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, OWNER_FLASH_CS)) {
 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[2] << 16) | (readIdResponse[3] << 8) | (readIdResponse[4]);
 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 void flashPageProgramBegin(uint32_t address)
 256 {
 257     flashDevice.callback = NULL;
 258     flashDevice.vTable->pageProgramBegin(&flashDevice, address);
 259 }
 260
 261 void flashPageProgramContinue(const uint8_t *data, int length)
 262 {
 263     flashDevice.callback = NULL;
 264     flashDevice.vTable->pageProgramContinue(&flashDevice, data, length);
 265 }
 266
 267 void flashPageProgramFinish(void)
 268 {
 269     flashDevice.callback = NULL;
 270     flashDevice.vTable->pageProgramFinish(&flashDevice);
 271 }
 272
 273 void flashPageProgram(uint32_t address, const uint8_t *data, int length)
 274 {
 275     flashDevice.callback = NULL;
 276     flashDevice.vTable->pageProgram(&flashDevice, address, data, length);
 277 }
 278
 279 int flashReadBytes(uint32_t address, uint8_t *buffer, int length)
 280 {
 281     flashDevice.callback = NULL;
 282     return flashDevice.vTable->readBytes(&flashDevice, address, buffer, length);
 283 }
 284
 285 void flashFlush(void)
 286 {
 287     if (flashDevice.vTable->flush) {
 288         flashDevice.vTable->flush(&flashDevice);
 289     }
 290 }
 291
 292 static const flashGeometry_t noFlashGeometry = {
 293     .totalSize = 0,
 294 };
 295
 296 const flashGeometry_t *flashGetGeometry(void)
 297 {
 298     if (flashDevice.vTable && flashDevice.vTable->getGeometry) {
 299         return flashDevice.vTable->getGeometry(&flashDevice);
 300     }
 301
 302     return &noFlashGeometry;
 303 }
 304
 305 /*
 306  * Flash partitioning
 307  *
 308  * Partition table is not currently stored on the flash, in-memory only.
 309  *
 310  * Partitions are required so that Badblock management (inc spare blocks), FlashFS (Blackbox Logging), Configuration and Firmware can be kept separate and tracked.
 311  *
 312  * XXX FIXME
 313  * XXX Note that Flash FS must start at sector 0.
 314  * XXX There is existing blackbox/flash FS code the relies on this!!!
 315  * XXX This restriction can and will be fixed by creating a set of flash operation functions that take partition as an additional parameter.
 316  */
 317
 318 static void flashConfigurePartitions(void)
 319 {
 320
 321     const flashGeometry_t *flashGeometry = flashGetGeometry();
 322     if (flashGeometry->totalSize == 0) {
 323         return;
 324     }
 325
 326     flashSector_t startSector = 0;
 327     flashSector_t endSector = flashGeometry->sectors - 1; // 0 based index
 328
 329     const flashPartition_t *badBlockPartition = flashPartitionFindByType(FLASH_PARTITION_TYPE_BADBLOCK_MANAGEMENT);
 330     if (badBlockPartition) {
 331         endSector = badBlockPartition->startSector - 1;
 332     }
 333
 334 #if defined(FIRMWARE_SIZE)
 335     const uint32_t firmwareSize = (FIRMWARE_SIZE * 1024);
 336     flashSector_t firmwareSectors = (firmwareSize / flashGeometry->sectorSize);
 337
 338     if (firmwareSize % flashGeometry->sectorSize > 0) {
 339         firmwareSectors++; // needs a portion of a sector.
 340     }
 341
 342     startSector = (endSector + 1) - firmwareSectors; // + 1 for inclusive
 343
 344     flashPartitionSet(FLASH_PARTITION_TYPE_FIRMWARE, startSector, endSector);
 345
 346     endSector = startSector - 1;
 347     startSector = 0;
 348 #endif
 349
 350 #if defined(CONFIG_IN_EXTERNAL_FLASH)
 351     const uint32_t configSize = EEPROM_SIZE;
 352     flashSector_t configSectors = (configSize / flashGeometry->sectorSize);
 353
 354     if (configSize % flashGeometry->sectorSize > 0) {
 355         configSectors++; // needs a portion of a sector.
 356     }
 357
 358     startSector = (endSector + 1) - configSectors; // + 1 for inclusive
 359
 360     flashPartitionSet(FLASH_PARTITION_TYPE_CONFIG, startSector, endSector);
 361
 362     endSector = startSector - 1;
 363     startSector = 0;
 364 #endif
 365
 366 #ifdef USE_FLASHFS
 367     flashPartitionSet(FLASH_PARTITION_TYPE_FLASHFS, startSector, endSector);
 368 #endif
 369 }
 370
 371 flashPartition_t *flashPartitionFindByType(uint8_t type)
 372 {
 373     for (int index = 0; index < FLASH_MAX_PARTITIONS; index++) {
 374         flashPartition_t *candidate = &flashPartitionTable.partitions[index];
 375         if (candidate->type == type) {
 376             return candidate;
 377         }
 378     }
 379
 380     return NULL;
 381 }
 382
 383 const flashPartition_t *flashPartitionFindByIndex(uint8_t index)
 384 {
 385     if (index >= flashPartitions) {
 386         return NULL;
 387     }
 388
 389     return &flashPartitionTable.partitions[index];
 390 }
 391
 392 void flashPartitionSet(uint8_t type, uint32_t startSector, uint32_t endSector)
 393 {
 394     flashPartition_t *entry = flashPartitionFindByType(type);
 395
 396     if (!entry) {
 397         if (flashPartitions == FLASH_MAX_PARTITIONS - 1) {
 398             return;
 399         }
 400         entry = &flashPartitionTable.partitions[flashPartitions++];
 401     }
 402
 403     entry->type = type;
 404     entry->startSector = startSector;
 405     entry->endSector = endSector;
 406 }
 407
 408 // Must be in sync with FLASH_PARTITION_TYPE
 409 static const char *flashPartitionNames[] = {
 410     "UNKNOWN  ",
 411     "PARTITION",
 412     "FLASHFS  ",
 413     "BBMGMT   ",
 414     "FIRMWARE ",
 415     "CONFIG   ",
 416 };
 417
 418 const char *flashPartitionGetTypeName(flashPartitionType_e type)
 419 {
 420     if (type < ARRAYLEN(flashPartitionNames)) {
 421         return flashPartitionNames[type];
 422     }
 423
 424     return NULL;
 425 }
 426
 427 bool flashInit(const flashConfig_t *flashConfig)
 428 {
 429     memset(&flashPartitionTable, 0x00, sizeof(flashPartitionTable));
 430     flashPartitions = 0;
 431
 432     bool haveFlash = flashDeviceInit(flashConfig);
 433
 434     flashConfigurePartitions();
 435
 436     return haveFlash;
 437 }
 438
 439 int flashPartitionCount(void)
 440 {
 441     return flashPartitions;
 442 }
 443 #endif // USE_FLASH_CHIP