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/io.h"
  40 #include "drivers/time.h"
  41
  42 // 20 MHz max SPI frequency
  43 #define FLASH_MAX_SPI_CLK_HZ 20000000
  44 // 5 MHz max SPI init frequency
  45 #define FLASH_MAX_SPI_INIT_CLK 5000000
  46
  47 static extDevice_t devInstance;
  48 static extDevice_t *dev;
  49
  50 static flashDevice_t flashDevice;
  51 static flashPartitionTable_t flashPartitionTable;
  52 static int flashPartitions = 0;
  53
  54 #define FLASH_INSTRUCTION_RDID 0x9F
  55
  56 #ifdef USE_QUADSPI
  57 static bool flashQuadSpiInit(const flashConfig_t *flashConfig)
  58 {
  59     bool detected = false;
  60
  61     enum { TRY_1LINE = 0, TRY_4LINE, BAIL};
  62     int phase = TRY_1LINE;
  63
  64     QUADSPI_TypeDef *hqspi = quadSpiInstanceByDevice(QUADSPI_CFG_TO_DEV(flashConfig->quadSpiDevice));
  65
  66     do {
  67         quadSpiSetDivisor(hqspi, QUADSPI_CLOCK_INITIALISATION);
  68
  69         // 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
  70         // assemble the chip id from the response.
  71         uint8_t readIdResponse[4];
  72
  73         bool status = false;
  74         switch (phase) {
  75         case TRY_1LINE:
  76             status = quadSpiReceive1LINE(hqspi, FLASH_INSTRUCTION_RDID, 0, readIdResponse, 4);
  77             break;
  78         case TRY_4LINE:
  79             status = quadSpiReceive4LINES(hqspi, FLASH_INSTRUCTION_RDID, 2, readIdResponse, 3);
  80             break;
  81         default:
  82             break;
  83         }
  84
  85         if (!status) {
  86             phase++;
  87             continue;
  88         }
  89
  90         flashDevice.io.handle.quadSpi = hqspi;
  91         flashDevice.io.mode = FLASHIO_QUADSPI;
  92
  93         quadSpiSetDivisor(hqspi, QUADSPI_CLOCK_ULTRAFAST);
  94
  95
  96         for (uint8_t offset = 0; offset <= 1 && !detected; offset++) {
  97
  98             uint32_t chipID = (readIdResponse[offset + 0] << 16) | (readIdResponse[offset + 1] << 8) | (readIdResponse[offset + 2]);
  99
 100             if (offset == 0) {
 101 #ifdef USE_FLASH_W25Q128FV
 102                 if (!detected && w25q128fv_detect(&flashDevice, chipID)) {
 103                     detected = true;
 104                 }
 105 #endif
 106             }
 107
 108             if (offset == 1) {
 109 #ifdef USE_FLASH_W25N01G
 110                 if (!detected && w25n01g_detect(&flashDevice, chipID)) {
 111                     detected = true;
 112                 }
 113 #endif
 114 #if defined(USE_FLASH_W25M02G)
 115                 if (!detected && w25m_detect(&flashDevice, chipID)) {
 116                     detected = true;
 117                 }
 118 #endif
 119             }
 120         }
 121         phase++;
 122     } while (phase != BAIL && !detected);
 123
 124     return detected;
 125 }
 126 #endif  // USE_QUADSPI
 127
 128 #ifdef USE_SPI
 129
 130 void flashPreInit(const flashConfig_t *flashConfig)
 131 {
 132     spiPreinitRegister(flashConfig->csTag, IOCFG_IPU, 1);
 133 }
 134
 135 static bool flashSpiInit(const flashConfig_t *flashConfig)
 136 {
 137     // Read chip identification and send it to device detect
 138     dev = &devInstance;
 139
 140     if (flashConfig->csTag) {
 141         dev->busType_u.spi.csnPin = IOGetByTag(flashConfig->csTag);
 142     } else {
 143         return false;
 144     }
 145
 146     if (!IOIsFreeOrPreinit(dev->busType_u.spi.csnPin)) {
 147         return false;
 148     }
 149
 150     if (!spiSetBusInstance(dev, flashConfig->spiDevice)) {
 151         return false;
 152     }
 153
 154     // Set the callback argument when calling back to this driver for DMA completion
 155     dev->callbackArg = (uint32_t)&flashDevice;
 156
 157     IOInit(dev->busType_u.spi.csnPin, OWNER_FLASH_CS, 0);
 158     IOConfigGPIO(dev->busType_u.spi.csnPin, SPI_IO_CS_CFG);
 159     IOHi(dev->busType_u.spi.csnPin);
 160
 161     //Maximum speed for standard READ command is 20mHz, other commands tolerate 25mHz
 162     spiSetClkDivisor(dev, spiCalculateDivider(FLASH_MAX_SPI_INIT_CLK));
 163
 164     flashDevice.io.mode = FLASHIO_SPI;
 165     flashDevice.io.handle.dev = dev;
 166
 167     delay(50); // short delay required after initialisation of SPI device instance.
 168
 169     /*
 170      * Some newer chips require one dummy byte to be read; we can read
 171      * 4 bytes for these chips while retaining backward compatibility.
 172      */
 173     uint8_t readIdResponse[4] = { 0 };
 174
 175     spiReadRegBuf(dev, FLASH_INSTRUCTION_RDID, readIdResponse, sizeof(readIdResponse));
 176
 177     // Manufacturer, memory type, and capacity
 178     uint32_t chipID = (readIdResponse[0] << 16) | (readIdResponse[1] << 8) | (readIdResponse[2]);
 179
 180 #ifdef USE_FLASH_M25P16
 181     if (m25p16_detect(&flashDevice, chipID)) {
 182         return true;
 183     }
 184 #endif
 185
 186 #ifdef USE_FLASH_W25M512
 187     if (w25m_detect(&flashDevice, chipID)) {
 188         return true;
 189     }
 190 #endif
 191
 192     // Newer chips
 193     chipID = (readIdResponse[1] << 16) | (readIdResponse[2] << 8) | (readIdResponse[3]);
 194
 195 #ifdef USE_FLASH_W25N01G
 196     if (w25n01g_detect(&flashDevice, chipID)) {
 197         return true;
 198     }
 199 #endif
 200
 201 #ifdef USE_FLASH_W25M02G
 202     if (w25m_detect(&flashDevice, chipID)) {
 203         return true;
 204     }
 205 #endif
 206
 207     spiPreinitByTag(flashConfig->csTag);
 208
 209     return false;
 210 }
 211 #endif // USE_SPI
 212
 213 bool flashDeviceInit(const flashConfig_t *flashConfig)
 214 {
 215 #ifdef USE_SPI
 216     bool useSpi = (SPI_CFG_TO_DEV(flashConfig->spiDevice) != SPIINVALID);
 217
 218     if (useSpi) {
 219         return flashSpiInit(flashConfig);
 220     }
 221 #endif
 222
 223 #ifdef USE_QUADSPI
 224     bool useQuadSpi = (QUADSPI_CFG_TO_DEV(flashConfig->quadSpiDevice) != QUADSPIINVALID);
 225     if (useQuadSpi) {
 226         return flashQuadSpiInit(flashConfig);
 227     }
 228 #endif
 229
 230     return false;
 231 }
 232
 233 bool flashIsReady(void)
 234 {
 235     return flashDevice.vTable->isReady(&flashDevice);
 236 }
 237
 238 bool flashWaitForReady(void)
 239 {
 240     return flashDevice.vTable->waitForReady(&flashDevice);
 241 }
 242
 243 void flashEraseSector(uint32_t address)
 244 {
 245     flashDevice.callback = NULL;
 246     flashDevice.vTable->eraseSector(&flashDevice, address);
 247 }
 248
 249 void flashEraseCompletely(void)
 250 {
 251     flashDevice.callback = NULL;
 252     flashDevice.vTable->eraseCompletely(&flashDevice);
 253 }
 254
 255 /* The callback, if provided, will receive the totoal number of bytes transfered
 256  * by each call to flashPageProgramContinue() once the transfer completes.
 257  */
 258 void flashPageProgramBegin(uint32_t address, void (*callback)(uint32_t length))
 259 {
 260     flashDevice.vTable->pageProgramBegin(&flashDevice, address, callback);
 261 }
 262
 263 uint32_t flashPageProgramContinue(const uint8_t **buffers, uint32_t *bufferSizes, uint32_t bufferCount)
 264 {
 265     uint32_t maxBytesToWrite = flashDevice.geometry.pageSize - (flashDevice.currentWriteAddress % flashDevice.geometry.pageSize);
 266
 267     if (bufferCount == 0) {
 268         return 0;
 269     }
 270
 271     if (bufferSizes[0] >= maxBytesToWrite) {
 272         bufferSizes[0] = maxBytesToWrite;
 273         bufferCount = 1;
 274     } else {
 275         maxBytesToWrite -= bufferSizes[0];
 276         if ((bufferCount == 2) && (bufferSizes[1] > maxBytesToWrite)) {
 277             bufferSizes[1] = maxBytesToWrite;
 278         }
 279     }
 280
 281     return flashDevice.vTable->pageProgramContinue(&flashDevice, buffers, bufferSizes, bufferCount);
 282 }
 283
 284 void flashPageProgramFinish(void)
 285 {
 286     flashDevice.vTable->pageProgramFinish(&flashDevice);
 287 }
 288
 289 void flashPageProgram(uint32_t address, const uint8_t *data, uint32_t length, void (*callback)(uint32_t length))
 290 {
 291     flashDevice.vTable->pageProgram(&flashDevice, address, data, length, callback);
 292 }
 293
 294 int flashReadBytes(uint32_t address, uint8_t *buffer, uint32_t length)
 295 {
 296     flashDevice.callback = NULL;
 297     return flashDevice.vTable->readBytes(&flashDevice, address, buffer, length);
 298 }
 299
 300 void flashFlush(void)
 301 {
 302     if (flashDevice.vTable->flush) {
 303         flashDevice.vTable->flush(&flashDevice);
 304     }
 305 }
 306
 307 static const flashGeometry_t noFlashGeometry = {
 308     .totalSize = 0,
 309 };
 310
 311 const flashGeometry_t *flashGetGeometry(void)
 312 {
 313     if (flashDevice.vTable && flashDevice.vTable->getGeometry) {
 314         return flashDevice.vTable->getGeometry(&flashDevice);
 315     }
 316
 317     return &noFlashGeometry;
 318 }
 319
 320 /*
 321  * Flash partitioning
 322  *
 323  * Partition table is not currently stored on the flash, in-memory only.
 324  *
 325  * Partitions are required so that Badblock management (inc spare blocks), FlashFS (Blackbox Logging), Configuration and Firmware can be kept separate and tracked.
 326  *
 327  * XXX FIXME
 328  * XXX Note that Flash FS must start at sector 0.
 329  * XXX There is existing blackbox/flash FS code the relies on this!!!
 330  * XXX This restriction can and will be fixed by creating a set of flash operation functions that take partition as an additional parameter.
 331  */
 332
 333 static void flashConfigurePartitions(void)
 334 {
 335
 336     const flashGeometry_t *flashGeometry = flashGetGeometry();
 337     if (flashGeometry->totalSize == 0) {
 338         return;
 339     }
 340
 341     flashSector_t startSector = 0;
 342     flashSector_t endSector = flashGeometry->sectors - 1; // 0 based index
 343
 344     const flashPartition_t *badBlockPartition = flashPartitionFindByType(FLASH_PARTITION_TYPE_BADBLOCK_MANAGEMENT);
 345     if (badBlockPartition) {
 346         endSector = badBlockPartition->startSector - 1;
 347     }
 348
 349 #if defined(FIRMWARE_SIZE)
 350     const uint32_t firmwareSize = (FIRMWARE_SIZE * 1024);
 351     flashSector_t firmwareSectors = (firmwareSize / flashGeometry->sectorSize);
 352
 353     if (firmwareSize % flashGeometry->sectorSize > 0) {
 354         firmwareSectors++; // needs a portion of a sector.
 355     }
 356
 357     startSector = (endSector + 1) - firmwareSectors; // + 1 for inclusive
 358
 359     flashPartitionSet(FLASH_PARTITION_TYPE_FIRMWARE, startSector, endSector);
 360
 361     endSector = startSector - 1;
 362     startSector = 0;
 363 #endif
 364
 365 #if defined(CONFIG_IN_EXTERNAL_FLASH)
 366     const uint32_t configSize = EEPROM_SIZE;
 367     flashSector_t configSectors = (configSize / flashGeometry->sectorSize);
 368
 369     if (configSize % flashGeometry->sectorSize > 0) {
 370         configSectors++; // needs a portion of a sector.
 371     }
 372
 373     startSector = (endSector + 1) - configSectors; // + 1 for inclusive
 374
 375     flashPartitionSet(FLASH_PARTITION_TYPE_CONFIG, startSector, endSector);
 376
 377     endSector = startSector - 1;
 378     startSector = 0;
 379 #endif
 380
 381 #ifdef USE_FLASHFS
 382     flashPartitionSet(FLASH_PARTITION_TYPE_FLASHFS, startSector, endSector);
 383 #endif
 384 }
 385
 386 flashPartition_t *flashPartitionFindByType(uint8_t type)
 387 {
 388     for (int index = 0; index < FLASH_MAX_PARTITIONS; index++) {
 389         flashPartition_t *candidate = &flashPartitionTable.partitions[index];
 390         if (candidate->type == type) {
 391             return candidate;
 392         }
 393     }
 394
 395     return NULL;
 396 }
 397
 398 const flashPartition_t *flashPartitionFindByIndex(uint8_t index)
 399 {
 400     if (index >= flashPartitions) {
 401         return NULL;
 402     }
 403
 404     return &flashPartitionTable.partitions[index];
 405 }
 406
 407 void flashPartitionSet(uint8_t type, uint32_t startSector, uint32_t endSector)
 408 {
 409     flashPartition_t *entry = flashPartitionFindByType(type);
 410
 411     if (!entry) {
 412         if (flashPartitions == FLASH_MAX_PARTITIONS - 1) {
 413             return;
 414         }
 415         entry = &flashPartitionTable.partitions[flashPartitions++];
 416     }
 417
 418     entry->type = type;
 419     entry->startSector = startSector;
 420     entry->endSector = endSector;
 421 }
 422
 423 // Must be in sync with FLASH_PARTITION_TYPE
 424 static const char *flashPartitionNames[] = {
 425     "UNKNOWN  ",
 426     "PARTITION",
 427     "FLASHFS  ",
 428     "BBMGMT   ",
 429     "FIRMWARE ",
 430     "CONFIG   ",
 431 };
 432
 433 const char *flashPartitionGetTypeName(flashPartitionType_e type)
 434 {
 435     if (type < ARRAYLEN(flashPartitionNames)) {
 436         return flashPartitionNames[type];
 437     }
 438
 439     return NULL;
 440 }
 441
 442 bool flashInit(const flashConfig_t *flashConfig)
 443 {
 444     memset(&flashPartitionTable, 0x00, sizeof(flashPartitionTable));
 445     flashPartitions = 0;
 446
 447     bool haveFlash = flashDeviceInit(flashConfig);
 448
 449     flashConfigurePartitions();
 450
 451     return haveFlash;
 452 }
 453
 454 int flashPartitionCount(void)
 455 {
 456     return flashPartitions;
 457 }
 458 #endif // USE_FLASH_CHIP