src/main/drivers/flash/flash_w25m.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 /*
  22  * Winbond W25M series stacked die flash driver.
  23  * Handles homogeneous stack of identical dies by calling die drivers.
  24  *
  25  * Author: jflyper
  26  */
  27
  28 #include <stdbool.h>
  29 #include <stdint.h>
  30
  31 #include "platform.h"
  32
  33 #include "build/debug.h"
  34
  35 #ifdef USE_FLASH_W25M
  36
  37 #include "common/maths.h"
  38 #include "drivers/bus_spi.h"
  39 #include "drivers/flash/flash.h"
  40 #include "drivers/flash/flash_impl.h"
  41 #include "drivers/io.h"
  42 #include "drivers/time.h"
  43
  44 #include "drivers/flash/flash_m25p16.h"
  45 #include "drivers/flash/flash_w25m.h"
  46 #include "drivers/flash/flash_w25n.h"
  47
  48 #include "pg/flash.h"
  49
  50 #define W25M_INSTRUCTION_SOFTWARE_DIE_SELECT         0xC2
  51
  52 #define JEDEC_ID_WINBOND_W25M512                     0xEF7119 // W25Q256 x 2
  53 #define JEDEC_ID_WINBOND_W25M02G                     0xEFAB21 // W25N01G x 2
  54 #define JEDEC_ID_WINBOND_W25Q256                     0xEF4019
  55 #define JEDEC_ID_WINBOND_W25N01GV                    0xEFAA21
  56
  57 static const flashVTable_t w25m_vTable;
  58
  59 #define MAX_DIE_COUNT 2
  60
  61 static flashDevice_t dieDevice[MAX_DIE_COUNT];
  62
  63 static int dieCount;
  64 static uint32_t dieSize;
  65
  66 static void w25m_dieSelect(const extDevice_t *dev, int die)
  67 {
  68     static int activeDie = -1;
  69
  70     if (activeDie == die) {
  71         return;
  72     }
  73
  74     uint8_t command[2] = { W25M_INSTRUCTION_SOFTWARE_DIE_SELECT, die };
  75
  76     busSegment_t segments[] = {
  77             {.u.buffers = {command, NULL}, sizeof(command), true, NULL},
  78             {.u.link = {NULL, NULL}, 0, true, NULL},
  79     };
  80
  81     // Ensure any prior DMA has completed before continuing
  82     spiWait(dev);
  83
  84     spiSequence(dev, &segments[0]);
  85
  86     // Block pending completion of SPI access, but the erase will be ongoing
  87     spiWait(dev);
  88
  89     activeDie = die;
  90 }
  91
  92 static bool w25m_isReady(flashDevice_t *fdevice)
  93 {
  94     for (int die = 0 ; die < dieCount ; die++) {
  95         if (dieDevice[die].couldBeBusy) {
  96             w25m_dieSelect(fdevice->io.handle.dev, die);
  97             if (!dieDevice[die].vTable->isReady(&dieDevice[die])) {
  98                 return false;
  99             }
 100         }
 101     }
 102
 103     return true;
 104 }
 105
 106 static bool w25m_waitForReady(flashDevice_t *fdevice)
 107 {
 108     for (int die = 0 ; die < dieCount ; die++) {
 109         w25m_dieSelect(fdevice->io.handle.dev, die);
 110         if (!dieDevice[die].vTable->waitForReady(&dieDevice[die])) {
 111             return false;
 112         }
 113     }
 114
 115     return true;
 116 }
 117
 118 bool w25m_identify(flashDevice_t *fdevice, uint32_t jedecID)
 119 {
 120
 121     switch (jedecID) {
 122 #ifdef USE_FLASH_W25M512
 123     case JEDEC_ID_WINBOND_W25M512:
 124         // W25Q256 x 2
 125         dieCount = 2;
 126
 127         for (int die = 0 ; die < dieCount ; die++) {
 128             w25m_dieSelect(fdevice->io.handle.dev, die);
 129             dieDevice[die].io.handle.dev = fdevice->io.handle.dev;
 130             dieDevice[die].io.mode = fdevice->io.mode;
 131             m25p16_identify(&dieDevice[die], JEDEC_ID_WINBOND_W25Q256);
 132         }
 133
 134         fdevice->geometry.flashType = FLASH_TYPE_NOR;
 135         break;
 136 #endif
 137
 138 #ifdef USE_FLASH_W25M02G
 139     case JEDEC_ID_WINBOND_W25M02G:
 140         // W25N01G x 2
 141         dieCount = 2;
 142
 143         for (int die = 0 ; die < dieCount ; die++) {
 144             w25m_dieSelect(fdevice->io.handle.dev, die);
 145             dieDevice[die].io.handle.dev = fdevice->io.handle.dev;
 146             dieDevice[die].io.mode = fdevice->io.mode;
 147             w25n_identify(&dieDevice[die], JEDEC_ID_WINBOND_W25N01GV);
 148         }
 149
 150         fdevice->geometry.flashType = FLASH_TYPE_NAND;
 151         break;
 152 #endif
 153
 154     default:
 155         // Not a valid W25M series device
 156         fdevice->geometry.sectors = 0;
 157         fdevice->geometry.pagesPerSector = 0;
 158         fdevice->geometry.sectorSize = 0;
 159         fdevice->geometry.totalSize = 0;
 160         return false;
 161     }
 162
 163     fdevice->geometry.sectors = dieDevice[0].geometry.sectors * dieCount;
 164     fdevice->geometry.sectorSize = dieDevice[0].geometry.sectorSize;
 165     fdevice->geometry.pagesPerSector = dieDevice[0].geometry.pagesPerSector;
 166     fdevice->geometry.pageSize = dieDevice[0].geometry.pageSize;
 167     dieSize = dieDevice[0].geometry.totalSize;
 168     fdevice->geometry.totalSize = dieSize * dieCount;
 169     fdevice->vTable = &w25m_vTable;
 170
 171     return true;
 172 }
 173
 174 void w25m_configure(flashDevice_t *fdevice, uint32_t configurationFlags)
 175 {
 176     for (int dieNumber = 0 ; dieNumber < dieCount ; dieNumber++) {
 177         w25m_dieSelect(fdevice->io.handle.dev, dieNumber);
 178         dieDevice[dieNumber].vTable->configure(&dieDevice[dieNumber], configurationFlags);
 179     }
 180 }
 181
 182 void w25m_eraseSector(flashDevice_t *fdevice, uint32_t address)
 183 {
 184     int dieNumber = address / dieSize;
 185
 186     w25m_dieSelect(fdevice->io.handle.dev, dieNumber);
 187
 188     dieDevice[dieNumber].vTable->eraseSector(&dieDevice[dieNumber], address % dieSize);
 189 }
 190
 191 void w25m_eraseCompletely(flashDevice_t *fdevice)
 192 {
 193     for (int dieNumber = 0 ; dieNumber < dieCount ; dieNumber++) {
 194         w25m_dieSelect(fdevice->io.handle.dev, dieNumber);
 195         dieDevice[dieNumber].vTable->eraseCompletely(&dieDevice[dieNumber]);
 196     }
 197 }
 198
 199 static uint32_t currentWriteAddress;
 200 static int currentWriteDie;
 201
 202 void w25m_pageProgramBegin(flashDevice_t *fdevice, uint32_t address, void (*callback)(uint32_t length))
 203 {
 204     currentWriteDie = address / dieSize;
 205     w25m_dieSelect(fdevice->io.handle.dev, currentWriteDie);
 206     currentWriteAddress = address % dieSize;
 207     dieDevice[currentWriteDie].vTable->pageProgramBegin(&dieDevice[currentWriteDie], address, callback);
 208 }
 209
 210 uint32_t w25m_pageProgramContinue(flashDevice_t *fdevice, uint8_t const **buffers, const uint32_t *bufferSizes, uint32_t bufferCount)
 211 {
 212     UNUSED(fdevice);
 213
 214     return dieDevice[currentWriteDie].vTable->pageProgramContinue(&dieDevice[currentWriteDie], buffers, bufferSizes, bufferCount);
 215 }
 216
 217 void w25m_pageProgramFinish(flashDevice_t *fdevice)
 218 {
 219     UNUSED(fdevice);
 220
 221     dieDevice[currentWriteDie].vTable->pageProgramFinish(&dieDevice[currentWriteDie]);
 222 }
 223
 224 void w25m_pageProgram(flashDevice_t *fdevice, uint32_t address, const uint8_t *data, uint32_t length, void (*callback)(uint32_t length))
 225 {
 226     w25m_pageProgramBegin(fdevice, address, callback);
 227
 228     w25m_pageProgramContinue(fdevice, &data, &length, 1);
 229
 230     w25m_pageProgramFinish(fdevice);
 231 }
 232
 233 int w25m_readBytes(flashDevice_t *fdevice, uint32_t address, uint8_t *buffer, uint32_t length)
 234 {
 235     int rlen; // remaining length
 236     int tlen; // transfer length for a round
 237     int rbytes;
 238
 239     // Divide a read that spans multiple dies into two.
 240     // The loop is executed twice at the most for decent 'length'.
 241
 242     for (rlen = length; rlen; rlen -= tlen) {
 243         int dieNumber = address / dieSize;
 244         uint32_t dieAddress = address % dieSize;
 245         tlen = MIN(dieAddress + rlen, dieSize) - dieAddress;
 246
 247         w25m_dieSelect(fdevice->io.handle.dev, dieNumber);
 248
 249         rbytes = dieDevice[dieNumber].vTable->readBytes(&dieDevice[dieNumber], dieAddress, buffer, tlen);
 250
 251         if (!rbytes) {
 252             return 0;
 253         }
 254
 255         address += tlen;
 256         buffer += tlen;
 257     }
 258     return length;
 259 }
 260
 261 const flashGeometry_t* w25m_getGeometry(flashDevice_t *fdevice)
 262 {
 263     return &fdevice->geometry;
 264 }
 265
 266 static const flashVTable_t w25m_vTable = {
 267     .configure = w25m_configure,
 268     .isReady = w25m_isReady,
 269     .waitForReady = w25m_waitForReady,
 270     .eraseSector = w25m_eraseSector,
 271     .eraseCompletely = w25m_eraseCompletely,
 272     .pageProgramBegin = w25m_pageProgramBegin,
 273     .pageProgramContinue = w25m_pageProgramContinue,
 274     .pageProgramFinish = w25m_pageProgramFinish,
 275     .pageProgram = w25m_pageProgram,
 276     .readBytes = w25m_readBytes,
 277     .getGeometry = w25m_getGeometry,
 278 };
 279 #endif