blob: 913db0dd6a8debde938a10e7b11af3421fa8ccef [file] [log] [blame]
Thomas Gleixner1a59d1b82019-05-27 08:55:05 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
David Woodhousea1452a32010-08-08 20:58:20 +01003 * Linux driver for NAND Flash Translation Layer
4 *
5 * Copyright © 1999 Machine Vision Holdings, Inc.
6 * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 */
8
9#define PRERELEASE
10
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/kernel.h>
12#include <linux/module.h>
13#include <asm/errno.h>
14#include <asm/io.h>
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080015#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/delay.h>
17#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/init.h>
19#include <linux/hdreg.h>
Scott James Remnante7f52162009-03-02 17:43:04 +000020#include <linux/blkdev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
22#include <linux/kmod.h>
23#include <linux/mtd/mtd.h>
Boris Brezillond4092d72017-08-04 17:29:10 +020024#include <linux/mtd/rawnand.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/mtd/nftl.h>
26#include <linux/mtd/blktrans.h>
27
28/* maximum number of loops while examining next block, to have a
29 chance to detect consistency problems (they should never happen
30 because of the checks done in the mounting */
31
32#define MAX_LOOPS 10000
33
34
35static void nftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
36{
37 struct NFTLrecord *nftl;
38 unsigned long temp;
39
Huang Shijie818b9732013-09-25 14:58:17 +080040 if (!mtd_type_is_nand(mtd) || mtd->size > UINT_MAX)
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 return;
42 /* OK, this is moderately ugly. But probably safe. Alternatives? */
43 if (memcmp(mtd->name, "DiskOnChip", 10))
44 return;
45
Brian Norris289c0522011-07-19 10:06:09 -070046 pr_debug("NFTL: add_mtd for %s\n", mtd->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
Burman Yan95b93a02006-11-15 21:10:29 +020048 nftl = kzalloc(sizeof(struct NFTLrecord), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
Brian Norris08700662011-06-07 16:01:54 -070050 if (!nftl)
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
53 nftl->mbd.mtd = mtd;
54 nftl->mbd.devnum = -1;
Richard Purdie19187672006-10-27 09:09:33 +010055
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 nftl->mbd.tr = tr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
58 if (NFTL_mount(nftl) < 0) {
59 printk(KERN_WARNING "NFTL: could not mount device\n");
60 kfree(nftl);
61 return;
62 }
63
64 /* OK, it's a new one. Set up all the data structures. */
65
66 /* Calculate geometry */
67 nftl->cylinders = 1024;
68 nftl->heads = 16;
69
70 temp = nftl->cylinders * nftl->heads;
71 nftl->sectors = nftl->mbd.size / temp;
72 if (nftl->mbd.size % temp) {
73 nftl->sectors++;
74 temp = nftl->cylinders * nftl->sectors;
75 nftl->heads = nftl->mbd.size / temp;
76
77 if (nftl->mbd.size % temp) {
78 nftl->heads++;
79 temp = nftl->heads * nftl->sectors;
80 nftl->cylinders = nftl->mbd.size / temp;
81 }
82 }
83
84 if (nftl->mbd.size != nftl->heads * nftl->cylinders * nftl->sectors) {
85 /*
Thomas Gleixner97894cd2005-11-07 11:15:26 +000086 Oh no we don't have
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 mbd.size == heads * cylinders * sectors
88 */
89 printk(KERN_WARNING "NFTL: cannot calculate a geometry to "
90 "match size of 0x%lx.\n", nftl->mbd.size);
91 printk(KERN_WARNING "NFTL: using C:%d H:%d S:%d "
92 "(== 0x%lx sects)\n",
Thomas Gleixner97894cd2005-11-07 11:15:26 +000093 nftl->cylinders, nftl->heads , nftl->sectors,
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 (long)nftl->cylinders * (long)nftl->heads *
95 (long)nftl->sectors );
96 }
97
98 if (add_mtd_blktrans_dev(&nftl->mbd)) {
Jesper Juhlfa671642005-11-07 01:01:27 -080099 kfree(nftl->ReplUnitTable);
100 kfree(nftl->EUNtable);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 kfree(nftl);
102 return;
103 }
104#ifdef PSYCHO_DEBUG
105 printk(KERN_INFO "NFTL: Found new nftl%c\n", nftl->mbd.devnum + 'a');
106#endif
107}
108
109static void nftl_remove_dev(struct mtd_blktrans_dev *dev)
110{
111 struct NFTLrecord *nftl = (void *)dev;
112
Brian Norris289c0522011-07-19 10:06:09 -0700113 pr_debug("NFTL: remove_dev (i=%d)\n", dev->devnum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
115 del_mtd_blktrans_dev(dev);
Jesper Juhlfa671642005-11-07 01:01:27 -0800116 kfree(nftl->ReplUnitTable);
117 kfree(nftl->EUNtable);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118}
119
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200120/*
121 * Read oob data from flash
122 */
123int nftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
124 size_t *retlen, uint8_t *buf)
125{
Dimitri Gorokhovik16f05c22009-09-03 14:04:22 +0100126 loff_t mask = mtd->writesize - 1;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200127 struct mtd_oob_ops ops;
128 int res;
129
Brian Norris0612b9d2011-08-30 18:45:40 -0700130 ops.mode = MTD_OPS_PLACE_OOB;
Dimitri Gorokhovik16f05c22009-09-03 14:04:22 +0100131 ops.ooboffs = offs & mask;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200132 ops.ooblen = len;
133 ops.oobbuf = buf;
134 ops.datbuf = NULL;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200135
Artem Bityutskiyfd2819b2011-12-23 18:27:05 +0200136 res = mtd_read_oob(mtd, offs & ~mask, &ops);
Vitaly Wool70145682006-11-03 18:20:38 +0300137 *retlen = ops.oobretlen;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200138 return res;
139}
140
141/*
142 * Write oob data to flash
143 */
144int nftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
145 size_t *retlen, uint8_t *buf)
146{
Dimitri Gorokhovik16f05c22009-09-03 14:04:22 +0100147 loff_t mask = mtd->writesize - 1;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200148 struct mtd_oob_ops ops;
149 int res;
150
Brian Norris0612b9d2011-08-30 18:45:40 -0700151 ops.mode = MTD_OPS_PLACE_OOB;
Dimitri Gorokhovik16f05c22009-09-03 14:04:22 +0100152 ops.ooboffs = offs & mask;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200153 ops.ooblen = len;
154 ops.oobbuf = buf;
155 ops.datbuf = NULL;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200156
Artem Bityutskiya2cc5ba2011-12-23 18:29:55 +0200157 res = mtd_write_oob(mtd, offs & ~mask, &ops);
Vitaly Wool70145682006-11-03 18:20:38 +0300158 *retlen = ops.oobretlen;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200159 return res;
160}
161
Frederik Deweerdt553a8012006-10-02 09:42:25 +0100162#ifdef CONFIG_NFTL_RW
163
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200164/*
165 * Write data and oob to flash
166 */
167static int nftl_write(struct mtd_info *mtd, loff_t offs, size_t len,
168 size_t *retlen, uint8_t *buf, uint8_t *oob)
169{
Dimitri Gorokhovik16f05c22009-09-03 14:04:22 +0100170 loff_t mask = mtd->writesize - 1;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200171 struct mtd_oob_ops ops;
172 int res;
173
Brian Norris0612b9d2011-08-30 18:45:40 -0700174 ops.mode = MTD_OPS_PLACE_OOB;
Dimitri Gorokhovik16f05c22009-09-03 14:04:22 +0100175 ops.ooboffs = offs & mask;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200176 ops.ooblen = mtd->oobsize;
177 ops.oobbuf = oob;
178 ops.datbuf = buf;
179 ops.len = len;
180
Artem Bityutskiya2cc5ba2011-12-23 18:29:55 +0200181 res = mtd_write_oob(mtd, offs & ~mask, &ops);
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200182 *retlen = ops.retlen;
183 return res;
184}
185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186/* Actual NFTL access routines */
187/* NFTL_findfreeblock: Find a free Erase Unit on the NFTL partition. This function is used
188 * when the give Virtual Unit Chain
189 */
190static u16 NFTL_findfreeblock(struct NFTLrecord *nftl, int desperate )
191{
192 /* For a given Virtual Unit Chain: find or create a free block and
193 add it to the chain */
194 /* We're passed the number of the last EUN in the chain, to save us from
195 having to look it up again */
196 u16 pot = nftl->LastFreeEUN;
197 int silly = nftl->nb_blocks;
198
199 /* Normally, we force a fold to happen before we run out of free blocks completely */
200 if (!desperate && nftl->numfreeEUNs < 2) {
Brian Norris289c0522011-07-19 10:06:09 -0700201 pr_debug("NFTL_findfreeblock: there are too few free EUNs\n");
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200202 return BLOCK_NIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 }
204
205 /* Scan for a free block */
206 do {
207 if (nftl->ReplUnitTable[pot] == BLOCK_FREE) {
208 nftl->LastFreeEUN = pot;
209 nftl->numfreeEUNs--;
210 return pot;
211 }
212
213 /* This will probably point to the MediaHdr unit itself,
214 right at the beginning of the partition. But that unit
215 (and the backup unit too) should have the UCI set
216 up so that it's not selected for overwriting */
217 if (++pot > nftl->lastEUN)
218 pot = le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN);
219
220 if (!silly--) {
221 printk("Argh! No free blocks found! LastFreeEUN = %d, "
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000222 "FirstEUN = %d\n", nftl->LastFreeEUN,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN));
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200224 return BLOCK_NIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 }
226 } while (pot != nftl->LastFreeEUN);
227
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200228 return BLOCK_NIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229}
230
231static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned pendingblock )
232{
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200233 struct mtd_info *mtd = nftl->mbd.mtd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 u16 BlockMap[MAX_SECTORS_PER_UNIT];
235 unsigned char BlockLastState[MAX_SECTORS_PER_UNIT];
236 unsigned char BlockFreeFound[MAX_SECTORS_PER_UNIT];
237 unsigned int thisEUN;
238 int block;
239 int silly;
240 unsigned int targetEUN;
241 struct nftl_oob oob;
242 int inplace = 1;
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200243 size_t retlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
245 memset(BlockMap, 0xff, sizeof(BlockMap));
246 memset(BlockFreeFound, 0, sizeof(BlockFreeFound));
247
248 thisEUN = nftl->EUNtable[thisVUC];
249
250 if (thisEUN == BLOCK_NIL) {
251 printk(KERN_WARNING "Trying to fold non-existent "
252 "Virtual Unit Chain %d!\n", thisVUC);
253 return BLOCK_NIL;
254 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 /* Scan to find the Erase Unit which holds the actual data for each
257 512-byte block within the Chain.
258 */
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200259 silly = MAX_LOOPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 targetEUN = BLOCK_NIL;
261 while (thisEUN <= nftl->lastEUN ) {
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200262 unsigned int status, foldmark;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 targetEUN = thisEUN;
265 for (block = 0; block < nftl->EraseSize / 512; block ++) {
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200266 nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200267 (block * 512), 16 , &retlen,
268 (char *)&oob);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 if (block == 2) {
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200270 foldmark = oob.u.c.FoldMark | oob.u.c.FoldMark1;
271 if (foldmark == FOLD_MARK_IN_PROGRESS) {
Brian Norris289c0522011-07-19 10:06:09 -0700272 pr_debug("Write Inhibited on EUN %d\n", thisEUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 inplace = 0;
274 } else {
275 /* There's no other reason not to do inplace,
276 except ones that come later. So we don't need
277 to preserve inplace */
278 inplace = 1;
279 }
280 }
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200281 status = oob.b.Status | oob.b.Status1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 BlockLastState[block] = status;
283
284 switch(status) {
285 case SECTOR_FREE:
286 BlockFreeFound[block] = 1;
287 break;
288
289 case SECTOR_USED:
290 if (!BlockFreeFound[block])
291 BlockMap[block] = thisEUN;
292 else
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000293 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 "SECTOR_USED found after SECTOR_FREE "
295 "in Virtual Unit Chain %d for block %d\n",
296 thisVUC, block);
297 break;
298 case SECTOR_DELETED:
299 if (!BlockFreeFound[block])
300 BlockMap[block] = BLOCK_NIL;
301 else
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000302 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 "SECTOR_DELETED found after SECTOR_FREE "
304 "in Virtual Unit Chain %d for block %d\n",
305 thisVUC, block);
306 break;
307
308 case SECTOR_IGNORE:
309 break;
310 default:
311 printk("Unknown status for block %d in EUN %d: %x\n",
312 block, thisEUN, status);
313 }
314 }
315
316 if (!silly--) {
317 printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%x\n",
318 thisVUC);
319 return BLOCK_NIL;
320 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 thisEUN = nftl->ReplUnitTable[thisEUN];
323 }
324
325 if (inplace) {
326 /* We're being asked to be a fold-in-place. Check
327 that all blocks which actually have data associated
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000328 with them (i.e. BlockMap[block] != BLOCK_NIL) are
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 either already present or SECTOR_FREE in the target
330 block. If not, we're going to have to fold out-of-place
331 anyway.
332 */
333 for (block = 0; block < nftl->EraseSize / 512 ; block++) {
334 if (BlockLastState[block] != SECTOR_FREE &&
335 BlockMap[block] != BLOCK_NIL &&
336 BlockMap[block] != targetEUN) {
Brian Norris289c0522011-07-19 10:06:09 -0700337 pr_debug("Setting inplace to 0. VUC %d, "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 "block %d was %x lastEUN, "
339 "and is in EUN %d (%s) %d\n",
340 thisVUC, block, BlockLastState[block],
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000341 BlockMap[block],
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 BlockMap[block]== targetEUN ? "==" : "!=",
343 targetEUN);
344 inplace = 0;
345 break;
346 }
347 }
348
349 if (pendingblock >= (thisVUC * (nftl->EraseSize / 512)) &&
350 pendingblock < ((thisVUC + 1)* (nftl->EraseSize / 512)) &&
351 BlockLastState[pendingblock - (thisVUC * (nftl->EraseSize / 512))] !=
352 SECTOR_FREE) {
Brian Norris289c0522011-07-19 10:06:09 -0700353 pr_debug("Pending write not free in EUN %d. "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 "Folding out of place.\n", targetEUN);
355 inplace = 0;
356 }
357 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000358
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 if (!inplace) {
Brian Norris289c0522011-07-19 10:06:09 -0700360 pr_debug("Cannot fold Virtual Unit Chain %d in place. "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 "Trying out-of-place\n", thisVUC);
362 /* We need to find a targetEUN to fold into. */
363 targetEUN = NFTL_findfreeblock(nftl, 1);
364 if (targetEUN == BLOCK_NIL) {
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000365 /* Ouch. Now we're screwed. We need to do a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 fold-in-place of another chain to make room
367 for this one. We need a better way of selecting
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000368 which chain to fold, because makefreeblock will
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 only ask us to fold the same one again.
370 */
371 printk(KERN_WARNING
372 "NFTL_findfreeblock(desperate) returns 0xffff.\n");
373 return BLOCK_NIL;
374 }
375 } else {
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200376 /* We put a fold mark in the chain we are folding only if we
377 fold in place to help the mount check code. If we do not fold in
378 place, it is possible to find the valid chain by selecting the
379 longer one */
380 oob.u.c.FoldMark = oob.u.c.FoldMark1 = cpu_to_le16(FOLD_MARK_IN_PROGRESS);
381 oob.u.c.unused = 0xffffffff;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200382 nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 2 * 512 + 8,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200383 8, &retlen, (char *)&oob.u);
384 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
386 /* OK. We now know the location of every block in the Virtual Unit Chain,
387 and the Erase Unit into which we are supposed to be copying.
388 Go for it.
389 */
Brian Norris289c0522011-07-19 10:06:09 -0700390 pr_debug("Folding chain %d into unit %d\n", thisVUC, targetEUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 for (block = 0; block < nftl->EraseSize / 512 ; block++) {
392 unsigned char movebuf[512];
393 int ret;
394
395 /* If it's in the target EUN already, or if it's pending write, do nothing */
396 if (BlockMap[block] == targetEUN ||
397 (pendingblock == (thisVUC * (nftl->EraseSize / 512) + block))) {
398 continue;
399 }
400
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200401 /* copy only in non free block (free blocks can only
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 happen in case of media errors or deleted blocks) */
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200403 if (BlockMap[block] == BLOCK_NIL)
404 continue;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000405
Artem Bityutskiy329ad392011-12-23 17:30:16 +0200406 ret = mtd_read(mtd,
407 (nftl->EraseSize * BlockMap[block]) + (block * 512),
408 512,
409 &retlen,
410 movebuf);
Brian Norrisd57f40542011-09-20 18:34:25 -0700411 if (ret < 0 && !mtd_is_bitflip(ret)) {
Artem Bityutskiy329ad392011-12-23 17:30:16 +0200412 ret = mtd_read(mtd,
413 (nftl->EraseSize * BlockMap[block]) + (block * 512),
414 512,
415 &retlen,
416 movebuf);
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200417 if (ret != -EIO)
418 printk("Error went away on retry.\n");
419 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 memset(&oob, 0xff, sizeof(struct nftl_oob));
421 oob.b.Status = oob.b.Status1 = SECTOR_USED;
Thomas Gleixner9223a452006-05-23 17:21:03 +0200422
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200423 nftl_write(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) +
424 (block * 512), 512, &retlen, movebuf, (char *)&oob);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000426
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200427 /* add the header so that it is now a valid chain */
428 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200429 oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = BLOCK_NIL;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000430
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200431 nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 8,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200432 8, &retlen, (char *)&oob.u);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
434 /* OK. We've moved the whole lot into the new block. Now we have to free the original blocks. */
435
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000436 /* At this point, we have two different chains for this Virtual Unit, and no way to tell
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 them apart. If we crash now, we get confused. However, both contain the same data, so we
438 shouldn't actually lose data in this case. It's just that when we load up on a medium which
439 has duplicate chains, we need to free one of the chains because it's not necessary any more.
440 */
441 thisEUN = nftl->EUNtable[thisVUC];
Brian Norris289c0522011-07-19 10:06:09 -0700442 pr_debug("Want to erase\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000444 /* For each block in the old chain (except the targetEUN of course),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 free it and make it available for future use */
446 while (thisEUN <= nftl->lastEUN && thisEUN != targetEUN) {
447 unsigned int EUNtmp;
448
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200449 EUNtmp = nftl->ReplUnitTable[thisEUN];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200451 if (NFTL_formatblock(nftl, thisEUN) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 /* could not erase : mark block as reserved
453 */
454 nftl->ReplUnitTable[thisEUN] = BLOCK_RESERVED;
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200455 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 /* correctly erased : mark it as free */
457 nftl->ReplUnitTable[thisEUN] = BLOCK_FREE;
458 nftl->numfreeEUNs++;
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200459 }
460 thisEUN = EUNtmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000462
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 /* Make this the new start of chain for thisVUC */
464 nftl->ReplUnitTable[targetEUN] = BLOCK_NIL;
465 nftl->EUNtable[thisVUC] = targetEUN;
466
467 return targetEUN;
468}
469
470static u16 NFTL_makefreeblock( struct NFTLrecord *nftl , unsigned pendingblock)
471{
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000472 /* This is the part that needs some cleverness applied.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 For now, I'm doing the minimum applicable to actually
474 get the thing to work.
475 Wear-levelling and other clever stuff needs to be implemented
476 and we also need to do some assessment of the results when
477 the system loses power half-way through the routine.
478 */
479 u16 LongestChain = 0;
480 u16 ChainLength = 0, thislen;
481 u16 chain, EUN;
482
483 for (chain = 0; chain < le32_to_cpu(nftl->MediaHdr.FormattedSize) / nftl->EraseSize; chain++) {
484 EUN = nftl->EUNtable[chain];
485 thislen = 0;
486
487 while (EUN <= nftl->lastEUN) {
488 thislen++;
489 //printk("VUC %d reaches len %d with EUN %d\n", chain, thislen, EUN);
490 EUN = nftl->ReplUnitTable[EUN] & 0x7fff;
491 if (thislen > 0xff00) {
492 printk("Endless loop in Virtual Chain %d: Unit %x\n",
493 chain, EUN);
494 }
495 if (thislen > 0xff10) {
496 /* Actually, don't return failure. Just ignore this chain and
497 get on with it. */
498 thislen = 0;
499 break;
500 }
501 }
502
503 if (thislen > ChainLength) {
504 //printk("New longest chain is %d with length %d\n", chain, thislen);
505 ChainLength = thislen;
506 LongestChain = chain;
507 }
508 }
509
510 if (ChainLength < 2) {
511 printk(KERN_WARNING "No Virtual Unit Chains available for folding. "
512 "Failing request\n");
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200513 return BLOCK_NIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 }
515
516 return NFTL_foldchain (nftl, LongestChain, pendingblock);
517}
518
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000519/* NFTL_findwriteunit: Return the unit number into which we can write
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 for this block. Make it available if it isn't already
521*/
522static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
523{
524 u16 lastEUN;
525 u16 thisVUC = block / (nftl->EraseSize / 512);
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200526 struct mtd_info *mtd = nftl->mbd.mtd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 unsigned int writeEUN;
528 unsigned long blockofs = (block * 512) & (nftl->EraseSize -1);
529 size_t retlen;
530 int silly, silly2 = 3;
531 struct nftl_oob oob;
532
533 do {
534 /* Scan the media to find a unit in the VUC which has
535 a free space for the block in question.
536 */
537
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000538 /* This condition catches the 0x[7f]fff cases, as well as
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 being a sanity check for past-end-of-media access
540 */
541 lastEUN = BLOCK_NIL;
542 writeEUN = nftl->EUNtable[thisVUC];
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200543 silly = MAX_LOOPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 while (writeEUN <= nftl->lastEUN) {
545 struct nftl_bci bci;
546 size_t retlen;
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200547 unsigned int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
549 lastEUN = writeEUN;
550
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200551 nftl_read_oob(mtd,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200552 (writeEUN * nftl->EraseSize) + blockofs,
553 8, &retlen, (char *)&bci);
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000554
Brian Norris289c0522011-07-19 10:06:09 -0700555 pr_debug("Status of block %d in EUN %d is %x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 block , writeEUN, le16_to_cpu(bci.Status));
557
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200558 status = bci.Status | bci.Status1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 switch(status) {
560 case SECTOR_FREE:
561 return writeEUN;
562
563 case SECTOR_DELETED:
564 case SECTOR_USED:
565 case SECTOR_IGNORE:
566 break;
567 default:
568 // Invalid block. Don't use it any more. Must implement.
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000569 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000571
572 if (!silly--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 printk(KERN_WARNING
574 "Infinite loop in Virtual Unit Chain 0x%x\n",
575 thisVUC);
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200576 return BLOCK_NIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 }
578
579 /* Skip to next block in chain */
580 writeEUN = nftl->ReplUnitTable[writeEUN];
581 }
582
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000583 /* OK. We didn't find one in the existing chain, or there
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 is no existing chain. */
585
586 /* Try to find an already-free block */
587 writeEUN = NFTL_findfreeblock(nftl, 0);
588
589 if (writeEUN == BLOCK_NIL) {
590 /* That didn't work - there were no free blocks just
591 waiting to be picked up. We're going to have to fold
592 a chain to make room.
593 */
594
595 /* First remember the start of this chain */
596 //u16 startEUN = nftl->EUNtable[thisVUC];
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000597
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 //printk("Write to VirtualUnitChain %d, calling makefreeblock()\n", thisVUC);
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200599 writeEUN = NFTL_makefreeblock(nftl, BLOCK_NIL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
601 if (writeEUN == BLOCK_NIL) {
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000602 /* OK, we accept that the above comment is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 lying - there may have been free blocks
604 last time we called NFTL_findfreeblock(),
605 but they are reserved for when we're
606 desperate. Well, now we're desperate.
607 */
Brian Norris289c0522011-07-19 10:06:09 -0700608 pr_debug("Using desperate==1 to find free EUN to accommodate write to VUC %d\n", thisVUC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 writeEUN = NFTL_findfreeblock(nftl, 1);
610 }
611 if (writeEUN == BLOCK_NIL) {
612 /* Ouch. This should never happen - we should
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000613 always be able to make some room somehow.
614 If we get here, we've allocated more storage
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 space than actual media, or our makefreeblock
616 routine is missing something.
617 */
618 printk(KERN_WARNING "Cannot make free space.\n");
619 return BLOCK_NIL;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000620 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 //printk("Restarting scan\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 continue;
623 }
624
625 /* We've found a free block. Insert it into the chain. */
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000626
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 if (lastEUN != BLOCK_NIL) {
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200628 thisVUC |= 0x8000; /* It's a replacement block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 } else {
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200630 /* The first block in a new chain */
631 nftl->EUNtable[thisVUC] = writeEUN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 }
633
634 /* set up the actual EUN we're writing into */
635 /* Both in our cache... */
636 nftl->ReplUnitTable[writeEUN] = BLOCK_NIL;
637
638 /* ... and on the flash itself */
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200639 nftl_read_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200640 &retlen, (char *)&oob.u);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641
642 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
643
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200644 nftl_write_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200645 &retlen, (char *)&oob.u);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200647 /* we link the new block to the chain only after the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 block is ready. It avoids the case where the chain
649 could point to a free block */
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200650 if (lastEUN != BLOCK_NIL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 /* Both in our cache... */
652 nftl->ReplUnitTable[lastEUN] = writeEUN;
653 /* ... and on the flash itself */
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200654 nftl_read_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200655 8, &retlen, (char *)&oob.u);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
657 oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum
658 = cpu_to_le16(writeEUN);
659
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200660 nftl_write_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200661 8, &retlen, (char *)&oob.u);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 }
663
664 return writeEUN;
665
666 } while (silly2--);
667
668 printk(KERN_WARNING "Error folding to make room for Virtual Unit Chain 0x%x\n",
669 thisVUC);
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200670 return BLOCK_NIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671}
672
673static int nftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block,
674 char *buffer)
675{
676 struct NFTLrecord *nftl = (void *)mbd;
677 u16 writeEUN;
678 unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
679 size_t retlen;
680 struct nftl_oob oob;
681
682 writeEUN = NFTL_findwriteunit(nftl, block);
683
684 if (writeEUN == BLOCK_NIL) {
685 printk(KERN_WARNING
686 "NFTL_writeblock(): Cannot find block to write to\n");
687 /* If we _still_ haven't got a block to use, we're screwed */
688 return 1;
689 }
690
691 memset(&oob, 0xff, sizeof(struct nftl_oob));
692 oob.b.Status = oob.b.Status1 = SECTOR_USED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200694 nftl_write(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs,
695 512, &retlen, (char *)buffer, (char *)&oob);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 return 0;
697}
698#endif /* CONFIG_NFTL_RW */
699
700static int nftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
701 char *buffer)
702{
703 struct NFTLrecord *nftl = (void *)mbd;
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200704 struct mtd_info *mtd = nftl->mbd.mtd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 u16 lastgoodEUN;
706 u16 thisEUN = nftl->EUNtable[block / (nftl->EraseSize / 512)];
707 unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200708 unsigned int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 int silly = MAX_LOOPS;
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200710 size_t retlen;
711 struct nftl_bci bci;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
713 lastgoodEUN = BLOCK_NIL;
714
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200715 if (thisEUN != BLOCK_NIL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 while (thisEUN < nftl->nb_blocks) {
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200717 if (nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200718 blockofs, 8, &retlen,
719 (char *)&bci) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 status = SECTOR_IGNORE;
721 else
722 status = bci.Status | bci.Status1;
723
724 switch (status) {
725 case SECTOR_FREE:
726 /* no modification of a sector should follow a free sector */
727 goto the_end;
728 case SECTOR_DELETED:
729 lastgoodEUN = BLOCK_NIL;
730 break;
731 case SECTOR_USED:
732 lastgoodEUN = thisEUN;
733 break;
734 case SECTOR_IGNORE:
735 break;
736 default:
737 printk("Unknown status for block %ld in EUN %d: %x\n",
738 block, thisEUN, status);
739 break;
740 }
741
742 if (!silly--) {
743 printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%lx\n",
744 block / (nftl->EraseSize / 512));
745 return 1;
746 }
747 thisEUN = nftl->ReplUnitTable[thisEUN];
748 }
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200749 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
751 the_end:
752 if (lastgoodEUN == BLOCK_NIL) {
753 /* the requested block is not on the media, return all 0x00 */
754 memset(buffer, 0, 512);
755 } else {
756 loff_t ptr = (lastgoodEUN * nftl->EraseSize) + blockofs;
757 size_t retlen;
Artem Bityutskiy329ad392011-12-23 17:30:16 +0200758 int res = mtd_read(mtd, ptr, 512, &retlen, buffer);
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200759
Brian Norrisd57f40542011-09-20 18:34:25 -0700760 if (res < 0 && !mtd_is_bitflip(res))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 return -EIO;
762 }
763 return 0;
764}
765
766static int nftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
767{
768 struct NFTLrecord *nftl = (void *)dev;
769
770 geo->heads = nftl->heads;
771 geo->sectors = nftl->sectors;
772 geo->cylinders = nftl->cylinders;
773
774 return 0;
775}
776
777/****************************************************************************
778 *
779 * Module stuff
780 *
781 ****************************************************************************/
782
783
784static struct mtd_blktrans_ops nftl_tr = {
785 .name = "nftl",
786 .major = NFTL_MAJOR,
787 .part_bits = NFTL_PARTN_BITS,
Richard Purdie19187672006-10-27 09:09:33 +0100788 .blksize = 512,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 .getgeo = nftl_getgeo,
790 .readsect = nftl_readblock,
791#ifdef CONFIG_NFTL_RW
792 .writesect = nftl_writeblock,
793#endif
794 .add_mtd = nftl_add_mtd,
795 .remove_dev = nftl_remove_dev,
796 .owner = THIS_MODULE,
797};
798
Dejin Zheng2dd8b552021-02-14 00:45:59 +0800799module_mtd_blktrans(nftl_tr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
801MODULE_LICENSE("GPL");
802MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
803MODULE_DESCRIPTION("Support code for NAND Flash Translation Layer, used on M-Systems DiskOnChip 2000 and Millennium");
Scott James Remnante7f52162009-03-02 17:43:04 +0000804MODULE_ALIAS_BLOCKDEV_MAJOR(NFTL_MAJOR);