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_w25q128fv.h"
  36 #include "flash_w25m.h"
  37 #include "drivers/bus_spi.h"
  38 #include "drivers/bus_quadspi.h"
  39 #include "drivers/bus_octospi.h"
  40 #include "drivers/io.h"
  41 #include "drivers/time.h"
  42 #include "drivers/system.h"
  43
  44 #ifdef USE_FLASH_SPI
  45
  46 // 20 MHz max SPI frequency
  47 #define FLASH_MAX_SPI_CLK_HZ 20000000
  48 // 5 MHz max SPI init frequency
  49 #define FLASH_MAX_SPI_INIT_CLK 5000000
  50
  51 static extDevice_t devInstance;
  52 static extDevice_t *dev;
  53
  54 #endif
  55
  56 static flashDevice_t flashDevice;
  57 static flashPartitionTable_t flashPartitionTable;
  58 static int flashPartitions = 0;
  59
  60 #define FLASH_INSTRUCTION_RDID 0x9F
  61
  62 #ifdef USE_FLASH_MEMORY_MAPPED
  63 MMFLASH_CODE_NOINLINE void flashMemoryMappedModeDisable(void)
  64 {
  65     __disable_irq();
  66 #ifdef USE_FLASH_OCTOSPI
  67     octoSpiDisableMemoryMappedMode(flashDevice.io.handle.octoSpi);
  68 #else
  69 #error Invalid configuration - Not implemented
  70 #endif
  71 }
  72
  73 MMFLASH_CODE_NOINLINE void flashMemoryMappedModeEnable(void)
  74 {
  75 #ifdef USE_FLASH_OCTOSPI
  76     octoSpiEnableMemoryMappedMode(flashDevice.io.handle.octoSpi);
  77     __enable_irq();
  78 #else
  79 #error Invalid configuration - Not implemented
  80 #endif
  81 }
  82 #endif
  83
  84 #ifdef USE_FLASH_OCTOSPI
  85 MMFLASH_CODE_NOINLINE static bool flashOctoSpiInit(const flashConfig_t *flashConfig)
  86 {
  87     bool detected = false;
  88
  89     enum {
  90         TRY_1LINE = 0, TRY_4LINE, BAIL
  91     } phase = TRY_1LINE;
  92
  93 #ifdef USE_FLASH_MEMORY_MAPPED
  94     bool memoryMappedModeEnabledOnBoot = isMemoryMappedModeEnabledOnBoot();
  95 #else
  96     bool memoryMappedModeEnabledOnBoot = false;
  97 #endif
  98
  99 #ifndef USE_OCTOSPI_EXPERIMENTAL
 100     if (!memoryMappedModeEnabledOnBoot) {
 101         return false; // Not supported yet, enable USE_OCTOSPI_EXPERIMENTAL and test/update implementation as required.
 102     }
 103 #endif
 104
 105     OCTOSPI_TypeDef *instance = octoSpiInstanceByDevice(OCTOSPI_CFG_TO_DEV(flashConfig->octoSpiDevice));
 106
 107     flashDevice.io.handle.octoSpi = instance;
 108     flashDevice.io.mode = FLASHIO_OCTOSPI;
 109
 110     if (memoryMappedModeEnabledOnBoot) {
 111         flashMemoryMappedModeDisable();
 112     }
 113
 114     do {
 115 #ifdef USE_OCTOSPI_EXPERIMENTAL
 116         if (!memoryMappedMode) {
 117             octoSpiSetDivisor(instance, OCTOSPI_CLOCK_INITIALISATION);
 118         }
 119 #endif
 120         // for the memory-mapped use-case, we rely on the bootloader to have already selected the correct speed for the flash chip.
 121
 122         // 3 bytes for what we need, but some IC's need 8 dummy cycles after the instruction, so read 4 and make two attempts to
 123         // assemble the chip id from the response.
 124         uint8_t readIdResponse[4];
 125
 126         bool status = false;
 127         switch (phase) {
 128         case TRY_1LINE:
 129             status = octoSpiReceive1LINE(instance, FLASH_INSTRUCTION_RDID, 0, readIdResponse, 4);
 130             break;
 131         case TRY_4LINE:
 132             status = octoSpiReceive4LINES(instance, FLASH_INSTRUCTION_RDID, 2, readIdResponse, 3);
 133             break;
 134         default:
 135             break;
 136         }
 137
 138         if (!status) {
 139             phase++;
 140             continue;
 141         }
 142
 143 #ifdef USE_OCTOSPI_EXPERIMENTAL
 144         if (!memoryMappedModeEnabledOnBoot) {
 145             octoSpiSetDivisor(instance, OCTOSPI_CLOCK_ULTRAFAST);
 146         }
 147 #endif
 148
 149         for (uint8_t offset = 0; offset <= 1 && !detected; offset++) {
 150
 151             uint32_t jedecID = (readIdResponse[offset + 0] << 16) | (readIdResponse[offset + 1] << 8) | (readIdResponse[offset + 2]);
 152
 153             if (offset == 0) {
 154 #if defined(USE_FLASH_W25Q128FV)
 155                 if (!detected && w25q128fv_identify(&flashDevice, jedecID)) {
 156                     detected = true;
 157                 }
 158 #endif
 159             }
 160
 161             if (offset == 1) {
 162 #ifdef USE_OCTOSPI_EXPERIMENTAL
 163                 if (!memoryMappedModeEnabledOnBoot) {
 164                     // These flash chips DO NOT support memory mapped mode; suitable flash read commands must be available.
 165 #if defined(USE_FLASH_W25N01G)
 166                     if (!detected && w25n01g_identify(&flashDevice, jedecID)) {
 167                         detected = true;
 168                     }
 169 #endif
 170 #if defined(USE_FLASH_W25M02G)
 171                     if (!detected && w25m_identify(&flashDevice, jedecID)) {
 172                         detected = true;
 173                     }
 174 #endif
 175                 }
 176 #endif
 177             }
 178         }
 179         phase++;
 180     } while (phase != BAIL && !detected);
 181
 182     if (memoryMappedModeEnabledOnBoot) {
 183         flashMemoryMappedModeEnable();
 184     }
 185     return detected;
 186
 187 }
 188 #endif // USE_FLASH_OCTOSPI
 189
 190 #ifdef USE_FLASH_QUADSPI
 191 static bool flashQuadSpiInit(const flashConfig_t *flashConfig)
 192 {
 193     bool detected = false;
 194
 195     enum { TRY_1LINE = 0, TRY_4LINE, BAIL};
 196     int phase = TRY_1LINE;
 197
 198     QUADSPI_TypeDef *hqspi = quadSpiInstanceByDevice(QUADSPI_CFG_TO_DEV(flashConfig->quadSpiDevice));
 199
 200     flashDevice.io.handle.quadSpi = hqspi;
 201     flashDevice.io.mode = FLASHIO_QUADSPI;
 202
 203     do {
 204         quadSpiSetDivisor(hqspi, QUADSPI_CLOCK_INITIALISATION);
 205
 206         // 3 bytes for what we need, but some IC's need 8 dummy cycles after the instruction, so read 4 and make two attempts to
 207         // assemble the chip id from the response.
 208         uint8_t readIdResponse[4];
 209
 210         bool status = false;
 211         switch (phase) {
 212         case TRY_1LINE:
 213             status = quadSpiReceive1LINE(hqspi, FLASH_INSTRUCTION_RDID, 0, readIdResponse, 4);
 214             break;
 215         case TRY_4LINE:
 216             status = quadSpiReceive4LINES(hqspi, FLASH_INSTRUCTION_RDID, 2, readIdResponse, 3);
 217             break;
 218         default:
 219             break;
 220         }
 221
 222         if (!status) {
 223             phase++;
 224             continue;
 225         }
 226
 227         quadSpiSetDivisor(hqspi, QUADSPI_CLOCK_ULTRAFAST);
 228
 229
 230         for (uint8_t offset = 0; offset <= 1 && !detected; offset++) {
 231
 232             uint32_t jedecID = (readIdResponse[offset + 0] << 16) | (readIdResponse[offset + 1] << 8) | (readIdResponse[offset + 2]);
 233
 234             if (offset == 0) {
 235 #if defined(USE_FLASH_W25Q128FV)
 236                 if (!detected && w25q128fv_identify(&flashDevice, jedecID)) {
 237                     detected = true;
 238                 }
 239 #endif
 240
 241 #ifdef USE_FLASH_M25P16
 242                 if (!detected && m25p16_detect(&flashDevice, chipID)) {
 243                     detected = true;
 244                 }
 245 #endif
 246             }
 247
 248             if (offset == 1) {
 249 #if defined(USE_FLASH_W25N01G)
 250                 if (!detected && w25n01g_identify(&flashDevice, jedecID)) {
 251                     detected = true;
 252                 }
 253 #endif
 254 #if defined(USE_FLASH_W25M02G)
 255                 if (!detected && w25m_identify(&flashDevice, jedecID)) {
 256                     detected = true;
 257                 }
 258 #endif
 259             }
 260
 261             if (detected) {
 262                 flashDevice.geometry.jedecId = jedecID;
 263             }
 264         }
 265         phase++;
 266     } while (phase != BAIL && !detected);
 267
 268     return detected;
 269 }
 270 #endif  // USE_FLASH_QUADSPI
 271
 272 #ifdef USE_FLASH_SPI
 273 static bool flashSpiInit(const flashConfig_t *flashConfig)
 274 {
 275     bool detected = false;
 276     // Read chip identification and send it to device detect
 277     dev = &devInstance;
 278
 279     if (flashConfig->csTag) {
 280         dev->busType_u.spi.csnPin = IOGetByTag(flashConfig->csTag);
 281     } else {
 282         return false;
 283     }
 284
 285     if (!IOIsFreeOrPreinit(dev->busType_u.spi.csnPin)) {
 286         return false;
 287     }
 288
 289     if (!spiSetBusInstance(dev, flashConfig->spiDevice)) {
 290         return false;
 291     }
 292
 293     // Set the callback argument when calling back to this driver for DMA completion
 294     dev->callbackArg = (uint32_t)&flashDevice;
 295
 296     IOInit(dev->busType_u.spi.csnPin, OWNER_FLASH_CS, 0);
 297     IOConfigGPIO(dev->busType_u.spi.csnPin, SPI_IO_CS_CFG);
 298     IOHi(dev->busType_u.spi.csnPin);
 299
 300     //Maximum speed for standard READ command is 20mHz, other commands tolerate 25mHz
 301     spiSetClkDivisor(dev, spiCalculateDivider(FLASH_MAX_SPI_INIT_CLK));
 302
 303     flashDevice.io.mode = FLASHIO_SPI;
 304     flashDevice.io.handle.dev = dev;
 305
 306     delay(50); // short delay required after initialisation of SPI device instance.
 307
 308     /*
 309      * Some newer chips require one dummy byte to be read; we can read
 310      * 4 bytes for these chips while retaining backward compatibility.
 311      */
 312     uint8_t readIdResponse[4] = { 0 };
 313
 314     spiReadRegBuf(dev, FLASH_INSTRUCTION_RDID, readIdResponse, sizeof(readIdResponse));
 315
 316     // Manufacturer, memory type, and capacity
 317     uint32_t jedecID = (readIdResponse[0] << 16) | (readIdResponse[1] << 8) | (readIdResponse[2]);
 318
 319 #ifdef USE_FLASH_M25P16
 320     if (m25p16_identify(&flashDevice, jedecID)) {
 321         detected = true;
 322     }
 323 #endif
 324
 325 #if defined(USE_FLASH_W25M512) || defined(USE_FLASH_W25M)
 326     if (!detected && w25m_identify(&flashDevice, jedecID)) {
 327         detected = true;
 328     }
 329 #endif
 330
 331     if (!detected) {
 332         // Newer chips
 333         jedecID = (readIdResponse[1] << 16) | (readIdResponse[2] << 8) | (readIdResponse[3]);
 334     }
 335
 336 #ifdef USE_FLASH_W25N01G
 337     if (!detected && w25n01g_identify(&flashDevice, jedecID)) {
 338         detected = true;
 339     }
 340 #endif
 341
 342 #ifdef USE_FLASH_W25M02G
 343     if (!detected && w25m_identify(&flashDevice, jedecID)) {
 344         detected = true;
 345     }
 346 #endif
 347
 348     if (detected) {
 349         flashDevice.geometry.jedecId = jedecID;
 350         return detected;
 351     }
 352
 353     spiPreinitByTag(flashConfig->csTag);
 354
 355     return false;
 356 }
 357 #endif // USE_FLASH_SPI
 358
 359 void flashPreInit(const flashConfig_t *flashConfig)
 360 {
 361     spiPreinitRegister(flashConfig->csTag, IOCFG_IPU, 1);
 362 }
 363
 364 bool flashDeviceInit(const flashConfig_t *flashConfig)
 365 {
 366     bool haveFlash = false;
 367
 368 #ifdef USE_FLASH_SPI
 369     bool useSpi = (SPI_CFG_TO_DEV(flashConfig->spiDevice) != SPIINVALID);
 370
 371     if (useSpi) {
 372         haveFlash = flashSpiInit(flashConfig);
 373     }
 374 #endif
 375
 376 #ifdef USE_FLASH_QUADSPI
 377     bool useQuadSpi = (QUADSPI_CFG_TO_DEV(flashConfig->quadSpiDevice) != QUADSPIINVALID);
 378     if (useQuadSpi) {
 379         haveFlash = flashQuadSpiInit(flashConfig);
 380     }
 381 #endif
 382
 383 #ifdef USE_FLASH_OCTOSPI
 384     bool useOctoSpi = (OCTOSPI_CFG_TO_DEV(flashConfig->octoSpiDevice) != OCTOSPIINVALID);
 385     if (useOctoSpi) {
 386         haveFlash = flashOctoSpiInit(flashConfig);
 387     }
 388 #endif
 389
 390     if (haveFlash && flashDevice.vTable->configure) {
 391         uint32_t configurationFlags = 0;
 392
 393 #ifdef USE_FLASH_MEMORY_MAPPED
 394         if (isMemoryMappedModeEnabledOnBoot()) {
 395             configurationFlags |= FLASH_CF_SYSTEM_IS_MEMORY_MAPPED;
 396         }
 397 #endif
 398
 399         flashDevice.vTable->configure(&flashDevice, configurationFlags);
 400     }
 401
 402     return haveFlash;
 403 }
 404
 405 MMFLASH_CODE bool flashIsReady(void)
 406 {
 407     return flashDevice.vTable->isReady(&flashDevice);
 408 }
 409
 410 MMFLASH_CODE bool flashWaitForReady(void)
 411 {
 412     return flashDevice.vTable->waitForReady(&flashDevice);
 413 }
 414
 415 MMFLASH_CODE void flashEraseSector(uint32_t address)
 416 {
 417     flashDevice.callback = NULL;
 418     flashDevice.vTable->eraseSector(&flashDevice, address);
 419 }
 420
 421 void flashEraseCompletely(void)
 422 {
 423     flashDevice.callback = NULL;
 424     flashDevice.vTable->eraseCompletely(&flashDevice);
 425 }
 426
 427 /* The callback, if provided, will receive the totoal number of bytes transfered
 428  * by each call to flashPageProgramContinue() once the transfer completes.
 429  */
 430 MMFLASH_CODE void flashPageProgramBegin(uint32_t address, void (*callback)(uint32_t length))
 431 {
 432     flashDevice.vTable->pageProgramBegin(&flashDevice, address, callback);
 433 }
 434
 435 MMFLASH_CODE uint32_t flashPageProgramContinue(const uint8_t **buffers, uint32_t *bufferSizes, uint32_t bufferCount)
 436 {
 437     uint32_t maxBytesToWrite = flashDevice.geometry.pageSize - (flashDevice.currentWriteAddress % flashDevice.geometry.pageSize);
 438
 439     if (bufferCount == 0) {
 440         return 0;
 441     }
 442
 443     if (bufferSizes[0] >= maxBytesToWrite) {
 444         bufferSizes[0] = maxBytesToWrite;
 445         bufferCount = 1;
 446     } else {
 447         maxBytesToWrite -= bufferSizes[0];
 448         if ((bufferCount == 2) && (bufferSizes[1] > maxBytesToWrite)) {
 449             bufferSizes[1] = maxBytesToWrite;
 450         }
 451     }
 452
 453     return flashDevice.vTable->pageProgramContinue(&flashDevice, buffers, bufferSizes, bufferCount);
 454 }
 455
 456 MMFLASH_CODE void flashPageProgramFinish(void)
 457 {
 458     flashDevice.vTable->pageProgramFinish(&flashDevice);
 459 }
 460
 461 MMFLASH_CODE void flashPageProgram(uint32_t address, const uint8_t *data, uint32_t length, void (*callback)(uint32_t length))
 462 {
 463     flashDevice.vTable->pageProgram(&flashDevice, address, data, length, callback);
 464 }
 465
 466 MMFLASH_CODE int flashReadBytes(uint32_t address, uint8_t *buffer, uint32_t length)
 467 {
 468     flashDevice.callback = NULL;
 469     return flashDevice.vTable->readBytes(&flashDevice, address, buffer, length);
 470 }
 471
 472 MMFLASH_CODE void flashFlush(void)
 473 {
 474     if (flashDevice.vTable->flush) {
 475         flashDevice.vTable->flush(&flashDevice);
 476     }
 477 }
 478
 479 static const flashGeometry_t noFlashGeometry = {
 480     .totalSize = 0,
 481 };
 482
 483 const flashGeometry_t *flashGetGeometry(void)
 484 {
 485     if (flashDevice.vTable && flashDevice.vTable->getGeometry) {
 486         return flashDevice.vTable->getGeometry(&flashDevice);
 487     }
 488
 489     return &noFlashGeometry;
 490 }
 491
 492 /*
 493  * Flash partitioning
 494  *
 495  * Partition table is not currently stored on the flash, in-memory only.
 496  *
 497  * Partitions are required so that Badblock management (inc spare blocks), FlashFS (Blackbox Logging), Configuration and Firmware can be kept separate and tracked.
 498  *
 499  * XXX FIXME
 500  * XXX Note that Flash FS must start at sector 0.
 501  * XXX There is existing blackbox/flash FS code the relies on this!!!
 502  * XXX This restriction can and will be fixed by creating a set of flash operation functions that take partition as an additional parameter.
 503  */
 504
 505 static void flashConfigurePartitions(void)
 506 {
 507 #if defined(FIRMWARE_SIZE) || defined(CONFIG_IN_EXTERNAL_FLASH) || defined(USE_FLASHFS)
 508     const flashGeometry_t *flashGeometry = flashGetGeometry();
 509     if (flashGeometry->totalSize == 0) {
 510         return;
 511     }
 512
 513     flashSector_t startSector = 0;
 514     flashSector_t endSector = flashGeometry->sectors - 1; // 0 based index
 515
 516     const flashPartition_t *badBlockPartition = flashPartitionFindByType(FLASH_PARTITION_TYPE_BADBLOCK_MANAGEMENT);
 517     if (badBlockPartition) {
 518         endSector = badBlockPartition->startSector - 1;
 519     }
 520 #endif
 521
 522 #if defined(FIRMWARE_SIZE)
 523     const uint32_t firmwareSize = (FIRMWARE_SIZE * 1024);
 524     flashSector_t firmwareSectors = (firmwareSize / flashGeometry->sectorSize);
 525
 526     if (firmwareSize % flashGeometry->sectorSize > 0) {
 527         firmwareSectors++; // needs a portion of a sector.
 528     }
 529
 530     startSector = (endSector + 1) - firmwareSectors; // + 1 for inclusive
 531
 532     flashPartitionSet(FLASH_PARTITION_TYPE_FIRMWARE, startSector, endSector);
 533
 534     endSector = startSector - 1;
 535     startSector = 0;
 536 #endif
 537
 538 #if defined(CONFIG_IN_EXTERNAL_FLASH) || defined(CONFIG_IN_MEMORY_MAPPED_FLASH)
 539     const uint32_t configSize = EEPROM_SIZE;
 540     flashSector_t configSectors = (configSize / flashGeometry->sectorSize);
 541
 542     if (configSize % flashGeometry->sectorSize > 0) {
 543         configSectors++; // needs a portion of a sector.
 544     }
 545
 546     startSector = (endSector + 1) - configSectors; // + 1 for inclusive
 547
 548     flashPartitionSet(FLASH_PARTITION_TYPE_CONFIG, startSector, endSector);
 549
 550     endSector = startSector - 1;
 551     startSector = 0;
 552 #endif
 553
 554 #ifdef USE_FLASHFS
 555     flashPartitionSet(FLASH_PARTITION_TYPE_FLASHFS, startSector, endSector);
 556 #endif
 557 }
 558
 559 flashPartition_t *flashPartitionFindByType(uint8_t type)
 560 {
 561     for (int index = 0; index < FLASH_MAX_PARTITIONS; index++) {
 562         flashPartition_t *candidate = &flashPartitionTable.partitions[index];
 563         if (candidate->type == type) {
 564             return candidate;
 565         }
 566     }
 567
 568     return NULL;
 569 }
 570
 571 const flashPartition_t *flashPartitionFindByIndex(uint8_t index)
 572 {
 573     if (index >= flashPartitions) {
 574         return NULL;
 575     }
 576
 577     return &flashPartitionTable.partitions[index];
 578 }
 579
 580 void flashPartitionSet(uint8_t type, uint32_t startSector, uint32_t endSector)
 581 {
 582     flashPartition_t *entry = flashPartitionFindByType(type);
 583
 584     if (!entry) {
 585         if (flashPartitions == FLASH_MAX_PARTITIONS - 1) {
 586             return;
 587         }
 588         entry = &flashPartitionTable.partitions[flashPartitions++];
 589     }
 590
 591     entry->type = type;
 592     entry->startSector = startSector;
 593     entry->endSector = endSector;
 594 }
 595
 596 // Must be in sync with FLASH_PARTITION_TYPE
 597 static const char *flashPartitionNames[] = {
 598     "UNKNOWN  ",
 599     "PARTITION",
 600     "FLASHFS  ",
 601     "BBMGMT   ",
 602     "FIRMWARE ",
 603     "CONFIG   ",
 604 };
 605
 606 const char *flashPartitionGetTypeName(flashPartitionType_e type)
 607 {
 608     if (type < ARRAYLEN(flashPartitionNames)) {
 609         return flashPartitionNames[type];
 610     }
 611
 612     return NULL;
 613 }
 614
 615 bool flashInit(const flashConfig_t *flashConfig)
 616 {
 617     memset(&flashPartitionTable, 0x00, sizeof(flashPartitionTable));
 618     flashPartitions = 0;
 619
 620     bool haveFlash = flashDeviceInit(flashConfig);
 621
 622     flashConfigurePartitions();
 623
 624     return haveFlash;
 625 }
 626
 627 int flashPartitionCount(void)
 628 {
 629     return flashPartitions;
 630 }
 631 #endif // USE_FLASH_CHIP