src/main/drivers/flash.c

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are 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  * Cleanflight and Betaflight are distributed in the hope that they
  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_FLASH_CHIP
  30
  31 #include "flash.h"
  32 #include "flash_impl.h"
  33 #include "flash_m25p16.h"
  34 #include "flash_w25n01g.h"
  35 #include "flash_w25m.h"
  36 #include "drivers/bus_spi.h"
  37 #include "drivers/bus_quadspi.h"
  38 #include "drivers/io.h"
  39 #include "drivers/time.h"
  40
  41 static busDevice_t busInstance;
  42 static busDevice_t *busdev;
  43
  44 static flashDevice_t flashDevice;
  45 static flashPartitionTable_t flashPartitionTable;
  46 static int flashPartitions = 0;
  47
  48 #define FLASH_INSTRUCTION_RDID 0x9F
  49
  50 #ifdef USE_QUADSPI
  51 static bool flashQuadSpiInit(const flashConfig_t *flashConfig)
  52 {
  53     QUADSPI_TypeDef *quadSpiInstance = quadSpiInstanceByDevice(QUADSPI_CFG_TO_DEV(flashConfig->quadSpiDevice));
  54     quadSpiSetDivisor(quadSpiInstance, QUADSPI_CLOCK_INITIALISATION);
  55
  56     uint8_t readIdResponse[4];
  57     bool status = quadSpiReceive1LINE(quadSpiInstance, FLASH_INSTRUCTION_RDID, 8, readIdResponse, sizeof(readIdResponse));
  58     if (!status) {
  59         return false;
  60     }
  61
  62     flashDevice.io.mode = FLASHIO_QUADSPI;
  63     flashDevice.io.handle.quadSpi = quadSpiInstance;
  64
  65     // Manufacturer, memory type, and capacity
  66     uint32_t chipID = (readIdResponse[0] << 16) | (readIdResponse[1] << 8) | (readIdResponse[2]);
  67
  68 #ifdef USE_FLASH_W25N01G
  69     quadSpiSetDivisor(quadSpiInstance, QUADSPI_CLOCK_ULTRAFAST);
  70
  71     if (w25n01g_detect(&flashDevice, chipID)) {
  72         return true;
  73     }
  74 #endif
  75
  76     return false;
  77 }
  78 #endif  // USE_QUADSPI
  79
  80 #ifdef USE_SPI
  81
  82 void flashPreInit(const flashConfig_t *flashConfig)
  83 {
  84     spiPreinitRegister(flashConfig->csTag, IOCFG_IPU, 1);
  85 }
  86
  87 static bool flashSpiInit(const flashConfig_t *flashConfig)
  88 {
  89     // Read chip identification and send it to device detect
  90
  91     busdev = &busInstance;
  92
  93     if (flashConfig->csTag) {
  94         busdev->busdev_u.spi.csnPin = IOGetByTag(flashConfig->csTag);
  95     } else {
  96         return false;
  97     }
  98
  99     if (!IOIsFreeOrPreinit(busdev->busdev_u.spi.csnPin)) {
 100         return false;
 101     }
 102
 103     busdev->bustype = BUSTYPE_SPI;
 104
 105     SPI_TypeDef *instance = spiInstanceByDevice(SPI_CFG_TO_DEV(flashConfig->spiDevice));
 106     if (!instance) {
 107         return false;
 108     }
 109
 110     spiBusSetInstance(busdev, instance);
 111
 112     IOInit(busdev->busdev_u.spi.csnPin, OWNER_FLASH_CS, 0);
 113     IOConfigGPIO(busdev->busdev_u.spi.csnPin, SPI_IO_CS_CFG);
 114     IOHi(busdev->busdev_u.spi.csnPin);
 115
 116 #ifdef USE_SPI_TRANSACTION
 117     spiBusTransactionInit(busdev, SPI_MODE3_POL_HIGH_EDGE_2ND, SPI_CLOCK_FAST);
 118 #else
 119 #ifndef FLASH_SPI_SHARED
 120     //Maximum speed for standard READ command is 20mHz, other commands tolerate 25mHz
 121     //spiSetDivisor(busdev->busdev_u.spi.instance, SPI_CLOCK_FAST);
 122     spiSetDivisor(busdev->busdev_u.spi.instance, SPI_CLOCK_STANDARD*2);
 123 #endif
 124 #endif
 125
 126     flashDevice.io.mode = FLASHIO_SPI;
 127     flashDevice.io.handle.busdev = busdev;
 128
 129     const uint8_t out[] = { FLASH_INSTRUCTION_RDID, 0, 0, 0, 0 };
 130
 131     delay(50); // short delay required after initialisation of SPI device instance.
 132
 133     /*
 134      * Some newer chips require one dummy byte to be read; we can read
 135      * 4 bytes for these chips while retaining backward compatibility.
 136      */
 137     uint8_t readIdResponse[5];
 138     readIdResponse[1] = readIdResponse[2] = 0;
 139
 140     // Clearing the CS bit terminates the command early so we don't have to read the chip UID:
 141 #ifdef USE_SPI_TRANSACTION
 142     spiBusTransactionTransfer(busdev, out, readIdResponse, sizeof(out));
 143 #else
 144     spiBusTransfer(busdev, out, readIdResponse, sizeof(out));
 145 #endif
 146
 147     // Manufacturer, memory type, and capacity
 148     uint32_t chipID = (readIdResponse[1] << 16) | (readIdResponse[2] << 8) | (readIdResponse[3]);
 149
 150 #ifdef USE_FLASH_M25P16
 151     if (m25p16_detect(&flashDevice, chipID)) {
 152         return true;
 153     }
 154 #endif
 155
 156 #ifdef USE_FLASH_W25M512
 157     if (w25m_detect(&flashDevice, chipID)) {
 158         return true;
 159     }
 160 #endif
 161
 162     // Newer chips
 163     chipID = (readIdResponse[2] << 16) | (readIdResponse[3] << 8) | (readIdResponse[4]);
 164
 165 #ifdef USE_FLASH_W25N01G
 166     if (w25n01g_detect(&flashDevice, chipID)) {
 167         return true;
 168     }
 169 #endif
 170
 171 #ifdef USE_FLASH_W25M02G
 172     if (w25m_detect(&flashDevice, chipID)) {
 173         return true;
 174     }
 175 #endif
 176
 177     spiPreinitByTag(flashConfig->csTag);
 178
 179     return false;
 180 }
 181 #endif // USE_SPI
 182
 183 bool flashDeviceInit(const flashConfig_t *flashConfig)
 184 {
 185 #ifdef USE_SPI
 186     bool useSpi = (SPI_CFG_TO_DEV(flashConfig->spiDevice) != SPIINVALID);
 187
 188     if (useSpi) {
 189         return flashSpiInit(flashConfig);
 190     }
 191 #endif
 192
 193 #ifdef USE_QUADSPI
 194     bool useQuadSpi = (QUADSPI_CFG_TO_DEV(flashConfig->quadSpiDevice) != QUADSPIINVALID);
 195     if (useQuadSpi) {
 196         return flashQuadSpiInit(flashConfig);
 197     }
 198 #endif
 199
 200     return false;
 201 }
 202
 203 bool flashIsReady(void)
 204 {
 205     return flashDevice.vTable->isReady(&flashDevice);
 206 }
 207
 208 bool flashWaitForReady(void)
 209 {
 210     return flashDevice.vTable->waitForReady(&flashDevice);
 211 }
 212
 213 void flashEraseSector(uint32_t address)
 214 {
 215     flashDevice.vTable->eraseSector(&flashDevice, address);
 216 }
 217
 218 void flashEraseCompletely(void)
 219 {
 220     flashDevice.vTable->eraseCompletely(&flashDevice);
 221 }
 222
 223 void flashPageProgramBegin(uint32_t address)
 224 {
 225     flashDevice.vTable->pageProgramBegin(&flashDevice, address);
 226 }
 227
 228 void flashPageProgramContinue(const uint8_t *data, int length)
 229 {
 230     flashDevice.vTable->pageProgramContinue(&flashDevice, data, length);
 231 }
 232
 233 void flashPageProgramFinish(void)
 234 {
 235     flashDevice.vTable->pageProgramFinish(&flashDevice);
 236 }
 237
 238 void flashPageProgram(uint32_t address, const uint8_t *data, int length)
 239 {
 240     flashDevice.vTable->pageProgram(&flashDevice, address, data, length);
 241 }
 242
 243 int flashReadBytes(uint32_t address, uint8_t *buffer, int length)
 244 {
 245     return flashDevice.vTable->readBytes(&flashDevice, address, buffer, length);
 246 }
 247
 248 void flashFlush(void)
 249 {
 250     if (flashDevice.vTable->flush) {
 251         flashDevice.vTable->flush(&flashDevice);
 252     }
 253 }
 254
 255 static const flashGeometry_t noFlashGeometry = {
 256     .totalSize = 0,
 257 };
 258
 259 const flashGeometry_t *flashGetGeometry(void)
 260 {
 261     if (flashDevice.vTable && flashDevice.vTable->getGeometry) {
 262         return flashDevice.vTable->getGeometry(&flashDevice);
 263     }
 264
 265     return &noFlashGeometry;
 266 }
 267
 268 /*
 269  * Flash partitioning
 270  *
 271  * Partition table is not currently stored on the flash, in-memory only.
 272  *
 273  * Partitions are required so that Badblock management (inc spare blocks), FlashFS (Blackbox Logging), Configuration and Firmware can be kept separate and tracked.
 274  *
 275  * XXX FIXME
 276  * XXX Note that Flash FS must start at sector 0.
 277  * XXX There is existing blackbox/flash FS code the relies on this!!!
 278  * XXX This restriction can and will be fixed by creating a set of flash operation functions that take partition as an additional parameter.
 279  */
 280
 281 static void flashConfigurePartitions(void)
 282 {
 283
 284     const flashGeometry_t *flashGeometry = flashGetGeometry();
 285     if (flashGeometry->totalSize == 0) {
 286         return;
 287     }
 288
 289     flashSector_t startSector = 0;
 290     flashSector_t endSector = flashGeometry->sectors - 1; // 0 based index
 291
 292     const flashPartition_t *badBlockPartition = flashPartitionFindByType(FLASH_PARTITION_TYPE_BADBLOCK_MANAGEMENT);
 293     if (badBlockPartition) {
 294         endSector = badBlockPartition->startSector - 1;
 295     }
 296
 297 #if defined(FIRMWARE_SIZE)
 298     const uint32_t firmwareSize = (FIRMWARE_SIZE * 1024);
 299     flashSector_t firmwareSectors = (firmwareSize / flashGeometry->sectorSize);
 300
 301     if (firmwareSize % flashGeometry->sectorSize > 0) {
 302         firmwareSectors++; // needs a portion of a sector.
 303     }
 304
 305     startSector = (endSector + 1) - firmwareSectors; // + 1 for inclusive
 306
 307     flashPartitionSet(FLASH_PARTITION_TYPE_FIRMWARE, startSector, endSector);
 308
 309     endSector = startSector - 1;
 310     startSector = 0;
 311 #endif
 312
 313 #if defined(CONFIG_IN_EXTERNAL_FLASH)
 314     const uint32_t configSize = EEPROM_SIZE;
 315     flashSector_t configSectors = (configSize / flashGeometry->sectorSize);
 316
 317     if (configSize % flashGeometry->sectorSize > 0) {
 318         configSectors++; // needs a portion of a sector.
 319     }
 320
 321     startSector = (endSector + 1) - configSectors; // + 1 for inclusive
 322
 323     flashPartitionSet(FLASH_PARTITION_TYPE_CONFIG, startSector, endSector);
 324
 325     endSector = startSector - 1;
 326     startSector = 0;
 327 #endif
 328
 329 #ifdef USE_FLASHFS
 330     flashPartitionSet(FLASH_PARTITION_TYPE_FLASHFS, startSector, endSector);
 331 #endif
 332 }
 333
 334 flashPartition_t *flashPartitionFindByType(uint8_t type)
 335 {
 336     for (int index = 0; index < FLASH_MAX_PARTITIONS; index++) {
 337         flashPartition_t *candidate = &flashPartitionTable.partitions[index];
 338         if (candidate->type == type) {
 339             return candidate;
 340         }
 341     }
 342
 343     return NULL;
 344 }
 345
 346 const flashPartition_t *flashPartitionFindByIndex(uint8_t index)
 347 {
 348     if (index >= flashPartitions) {
 349         return NULL;
 350     }
 351
 352     return &flashPartitionTable.partitions[index];
 353 }
 354
 355 void flashPartitionSet(uint8_t type, uint32_t startSector, uint32_t endSector)
 356 {
 357     flashPartition_t *entry = flashPartitionFindByType(type);
 358
 359     if (!entry) {
 360         if (flashPartitions == FLASH_MAX_PARTITIONS - 1) {
 361             return;
 362         }
 363         entry = &flashPartitionTable.partitions[flashPartitions++];
 364     }
 365
 366     entry->type = type;
 367     entry->startSector = startSector;
 368     entry->endSector = endSector;
 369 }
 370
 371 // Must be in sync with FLASH_PARTITION_TYPE
 372 static const char *flashPartitionNames[] = {
 373     "UNKNOWN  ",
 374     "PARTITION",
 375     "FLASHFS  ",
 376     "BBMGMT   ",
 377     "FIRMWARE ",
 378     "CONFIG   ",
 379 };
 380
 381 const char *flashPartitionGetTypeName(flashPartitionType_e type)
 382 {
 383     if (type < ARRAYLEN(flashPartitionNames)) {
 384         return flashPartitionNames[type];
 385     }
 386
 387     return NULL;
 388 }
 389
 390 bool flashInit(const flashConfig_t *flashConfig)
 391 {
 392     memset(&flashPartitionTable, 0x00, sizeof(flashPartitionTable));
 393
 394     bool haveFlash = flashDeviceInit(flashConfig);
 395
 396     flashConfigurePartitions();
 397
 398     return haveFlash;
 399 }
 400
 401 int flashPartitionCount(void)
 402 {
 403     return flashPartitions;
 404 }
 405 #endif // USE_FLASH_CHIP