blob: a75382aff5f68d17f419307b70eb4427f7c07507 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
David Woodhousea1452a32010-08-08 20:58:20 +01002 * Linux driver for NAND Flash Translation Layer
3 *
4 * Copyright © 1999 Machine Vision Holdings, Inc.
5 * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 */
21
22#define PRERELEASE
23
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/kernel.h>
25#include <linux/module.h>
26#include <asm/errno.h>
27#include <asm/io.h>
28#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/delay.h>
30#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/init.h>
32#include <linux/hdreg.h>
Scott James Remnante7f52162009-03-02 17:43:04 +000033#include <linux/blkdev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35#include <linux/kmod.h>
36#include <linux/mtd/mtd.h>
37#include <linux/mtd/nand.h>
38#include <linux/mtd/nftl.h>
39#include <linux/mtd/blktrans.h>
40
41/* maximum number of loops while examining next block, to have a
42 chance to detect consistency problems (they should never happen
43 because of the checks done in the mounting */
44
45#define MAX_LOOPS 10000
46
47
48static void nftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
49{
50 struct NFTLrecord *nftl;
51 unsigned long temp;
52
Adrian Hunter69423d92008-12-10 13:37:21 +000053 if (mtd->type != MTD_NANDFLASH || mtd->size > UINT_MAX)
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 return;
55 /* OK, this is moderately ugly. But probably safe. Alternatives? */
56 if (memcmp(mtd->name, "DiskOnChip", 10))
57 return;
58
Artem Bityutskiy8f461a72012-01-02 13:48:54 +020059 if (!mtd_can_have_bb(mtd)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 printk(KERN_ERR
61"NFTL no longer supports the old DiskOnChip drivers loaded via docprobe.\n"
62"Please use the new diskonchip driver under the NAND subsystem.\n");
63 return;
64 }
65
Brian Norris289c0522011-07-19 10:06:09 -070066 pr_debug("NFTL: add_mtd for %s\n", mtd->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
Burman Yan95b93a02006-11-15 21:10:29 +020068 nftl = kzalloc(sizeof(struct NFTLrecord), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
Brian Norris08700662011-06-07 16:01:54 -070070 if (!nftl)
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
73 nftl->mbd.mtd = mtd;
74 nftl->mbd.devnum = -1;
Richard Purdie19187672006-10-27 09:09:33 +010075
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 nftl->mbd.tr = tr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78 if (NFTL_mount(nftl) < 0) {
79 printk(KERN_WARNING "NFTL: could not mount device\n");
80 kfree(nftl);
81 return;
82 }
83
84 /* OK, it's a new one. Set up all the data structures. */
85
86 /* Calculate geometry */
87 nftl->cylinders = 1024;
88 nftl->heads = 16;
89
90 temp = nftl->cylinders * nftl->heads;
91 nftl->sectors = nftl->mbd.size / temp;
92 if (nftl->mbd.size % temp) {
93 nftl->sectors++;
94 temp = nftl->cylinders * nftl->sectors;
95 nftl->heads = nftl->mbd.size / temp;
96
97 if (nftl->mbd.size % temp) {
98 nftl->heads++;
99 temp = nftl->heads * nftl->sectors;
100 nftl->cylinders = nftl->mbd.size / temp;
101 }
102 }
103
104 if (nftl->mbd.size != nftl->heads * nftl->cylinders * nftl->sectors) {
105 /*
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000106 Oh no we don't have
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 mbd.size == heads * cylinders * sectors
108 */
109 printk(KERN_WARNING "NFTL: cannot calculate a geometry to "
110 "match size of 0x%lx.\n", nftl->mbd.size);
111 printk(KERN_WARNING "NFTL: using C:%d H:%d S:%d "
112 "(== 0x%lx sects)\n",
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000113 nftl->cylinders, nftl->heads , nftl->sectors,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 (long)nftl->cylinders * (long)nftl->heads *
115 (long)nftl->sectors );
116 }
117
118 if (add_mtd_blktrans_dev(&nftl->mbd)) {
Jesper Juhlfa671642005-11-07 01:01:27 -0800119 kfree(nftl->ReplUnitTable);
120 kfree(nftl->EUNtable);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 kfree(nftl);
122 return;
123 }
124#ifdef PSYCHO_DEBUG
125 printk(KERN_INFO "NFTL: Found new nftl%c\n", nftl->mbd.devnum + 'a');
126#endif
127}
128
129static void nftl_remove_dev(struct mtd_blktrans_dev *dev)
130{
131 struct NFTLrecord *nftl = (void *)dev;
132
Brian Norris289c0522011-07-19 10:06:09 -0700133 pr_debug("NFTL: remove_dev (i=%d)\n", dev->devnum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
135 del_mtd_blktrans_dev(dev);
Jesper Juhlfa671642005-11-07 01:01:27 -0800136 kfree(nftl->ReplUnitTable);
137 kfree(nftl->EUNtable);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138}
139
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200140/*
141 * Read oob data from flash
142 */
143int nftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
144 size_t *retlen, uint8_t *buf)
145{
Dimitri Gorokhovik16f05c22009-09-03 14:04:22 +0100146 loff_t mask = mtd->writesize - 1;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200147 struct mtd_oob_ops ops;
148 int res;
149
Brian Norris0612b9d2011-08-30 18:45:40 -0700150 ops.mode = MTD_OPS_PLACE_OOB;
Dimitri Gorokhovik16f05c22009-09-03 14:04:22 +0100151 ops.ooboffs = offs & mask;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200152 ops.ooblen = len;
153 ops.oobbuf = buf;
154 ops.datbuf = NULL;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200155
Artem Bityutskiyfd2819b2011-12-23 18:27:05 +0200156 res = mtd_read_oob(mtd, offs & ~mask, &ops);
Vitaly Wool70145682006-11-03 18:20:38 +0300157 *retlen = ops.oobretlen;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200158 return res;
159}
160
161/*
162 * Write oob data to flash
163 */
164int nftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
165 size_t *retlen, uint8_t *buf)
166{
Dimitri Gorokhovik16f05c22009-09-03 14:04:22 +0100167 loff_t mask = mtd->writesize - 1;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200168 struct mtd_oob_ops ops;
169 int res;
170
Brian Norris0612b9d2011-08-30 18:45:40 -0700171 ops.mode = MTD_OPS_PLACE_OOB;
Dimitri Gorokhovik16f05c22009-09-03 14:04:22 +0100172 ops.ooboffs = offs & mask;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200173 ops.ooblen = len;
174 ops.oobbuf = buf;
175 ops.datbuf = NULL;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200176
Artem Bityutskiya2cc5ba2011-12-23 18:29:55 +0200177 res = mtd_write_oob(mtd, offs & ~mask, &ops);
Vitaly Wool70145682006-11-03 18:20:38 +0300178 *retlen = ops.oobretlen;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200179 return res;
180}
181
Frederik Deweerdt553a8012006-10-02 09:42:25 +0100182#ifdef CONFIG_NFTL_RW
183
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200184/*
185 * Write data and oob to flash
186 */
187static int nftl_write(struct mtd_info *mtd, loff_t offs, size_t len,
188 size_t *retlen, uint8_t *buf, uint8_t *oob)
189{
Dimitri Gorokhovik16f05c22009-09-03 14:04:22 +0100190 loff_t mask = mtd->writesize - 1;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200191 struct mtd_oob_ops ops;
192 int res;
193
Brian Norris0612b9d2011-08-30 18:45:40 -0700194 ops.mode = MTD_OPS_PLACE_OOB;
Dimitri Gorokhovik16f05c22009-09-03 14:04:22 +0100195 ops.ooboffs = offs & mask;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200196 ops.ooblen = mtd->oobsize;
197 ops.oobbuf = oob;
198 ops.datbuf = buf;
199 ops.len = len;
200
Artem Bityutskiya2cc5ba2011-12-23 18:29:55 +0200201 res = mtd_write_oob(mtd, offs & ~mask, &ops);
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200202 *retlen = ops.retlen;
203 return res;
204}
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206/* Actual NFTL access routines */
207/* NFTL_findfreeblock: Find a free Erase Unit on the NFTL partition. This function is used
208 * when the give Virtual Unit Chain
209 */
210static u16 NFTL_findfreeblock(struct NFTLrecord *nftl, int desperate )
211{
212 /* For a given Virtual Unit Chain: find or create a free block and
213 add it to the chain */
214 /* We're passed the number of the last EUN in the chain, to save us from
215 having to look it up again */
216 u16 pot = nftl->LastFreeEUN;
217 int silly = nftl->nb_blocks;
218
219 /* Normally, we force a fold to happen before we run out of free blocks completely */
220 if (!desperate && nftl->numfreeEUNs < 2) {
Brian Norris289c0522011-07-19 10:06:09 -0700221 pr_debug("NFTL_findfreeblock: there are too few free EUNs\n");
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200222 return BLOCK_NIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 }
224
225 /* Scan for a free block */
226 do {
227 if (nftl->ReplUnitTable[pot] == BLOCK_FREE) {
228 nftl->LastFreeEUN = pot;
229 nftl->numfreeEUNs--;
230 return pot;
231 }
232
233 /* This will probably point to the MediaHdr unit itself,
234 right at the beginning of the partition. But that unit
235 (and the backup unit too) should have the UCI set
236 up so that it's not selected for overwriting */
237 if (++pot > nftl->lastEUN)
238 pot = le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN);
239
240 if (!silly--) {
241 printk("Argh! No free blocks found! LastFreeEUN = %d, "
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000242 "FirstEUN = %d\n", nftl->LastFreeEUN,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN));
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200244 return BLOCK_NIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 }
246 } while (pot != nftl->LastFreeEUN);
247
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200248 return BLOCK_NIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249}
250
251static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned pendingblock )
252{
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200253 struct mtd_info *mtd = nftl->mbd.mtd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 u16 BlockMap[MAX_SECTORS_PER_UNIT];
255 unsigned char BlockLastState[MAX_SECTORS_PER_UNIT];
256 unsigned char BlockFreeFound[MAX_SECTORS_PER_UNIT];
257 unsigned int thisEUN;
258 int block;
259 int silly;
260 unsigned int targetEUN;
261 struct nftl_oob oob;
262 int inplace = 1;
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200263 size_t retlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
265 memset(BlockMap, 0xff, sizeof(BlockMap));
266 memset(BlockFreeFound, 0, sizeof(BlockFreeFound));
267
268 thisEUN = nftl->EUNtable[thisVUC];
269
270 if (thisEUN == BLOCK_NIL) {
271 printk(KERN_WARNING "Trying to fold non-existent "
272 "Virtual Unit Chain %d!\n", thisVUC);
273 return BLOCK_NIL;
274 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000275
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 /* Scan to find the Erase Unit which holds the actual data for each
277 512-byte block within the Chain.
278 */
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200279 silly = MAX_LOOPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 targetEUN = BLOCK_NIL;
281 while (thisEUN <= nftl->lastEUN ) {
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200282 unsigned int status, foldmark;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
284 targetEUN = thisEUN;
285 for (block = 0; block < nftl->EraseSize / 512; block ++) {
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200286 nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200287 (block * 512), 16 , &retlen,
288 (char *)&oob);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 if (block == 2) {
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200290 foldmark = oob.u.c.FoldMark | oob.u.c.FoldMark1;
291 if (foldmark == FOLD_MARK_IN_PROGRESS) {
Brian Norris289c0522011-07-19 10:06:09 -0700292 pr_debug("Write Inhibited on EUN %d\n", thisEUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 inplace = 0;
294 } else {
295 /* There's no other reason not to do inplace,
296 except ones that come later. So we don't need
297 to preserve inplace */
298 inplace = 1;
299 }
300 }
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200301 status = oob.b.Status | oob.b.Status1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 BlockLastState[block] = status;
303
304 switch(status) {
305 case SECTOR_FREE:
306 BlockFreeFound[block] = 1;
307 break;
308
309 case SECTOR_USED:
310 if (!BlockFreeFound[block])
311 BlockMap[block] = thisEUN;
312 else
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000313 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 "SECTOR_USED found after SECTOR_FREE "
315 "in Virtual Unit Chain %d for block %d\n",
316 thisVUC, block);
317 break;
318 case SECTOR_DELETED:
319 if (!BlockFreeFound[block])
320 BlockMap[block] = BLOCK_NIL;
321 else
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000322 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 "SECTOR_DELETED found after SECTOR_FREE "
324 "in Virtual Unit Chain %d for block %d\n",
325 thisVUC, block);
326 break;
327
328 case SECTOR_IGNORE:
329 break;
330 default:
331 printk("Unknown status for block %d in EUN %d: %x\n",
332 block, thisEUN, status);
333 }
334 }
335
336 if (!silly--) {
337 printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%x\n",
338 thisVUC);
339 return BLOCK_NIL;
340 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 thisEUN = nftl->ReplUnitTable[thisEUN];
343 }
344
345 if (inplace) {
346 /* We're being asked to be a fold-in-place. Check
347 that all blocks which actually have data associated
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000348 with them (i.e. BlockMap[block] != BLOCK_NIL) are
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 either already present or SECTOR_FREE in the target
350 block. If not, we're going to have to fold out-of-place
351 anyway.
352 */
353 for (block = 0; block < nftl->EraseSize / 512 ; block++) {
354 if (BlockLastState[block] != SECTOR_FREE &&
355 BlockMap[block] != BLOCK_NIL &&
356 BlockMap[block] != targetEUN) {
Brian Norris289c0522011-07-19 10:06:09 -0700357 pr_debug("Setting inplace to 0. VUC %d, "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 "block %d was %x lastEUN, "
359 "and is in EUN %d (%s) %d\n",
360 thisVUC, block, BlockLastState[block],
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000361 BlockMap[block],
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 BlockMap[block]== targetEUN ? "==" : "!=",
363 targetEUN);
364 inplace = 0;
365 break;
366 }
367 }
368
369 if (pendingblock >= (thisVUC * (nftl->EraseSize / 512)) &&
370 pendingblock < ((thisVUC + 1)* (nftl->EraseSize / 512)) &&
371 BlockLastState[pendingblock - (thisVUC * (nftl->EraseSize / 512))] !=
372 SECTOR_FREE) {
Brian Norris289c0522011-07-19 10:06:09 -0700373 pr_debug("Pending write not free in EUN %d. "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 "Folding out of place.\n", targetEUN);
375 inplace = 0;
376 }
377 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000378
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 if (!inplace) {
Brian Norris289c0522011-07-19 10:06:09 -0700380 pr_debug("Cannot fold Virtual Unit Chain %d in place. "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 "Trying out-of-place\n", thisVUC);
382 /* We need to find a targetEUN to fold into. */
383 targetEUN = NFTL_findfreeblock(nftl, 1);
384 if (targetEUN == BLOCK_NIL) {
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000385 /* Ouch. Now we're screwed. We need to do a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 fold-in-place of another chain to make room
387 for this one. We need a better way of selecting
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000388 which chain to fold, because makefreeblock will
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 only ask us to fold the same one again.
390 */
391 printk(KERN_WARNING
392 "NFTL_findfreeblock(desperate) returns 0xffff.\n");
393 return BLOCK_NIL;
394 }
395 } else {
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200396 /* We put a fold mark in the chain we are folding only if we
397 fold in place to help the mount check code. If we do not fold in
398 place, it is possible to find the valid chain by selecting the
399 longer one */
400 oob.u.c.FoldMark = oob.u.c.FoldMark1 = cpu_to_le16(FOLD_MARK_IN_PROGRESS);
401 oob.u.c.unused = 0xffffffff;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200402 nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 2 * 512 + 8,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200403 8, &retlen, (char *)&oob.u);
404 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
406 /* OK. We now know the location of every block in the Virtual Unit Chain,
407 and the Erase Unit into which we are supposed to be copying.
408 Go for it.
409 */
Brian Norris289c0522011-07-19 10:06:09 -0700410 pr_debug("Folding chain %d into unit %d\n", thisVUC, targetEUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 for (block = 0; block < nftl->EraseSize / 512 ; block++) {
412 unsigned char movebuf[512];
413 int ret;
414
415 /* If it's in the target EUN already, or if it's pending write, do nothing */
416 if (BlockMap[block] == targetEUN ||
417 (pendingblock == (thisVUC * (nftl->EraseSize / 512) + block))) {
418 continue;
419 }
420
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200421 /* copy only in non free block (free blocks can only
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 happen in case of media errors or deleted blocks) */
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200423 if (BlockMap[block] == BLOCK_NIL)
424 continue;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000425
Artem Bityutskiy329ad392011-12-23 17:30:16 +0200426 ret = mtd_read(mtd,
427 (nftl->EraseSize * BlockMap[block]) + (block * 512),
428 512,
429 &retlen,
430 movebuf);
Brian Norrisd57f40542011-09-20 18:34:25 -0700431 if (ret < 0 && !mtd_is_bitflip(ret)) {
Artem Bityutskiy329ad392011-12-23 17:30:16 +0200432 ret = mtd_read(mtd,
433 (nftl->EraseSize * BlockMap[block]) + (block * 512),
434 512,
435 &retlen,
436 movebuf);
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200437 if (ret != -EIO)
438 printk("Error went away on retry.\n");
439 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 memset(&oob, 0xff, sizeof(struct nftl_oob));
441 oob.b.Status = oob.b.Status1 = SECTOR_USED;
Thomas Gleixner9223a452006-05-23 17:21:03 +0200442
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200443 nftl_write(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) +
444 (block * 512), 512, &retlen, movebuf, (char *)&oob);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000446
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200447 /* add the header so that it is now a valid chain */
448 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200449 oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = BLOCK_NIL;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000450
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200451 nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 8,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200452 8, &retlen, (char *)&oob.u);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
454 /* OK. We've moved the whole lot into the new block. Now we have to free the original blocks. */
455
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000456 /* At this point, we have two different chains for this Virtual Unit, and no way to tell
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 them apart. If we crash now, we get confused. However, both contain the same data, so we
458 shouldn't actually lose data in this case. It's just that when we load up on a medium which
459 has duplicate chains, we need to free one of the chains because it's not necessary any more.
460 */
461 thisEUN = nftl->EUNtable[thisVUC];
Brian Norris289c0522011-07-19 10:06:09 -0700462 pr_debug("Want to erase\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000464 /* For each block in the old chain (except the targetEUN of course),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 free it and make it available for future use */
466 while (thisEUN <= nftl->lastEUN && thisEUN != targetEUN) {
467 unsigned int EUNtmp;
468
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200469 EUNtmp = nftl->ReplUnitTable[thisEUN];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200471 if (NFTL_formatblock(nftl, thisEUN) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 /* could not erase : mark block as reserved
473 */
474 nftl->ReplUnitTable[thisEUN] = BLOCK_RESERVED;
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200475 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 /* correctly erased : mark it as free */
477 nftl->ReplUnitTable[thisEUN] = BLOCK_FREE;
478 nftl->numfreeEUNs++;
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200479 }
480 thisEUN = EUNtmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000482
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 /* Make this the new start of chain for thisVUC */
484 nftl->ReplUnitTable[targetEUN] = BLOCK_NIL;
485 nftl->EUNtable[thisVUC] = targetEUN;
486
487 return targetEUN;
488}
489
490static u16 NFTL_makefreeblock( struct NFTLrecord *nftl , unsigned pendingblock)
491{
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000492 /* This is the part that needs some cleverness applied.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 For now, I'm doing the minimum applicable to actually
494 get the thing to work.
495 Wear-levelling and other clever stuff needs to be implemented
496 and we also need to do some assessment of the results when
497 the system loses power half-way through the routine.
498 */
499 u16 LongestChain = 0;
500 u16 ChainLength = 0, thislen;
501 u16 chain, EUN;
502
503 for (chain = 0; chain < le32_to_cpu(nftl->MediaHdr.FormattedSize) / nftl->EraseSize; chain++) {
504 EUN = nftl->EUNtable[chain];
505 thislen = 0;
506
507 while (EUN <= nftl->lastEUN) {
508 thislen++;
509 //printk("VUC %d reaches len %d with EUN %d\n", chain, thislen, EUN);
510 EUN = nftl->ReplUnitTable[EUN] & 0x7fff;
511 if (thislen > 0xff00) {
512 printk("Endless loop in Virtual Chain %d: Unit %x\n",
513 chain, EUN);
514 }
515 if (thislen > 0xff10) {
516 /* Actually, don't return failure. Just ignore this chain and
517 get on with it. */
518 thislen = 0;
519 break;
520 }
521 }
522
523 if (thislen > ChainLength) {
524 //printk("New longest chain is %d with length %d\n", chain, thislen);
525 ChainLength = thislen;
526 LongestChain = chain;
527 }
528 }
529
530 if (ChainLength < 2) {
531 printk(KERN_WARNING "No Virtual Unit Chains available for folding. "
532 "Failing request\n");
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200533 return BLOCK_NIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 }
535
536 return NFTL_foldchain (nftl, LongestChain, pendingblock);
537}
538
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000539/* NFTL_findwriteunit: Return the unit number into which we can write
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 for this block. Make it available if it isn't already
541*/
542static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
543{
544 u16 lastEUN;
545 u16 thisVUC = block / (nftl->EraseSize / 512);
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200546 struct mtd_info *mtd = nftl->mbd.mtd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 unsigned int writeEUN;
548 unsigned long blockofs = (block * 512) & (nftl->EraseSize -1);
549 size_t retlen;
550 int silly, silly2 = 3;
551 struct nftl_oob oob;
552
553 do {
554 /* Scan the media to find a unit in the VUC which has
555 a free space for the block in question.
556 */
557
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000558 /* This condition catches the 0x[7f]fff cases, as well as
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 being a sanity check for past-end-of-media access
560 */
561 lastEUN = BLOCK_NIL;
562 writeEUN = nftl->EUNtable[thisVUC];
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200563 silly = MAX_LOOPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 while (writeEUN <= nftl->lastEUN) {
565 struct nftl_bci bci;
566 size_t retlen;
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200567 unsigned int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
569 lastEUN = writeEUN;
570
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200571 nftl_read_oob(mtd,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200572 (writeEUN * nftl->EraseSize) + blockofs,
573 8, &retlen, (char *)&bci);
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000574
Brian Norris289c0522011-07-19 10:06:09 -0700575 pr_debug("Status of block %d in EUN %d is %x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 block , writeEUN, le16_to_cpu(bci.Status));
577
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200578 status = bci.Status | bci.Status1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 switch(status) {
580 case SECTOR_FREE:
581 return writeEUN;
582
583 case SECTOR_DELETED:
584 case SECTOR_USED:
585 case SECTOR_IGNORE:
586 break;
587 default:
588 // Invalid block. Don't use it any more. Must implement.
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000589 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000591
592 if (!silly--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 printk(KERN_WARNING
594 "Infinite loop in Virtual Unit Chain 0x%x\n",
595 thisVUC);
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200596 return BLOCK_NIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 }
598
599 /* Skip to next block in chain */
600 writeEUN = nftl->ReplUnitTable[writeEUN];
601 }
602
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000603 /* OK. We didn't find one in the existing chain, or there
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 is no existing chain. */
605
606 /* Try to find an already-free block */
607 writeEUN = NFTL_findfreeblock(nftl, 0);
608
609 if (writeEUN == BLOCK_NIL) {
610 /* That didn't work - there were no free blocks just
611 waiting to be picked up. We're going to have to fold
612 a chain to make room.
613 */
614
615 /* First remember the start of this chain */
616 //u16 startEUN = nftl->EUNtable[thisVUC];
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000617
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 //printk("Write to VirtualUnitChain %d, calling makefreeblock()\n", thisVUC);
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200619 writeEUN = NFTL_makefreeblock(nftl, BLOCK_NIL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
621 if (writeEUN == BLOCK_NIL) {
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000622 /* OK, we accept that the above comment is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 lying - there may have been free blocks
624 last time we called NFTL_findfreeblock(),
625 but they are reserved for when we're
626 desperate. Well, now we're desperate.
627 */
Brian Norris289c0522011-07-19 10:06:09 -0700628 pr_debug("Using desperate==1 to find free EUN to accommodate write to VUC %d\n", thisVUC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 writeEUN = NFTL_findfreeblock(nftl, 1);
630 }
631 if (writeEUN == BLOCK_NIL) {
632 /* Ouch. This should never happen - we should
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000633 always be able to make some room somehow.
634 If we get here, we've allocated more storage
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 space than actual media, or our makefreeblock
636 routine is missing something.
637 */
638 printk(KERN_WARNING "Cannot make free space.\n");
639 return BLOCK_NIL;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000640 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 //printk("Restarting scan\n");
642 lastEUN = BLOCK_NIL;
643 continue;
644 }
645
646 /* We've found a free block. Insert it into the chain. */
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000647
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 if (lastEUN != BLOCK_NIL) {
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200649 thisVUC |= 0x8000; /* It's a replacement block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 } else {
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200651 /* The first block in a new chain */
652 nftl->EUNtable[thisVUC] = writeEUN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 }
654
655 /* set up the actual EUN we're writing into */
656 /* Both in our cache... */
657 nftl->ReplUnitTable[writeEUN] = BLOCK_NIL;
658
659 /* ... and on the flash itself */
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200660 nftl_read_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200661 &retlen, (char *)&oob.u);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662
663 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
664
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200665 nftl_write_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200666 &retlen, (char *)&oob.u);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200668 /* we link the new block to the chain only after the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 block is ready. It avoids the case where the chain
670 could point to a free block */
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200671 if (lastEUN != BLOCK_NIL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 /* Both in our cache... */
673 nftl->ReplUnitTable[lastEUN] = writeEUN;
674 /* ... and on the flash itself */
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200675 nftl_read_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200676 8, &retlen, (char *)&oob.u);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
678 oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum
679 = cpu_to_le16(writeEUN);
680
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200681 nftl_write_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200682 8, &retlen, (char *)&oob.u);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 }
684
685 return writeEUN;
686
687 } while (silly2--);
688
689 printk(KERN_WARNING "Error folding to make room for Virtual Unit Chain 0x%x\n",
690 thisVUC);
Julia Lawall70ec3bb2009-06-27 09:55:32 +0200691 return BLOCK_NIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692}
693
694static int nftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block,
695 char *buffer)
696{
697 struct NFTLrecord *nftl = (void *)mbd;
698 u16 writeEUN;
699 unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
700 size_t retlen;
701 struct nftl_oob oob;
702
703 writeEUN = NFTL_findwriteunit(nftl, block);
704
705 if (writeEUN == BLOCK_NIL) {
706 printk(KERN_WARNING
707 "NFTL_writeblock(): Cannot find block to write to\n");
708 /* If we _still_ haven't got a block to use, we're screwed */
709 return 1;
710 }
711
712 memset(&oob, 0xff, sizeof(struct nftl_oob));
713 oob.b.Status = oob.b.Status1 = SECTOR_USED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200715 nftl_write(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs,
716 512, &retlen, (char *)buffer, (char *)&oob);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 return 0;
718}
719#endif /* CONFIG_NFTL_RW */
720
721static int nftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
722 char *buffer)
723{
724 struct NFTLrecord *nftl = (void *)mbd;
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200725 struct mtd_info *mtd = nftl->mbd.mtd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 u16 lastgoodEUN;
727 u16 thisEUN = nftl->EUNtable[block / (nftl->EraseSize / 512)];
728 unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200729 unsigned int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 int silly = MAX_LOOPS;
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200731 size_t retlen;
732 struct nftl_bci bci;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733
734 lastgoodEUN = BLOCK_NIL;
735
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200736 if (thisEUN != BLOCK_NIL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 while (thisEUN < nftl->nb_blocks) {
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200738 if (nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200739 blockofs, 8, &retlen,
740 (char *)&bci) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 status = SECTOR_IGNORE;
742 else
743 status = bci.Status | bci.Status1;
744
745 switch (status) {
746 case SECTOR_FREE:
747 /* no modification of a sector should follow a free sector */
748 goto the_end;
749 case SECTOR_DELETED:
750 lastgoodEUN = BLOCK_NIL;
751 break;
752 case SECTOR_USED:
753 lastgoodEUN = thisEUN;
754 break;
755 case SECTOR_IGNORE:
756 break;
757 default:
758 printk("Unknown status for block %ld in EUN %d: %x\n",
759 block, thisEUN, status);
760 break;
761 }
762
763 if (!silly--) {
764 printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%lx\n",
765 block / (nftl->EraseSize / 512));
766 return 1;
767 }
768 thisEUN = nftl->ReplUnitTable[thisEUN];
769 }
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200770 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771
772 the_end:
773 if (lastgoodEUN == BLOCK_NIL) {
774 /* the requested block is not on the media, return all 0x00 */
775 memset(buffer, 0, 512);
776 } else {
777 loff_t ptr = (lastgoodEUN * nftl->EraseSize) + blockofs;
778 size_t retlen;
Artem Bityutskiy329ad392011-12-23 17:30:16 +0200779 int res = mtd_read(mtd, ptr, 512, &retlen, buffer);
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200780
Brian Norrisd57f40542011-09-20 18:34:25 -0700781 if (res < 0 && !mtd_is_bitflip(res))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 return -EIO;
783 }
784 return 0;
785}
786
787static int nftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
788{
789 struct NFTLrecord *nftl = (void *)dev;
790
791 geo->heads = nftl->heads;
792 geo->sectors = nftl->sectors;
793 geo->cylinders = nftl->cylinders;
794
795 return 0;
796}
797
798/****************************************************************************
799 *
800 * Module stuff
801 *
802 ****************************************************************************/
803
804
805static struct mtd_blktrans_ops nftl_tr = {
806 .name = "nftl",
807 .major = NFTL_MAJOR,
808 .part_bits = NFTL_PARTN_BITS,
Richard Purdie19187672006-10-27 09:09:33 +0100809 .blksize = 512,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 .getgeo = nftl_getgeo,
811 .readsect = nftl_readblock,
812#ifdef CONFIG_NFTL_RW
813 .writesect = nftl_writeblock,
814#endif
815 .add_mtd = nftl_add_mtd,
816 .remove_dev = nftl_remove_dev,
817 .owner = THIS_MODULE,
818};
819
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820static int __init init_nftl(void)
821{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 return register_mtd_blktrans(&nftl_tr);
823}
824
825static void __exit cleanup_nftl(void)
826{
827 deregister_mtd_blktrans(&nftl_tr);
828}
829
830module_init(init_nftl);
831module_exit(cleanup_nftl);
832
833MODULE_LICENSE("GPL");
834MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
835MODULE_DESCRIPTION("Support code for NAND Flash Translation Layer, used on M-Systems DiskOnChip 2000 and Millennium");
Scott James Remnante7f52162009-03-02 17:43:04 +0000836MODULE_ALIAS_BLOCKDEV_MAJOR(NFTL_MAJOR);