Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Linux driver for NAND Flash Translation Layer
4 *
5 * Copyright © 1999 Machine Vision Holdings, Inc.
6 * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
7 */
8
9#define PRERELEASE
10
11#include <linux/kernel.h>
12#include <linux/module.h>
13#include <asm/errno.h>
14#include <asm/io.h>
15#include <linux/uaccess.h>
16#include <linux/delay.h>
17#include <linux/slab.h>
18#include <linux/init.h>
19#include <linux/hdreg.h>
20#include <linux/blkdev.h>
21
22#include <linux/kmod.h>
23#include <linux/mtd/mtd.h>
24#include <linux/mtd/rawnand.h>
25#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
40 if (!mtd_type_is_nand(mtd) || mtd->size > UINT_MAX)
41 return;
42 /* OK, this is moderately ugly. But probably safe. Alternatives? */
43 if (memcmp(mtd->name, "DiskOnChip", 10))
44 return;
45
46 pr_debug("NFTL: add_mtd for %s\n", mtd->name);
47
48 nftl = kzalloc(sizeof(struct NFTLrecord), GFP_KERNEL);
49
50 if (!nftl)
51 return;
52
53 nftl->mbd.mtd = mtd;
54 nftl->mbd.devnum = -1;
55
56 nftl->mbd.tr = tr;
57
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 /*
86 Oh no we don't have
87 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",
93 nftl->cylinders, nftl->heads , nftl->sectors,
94 (long)nftl->cylinders * (long)nftl->heads *
95 (long)nftl->sectors );
96 }
97
98 if (add_mtd_blktrans_dev(&nftl->mbd)) {
99 kfree(nftl->ReplUnitTable);
100 kfree(nftl->EUNtable);
101 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
113 pr_debug("NFTL: remove_dev (i=%d)\n", dev->devnum);
114
115 del_mtd_blktrans_dev(dev);
116 kfree(nftl->ReplUnitTable);
117 kfree(nftl->EUNtable);
118}
119
120/*
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{
126 loff_t mask = mtd->writesize - 1;
127 struct mtd_oob_ops ops = { };
128 int res;
129
130 ops.mode = MTD_OPS_PLACE_OOB;
131 ops.ooboffs = offs & mask;
132 ops.ooblen = len;
133 ops.oobbuf = buf;
134 ops.datbuf = NULL;
135
136 res = mtd_read_oob(mtd, offs & ~mask, &ops);
137 *retlen = ops.oobretlen;
138 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{
147 loff_t mask = mtd->writesize - 1;
148 struct mtd_oob_ops ops = { };
149 int res;
150
151 ops.mode = MTD_OPS_PLACE_OOB;
152 ops.ooboffs = offs & mask;
153 ops.ooblen = len;
154 ops.oobbuf = buf;
155 ops.datbuf = NULL;
156
157 res = mtd_write_oob(mtd, offs & ~mask, &ops);
158 *retlen = ops.oobretlen;
159 return res;
160}
161
162#ifdef CONFIG_NFTL_RW
163
164/*
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{
170 loff_t mask = mtd->writesize - 1;
171 struct mtd_oob_ops ops = { };
172 int res;
173
174 ops.mode = MTD_OPS_PLACE_OOB;
175 ops.ooboffs = offs & mask;
176 ops.ooblen = mtd->oobsize;
177 ops.oobbuf = oob;
178 ops.datbuf = buf;
179 ops.len = len;
180
181 res = mtd_write_oob(mtd, offs & ~mask, &ops);
182 *retlen = ops.retlen;
183 return res;
184}
185
186/* 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) {
201 pr_debug("NFTL_findfreeblock: there are too few free EUNs\n");
202 return BLOCK_NIL;
203 }
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, "
222 "FirstEUN = %d\n", nftl->LastFreeEUN,
223 le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN));
224 return BLOCK_NIL;
225 }
226 } while (pot != nftl->LastFreeEUN);
227
228 return BLOCK_NIL;
229}
230
231static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned pendingblock )
232{
233 struct mtd_info *mtd = nftl->mbd.mtd;
234 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;
243 size_t retlen;
244
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 }
255
256 /* Scan to find the Erase Unit which holds the actual data for each
257 512-byte block within the Chain.
258 */
259 silly = MAX_LOOPS;
260 targetEUN = BLOCK_NIL;
261 while (thisEUN <= nftl->lastEUN ) {
262 unsigned int status, foldmark;
263
264 targetEUN = thisEUN;
265 for (block = 0; block < nftl->EraseSize / 512; block ++) {
266 nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
267 (block * 512), 16 , &retlen,
268 (char *)&oob);
269 if (block == 2) {
270 foldmark = oob.u.c.FoldMark | oob.u.c.FoldMark1;
271 if (foldmark == FOLD_MARK_IN_PROGRESS) {
272 pr_debug("Write Inhibited on EUN %d\n", thisEUN);
273 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 }
281 status = oob.b.Status | oob.b.Status1;
282 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
293 printk(KERN_WARNING
294 "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
302 printk(KERN_WARNING
303 "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 }
321
322 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
328 with them (i.e. BlockMap[block] != BLOCK_NIL) are
329 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) {
337 pr_debug("Setting inplace to 0. VUC %d, "
338 "block %d was %x lastEUN, "
339 "and is in EUN %d (%s) %d\n",
340 thisVUC, block, BlockLastState[block],
341 BlockMap[block],
342 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) {
353 pr_debug("Pending write not free in EUN %d. "
354 "Folding out of place.\n", targetEUN);
355 inplace = 0;
356 }
357 }
358
359 if (!inplace) {
360 pr_debug("Cannot fold Virtual Unit Chain %d in place. "
361 "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) {
365 /* Ouch. Now we're screwed. We need to do a
366 fold-in-place of another chain to make room
367 for this one. We need a better way of selecting
368 which chain to fold, because makefreeblock will
369 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 {
376 /* 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;
382 nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 2 * 512 + 8,
383 8, &retlen, (char *)&oob.u);
384 }
385
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 */
390 pr_debug("Folding chain %d into unit %d\n", thisVUC, targetEUN);
391 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
401 /* copy only in non free block (free blocks can only
402 happen in case of media errors or deleted blocks) */
403 if (BlockMap[block] == BLOCK_NIL)
404 continue;
405
406 ret = mtd_read(mtd,
407 (nftl->EraseSize * BlockMap[block]) + (block * 512),
408 512,
409 &retlen,
410 movebuf);
411 if (ret < 0 && !mtd_is_bitflip(ret)) {
412 ret = mtd_read(mtd,
413 (nftl->EraseSize * BlockMap[block]) + (block * 512),
414 512,
415 &retlen,
416 movebuf);
417 if (ret != -EIO)
418 printk("Error went away on retry.\n");
419 }
420 memset(&oob, 0xff, sizeof(struct nftl_oob));
421 oob.b.Status = oob.b.Status1 = SECTOR_USED;
422
423 nftl_write(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) +
424 (block * 512), 512, &retlen, movebuf, (char *)&oob);
425 }
426
427 /* add the header so that it is now a valid chain */
428 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
429 oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = BLOCK_NIL;
430
431 nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 8,
432 8, &retlen, (char *)&oob.u);
433
434 /* OK. We've moved the whole lot into the new block. Now we have to free the original blocks. */
435
436 /* At this point, we have two different chains for this Virtual Unit, and no way to tell
437 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];
442 pr_debug("Want to erase\n");
443
444 /* For each block in the old chain (except the targetEUN of course),
445 free it and make it available for future use */
446 while (thisEUN <= nftl->lastEUN && thisEUN != targetEUN) {
447 unsigned int EUNtmp;
448
449 EUNtmp = nftl->ReplUnitTable[thisEUN];
450
451 if (NFTL_formatblock(nftl, thisEUN) < 0) {
452 /* could not erase : mark block as reserved
453 */
454 nftl->ReplUnitTable[thisEUN] = BLOCK_RESERVED;
455 } else {
456 /* correctly erased : mark it as free */
457 nftl->ReplUnitTable[thisEUN] = BLOCK_FREE;
458 nftl->numfreeEUNs++;
459 }
460 thisEUN = EUNtmp;
461 }
462
463 /* 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{
472 /* This is the part that needs some cleverness applied.
473 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");
513 return BLOCK_NIL;
514 }
515
516 return NFTL_foldchain (nftl, LongestChain, pendingblock);
517}
518
519/* NFTL_findwriteunit: Return the unit number into which we can write
520 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);
526 struct mtd_info *mtd = nftl->mbd.mtd;
527 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
538 /* This condition catches the 0x[7f]fff cases, as well as
539 being a sanity check for past-end-of-media access
540 */
541 lastEUN = BLOCK_NIL;
542 writeEUN = nftl->EUNtable[thisVUC];
543 silly = MAX_LOOPS;
544 while (writeEUN <= nftl->lastEUN) {
545 struct nftl_bci bci;
546 size_t retlen;
547 unsigned int status;
548
549 lastEUN = writeEUN;
550
551 nftl_read_oob(mtd,
552 (writeEUN * nftl->EraseSize) + blockofs,
553 8, &retlen, (char *)&bci);
554
555 pr_debug("Status of block %d in EUN %d is %x\n",
556 block , writeEUN, le16_to_cpu(bci.Status));
557
558 status = bci.Status | bci.Status1;
559 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.
569 break;
570 }
571
572 if (!silly--) {
573 printk(KERN_WARNING
574 "Infinite loop in Virtual Unit Chain 0x%x\n",
575 thisVUC);
576 return BLOCK_NIL;
577 }
578
579 /* Skip to next block in chain */
580 writeEUN = nftl->ReplUnitTable[writeEUN];
581 }
582
583 /* OK. We didn't find one in the existing chain, or there
584 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];
597
598 //printk("Write to VirtualUnitChain %d, calling makefreeblock()\n", thisVUC);
599 writeEUN = NFTL_makefreeblock(nftl, BLOCK_NIL);
600
601 if (writeEUN == BLOCK_NIL) {
602 /* OK, we accept that the above comment is
603 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 */
608 pr_debug("Using desperate==1 to find free EUN to accommodate write to VUC %d\n", thisVUC);
609 writeEUN = NFTL_findfreeblock(nftl, 1);
610 }
611 if (writeEUN == BLOCK_NIL) {
612 /* Ouch. This should never happen - we should
613 always be able to make some room somehow.
614 If we get here, we've allocated more storage
615 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;
620 }
621 //printk("Restarting scan\n");
622 continue;
623 }
624
625 /* We've found a free block. Insert it into the chain. */
626
627 if (lastEUN != BLOCK_NIL) {
628 thisVUC |= 0x8000; /* It's a replacement block */
629 } else {
630 /* The first block in a new chain */
631 nftl->EUNtable[thisVUC] = writeEUN;
632 }
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 */
639 nftl_read_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
640 &retlen, (char *)&oob.u);
641
642 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
643
644 nftl_write_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
645 &retlen, (char *)&oob.u);
646
647 /* we link the new block to the chain only after the
648 block is ready. It avoids the case where the chain
649 could point to a free block */
650 if (lastEUN != BLOCK_NIL) {
651 /* Both in our cache... */
652 nftl->ReplUnitTable[lastEUN] = writeEUN;
653 /* ... and on the flash itself */
654 nftl_read_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
655 8, &retlen, (char *)&oob.u);
656
657 oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum
658 = cpu_to_le16(writeEUN);
659
660 nftl_write_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
661 8, &retlen, (char *)&oob.u);
662 }
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);
670 return BLOCK_NIL;
671}
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;
693
694 nftl_write(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs,
695 512, &retlen, (char *)buffer, (char *)&oob);
696 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;
704 struct mtd_info *mtd = nftl->mbd.mtd;
705 u16 lastgoodEUN;
706 u16 thisEUN = nftl->EUNtable[block / (nftl->EraseSize / 512)];
707 unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
708 unsigned int status;
709 int silly = MAX_LOOPS;
710 size_t retlen;
711 struct nftl_bci bci;
712
713 lastgoodEUN = BLOCK_NIL;
714
715 if (thisEUN != BLOCK_NIL) {
716 while (thisEUN < nftl->nb_blocks) {
717 if (nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
718 blockofs, 8, &retlen,
719 (char *)&bci) < 0)
720 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 }
749 }
750
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;
758 int res = mtd_read(mtd, ptr, 512, &retlen, buffer);
759
760 if (res < 0 && !mtd_is_bitflip(res))
761 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,
788 .blksize = 512,
789 .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
799module_mtd_blktrans(nftl_tr);
800
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");
804MODULE_ALIAS_BLOCKDEV_MAJOR(NFTL_MAJOR);
1/*
2 * 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
20 */
21
22#define PRERELEASE
23
24#include <linux/kernel.h>
25#include <linux/module.h>
26#include <asm/errno.h>
27#include <asm/io.h>
28#include <linux/uaccess.h>
29#include <linux/delay.h>
30#include <linux/slab.h>
31#include <linux/init.h>
32#include <linux/hdreg.h>
33#include <linux/blkdev.h>
34
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
53 if (!mtd_type_is_nand(mtd) || mtd->size > UINT_MAX)
54 return;
55 /* OK, this is moderately ugly. But probably safe. Alternatives? */
56 if (memcmp(mtd->name, "DiskOnChip", 10))
57 return;
58
59 pr_debug("NFTL: add_mtd for %s\n", mtd->name);
60
61 nftl = kzalloc(sizeof(struct NFTLrecord), GFP_KERNEL);
62
63 if (!nftl)
64 return;
65
66 nftl->mbd.mtd = mtd;
67 nftl->mbd.devnum = -1;
68
69 nftl->mbd.tr = tr;
70
71 if (NFTL_mount(nftl) < 0) {
72 printk(KERN_WARNING "NFTL: could not mount device\n");
73 kfree(nftl);
74 return;
75 }
76
77 /* OK, it's a new one. Set up all the data structures. */
78
79 /* Calculate geometry */
80 nftl->cylinders = 1024;
81 nftl->heads = 16;
82
83 temp = nftl->cylinders * nftl->heads;
84 nftl->sectors = nftl->mbd.size / temp;
85 if (nftl->mbd.size % temp) {
86 nftl->sectors++;
87 temp = nftl->cylinders * nftl->sectors;
88 nftl->heads = nftl->mbd.size / temp;
89
90 if (nftl->mbd.size % temp) {
91 nftl->heads++;
92 temp = nftl->heads * nftl->sectors;
93 nftl->cylinders = nftl->mbd.size / temp;
94 }
95 }
96
97 if (nftl->mbd.size != nftl->heads * nftl->cylinders * nftl->sectors) {
98 /*
99 Oh no we don't have
100 mbd.size == heads * cylinders * sectors
101 */
102 printk(KERN_WARNING "NFTL: cannot calculate a geometry to "
103 "match size of 0x%lx.\n", nftl->mbd.size);
104 printk(KERN_WARNING "NFTL: using C:%d H:%d S:%d "
105 "(== 0x%lx sects)\n",
106 nftl->cylinders, nftl->heads , nftl->sectors,
107 (long)nftl->cylinders * (long)nftl->heads *
108 (long)nftl->sectors );
109 }
110
111 if (add_mtd_blktrans_dev(&nftl->mbd)) {
112 kfree(nftl->ReplUnitTable);
113 kfree(nftl->EUNtable);
114 kfree(nftl);
115 return;
116 }
117#ifdef PSYCHO_DEBUG
118 printk(KERN_INFO "NFTL: Found new nftl%c\n", nftl->mbd.devnum + 'a');
119#endif
120}
121
122static void nftl_remove_dev(struct mtd_blktrans_dev *dev)
123{
124 struct NFTLrecord *nftl = (void *)dev;
125
126 pr_debug("NFTL: remove_dev (i=%d)\n", dev->devnum);
127
128 del_mtd_blktrans_dev(dev);
129 kfree(nftl->ReplUnitTable);
130 kfree(nftl->EUNtable);
131}
132
133/*
134 * Read oob data from flash
135 */
136int nftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
137 size_t *retlen, uint8_t *buf)
138{
139 loff_t mask = mtd->writesize - 1;
140 struct mtd_oob_ops ops;
141 int res;
142
143 ops.mode = MTD_OPS_PLACE_OOB;
144 ops.ooboffs = offs & mask;
145 ops.ooblen = len;
146 ops.oobbuf = buf;
147 ops.datbuf = NULL;
148
149 res = mtd_read_oob(mtd, offs & ~mask, &ops);
150 *retlen = ops.oobretlen;
151 return res;
152}
153
154/*
155 * Write oob data to flash
156 */
157int nftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
158 size_t *retlen, uint8_t *buf)
159{
160 loff_t mask = mtd->writesize - 1;
161 struct mtd_oob_ops ops;
162 int res;
163
164 ops.mode = MTD_OPS_PLACE_OOB;
165 ops.ooboffs = offs & mask;
166 ops.ooblen = len;
167 ops.oobbuf = buf;
168 ops.datbuf = NULL;
169
170 res = mtd_write_oob(mtd, offs & ~mask, &ops);
171 *retlen = ops.oobretlen;
172 return res;
173}
174
175#ifdef CONFIG_NFTL_RW
176
177/*
178 * Write data and oob to flash
179 */
180static int nftl_write(struct mtd_info *mtd, loff_t offs, size_t len,
181 size_t *retlen, uint8_t *buf, uint8_t *oob)
182{
183 loff_t mask = mtd->writesize - 1;
184 struct mtd_oob_ops ops;
185 int res;
186
187 ops.mode = MTD_OPS_PLACE_OOB;
188 ops.ooboffs = offs & mask;
189 ops.ooblen = mtd->oobsize;
190 ops.oobbuf = oob;
191 ops.datbuf = buf;
192 ops.len = len;
193
194 res = mtd_write_oob(mtd, offs & ~mask, &ops);
195 *retlen = ops.retlen;
196 return res;
197}
198
199/* Actual NFTL access routines */
200/* NFTL_findfreeblock: Find a free Erase Unit on the NFTL partition. This function is used
201 * when the give Virtual Unit Chain
202 */
203static u16 NFTL_findfreeblock(struct NFTLrecord *nftl, int desperate )
204{
205 /* For a given Virtual Unit Chain: find or create a free block and
206 add it to the chain */
207 /* We're passed the number of the last EUN in the chain, to save us from
208 having to look it up again */
209 u16 pot = nftl->LastFreeEUN;
210 int silly = nftl->nb_blocks;
211
212 /* Normally, we force a fold to happen before we run out of free blocks completely */
213 if (!desperate && nftl->numfreeEUNs < 2) {
214 pr_debug("NFTL_findfreeblock: there are too few free EUNs\n");
215 return BLOCK_NIL;
216 }
217
218 /* Scan for a free block */
219 do {
220 if (nftl->ReplUnitTable[pot] == BLOCK_FREE) {
221 nftl->LastFreeEUN = pot;
222 nftl->numfreeEUNs--;
223 return pot;
224 }
225
226 /* This will probably point to the MediaHdr unit itself,
227 right at the beginning of the partition. But that unit
228 (and the backup unit too) should have the UCI set
229 up so that it's not selected for overwriting */
230 if (++pot > nftl->lastEUN)
231 pot = le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN);
232
233 if (!silly--) {
234 printk("Argh! No free blocks found! LastFreeEUN = %d, "
235 "FirstEUN = %d\n", nftl->LastFreeEUN,
236 le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN));
237 return BLOCK_NIL;
238 }
239 } while (pot != nftl->LastFreeEUN);
240
241 return BLOCK_NIL;
242}
243
244static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned pendingblock )
245{
246 struct mtd_info *mtd = nftl->mbd.mtd;
247 u16 BlockMap[MAX_SECTORS_PER_UNIT];
248 unsigned char BlockLastState[MAX_SECTORS_PER_UNIT];
249 unsigned char BlockFreeFound[MAX_SECTORS_PER_UNIT];
250 unsigned int thisEUN;
251 int block;
252 int silly;
253 unsigned int targetEUN;
254 struct nftl_oob oob;
255 int inplace = 1;
256 size_t retlen;
257
258 memset(BlockMap, 0xff, sizeof(BlockMap));
259 memset(BlockFreeFound, 0, sizeof(BlockFreeFound));
260
261 thisEUN = nftl->EUNtable[thisVUC];
262
263 if (thisEUN == BLOCK_NIL) {
264 printk(KERN_WARNING "Trying to fold non-existent "
265 "Virtual Unit Chain %d!\n", thisVUC);
266 return BLOCK_NIL;
267 }
268
269 /* Scan to find the Erase Unit which holds the actual data for each
270 512-byte block within the Chain.
271 */
272 silly = MAX_LOOPS;
273 targetEUN = BLOCK_NIL;
274 while (thisEUN <= nftl->lastEUN ) {
275 unsigned int status, foldmark;
276
277 targetEUN = thisEUN;
278 for (block = 0; block < nftl->EraseSize / 512; block ++) {
279 nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
280 (block * 512), 16 , &retlen,
281 (char *)&oob);
282 if (block == 2) {
283 foldmark = oob.u.c.FoldMark | oob.u.c.FoldMark1;
284 if (foldmark == FOLD_MARK_IN_PROGRESS) {
285 pr_debug("Write Inhibited on EUN %d\n", thisEUN);
286 inplace = 0;
287 } else {
288 /* There's no other reason not to do inplace,
289 except ones that come later. So we don't need
290 to preserve inplace */
291 inplace = 1;
292 }
293 }
294 status = oob.b.Status | oob.b.Status1;
295 BlockLastState[block] = status;
296
297 switch(status) {
298 case SECTOR_FREE:
299 BlockFreeFound[block] = 1;
300 break;
301
302 case SECTOR_USED:
303 if (!BlockFreeFound[block])
304 BlockMap[block] = thisEUN;
305 else
306 printk(KERN_WARNING
307 "SECTOR_USED found after SECTOR_FREE "
308 "in Virtual Unit Chain %d for block %d\n",
309 thisVUC, block);
310 break;
311 case SECTOR_DELETED:
312 if (!BlockFreeFound[block])
313 BlockMap[block] = BLOCK_NIL;
314 else
315 printk(KERN_WARNING
316 "SECTOR_DELETED found after SECTOR_FREE "
317 "in Virtual Unit Chain %d for block %d\n",
318 thisVUC, block);
319 break;
320
321 case SECTOR_IGNORE:
322 break;
323 default:
324 printk("Unknown status for block %d in EUN %d: %x\n",
325 block, thisEUN, status);
326 }
327 }
328
329 if (!silly--) {
330 printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%x\n",
331 thisVUC);
332 return BLOCK_NIL;
333 }
334
335 thisEUN = nftl->ReplUnitTable[thisEUN];
336 }
337
338 if (inplace) {
339 /* We're being asked to be a fold-in-place. Check
340 that all blocks which actually have data associated
341 with them (i.e. BlockMap[block] != BLOCK_NIL) are
342 either already present or SECTOR_FREE in the target
343 block. If not, we're going to have to fold out-of-place
344 anyway.
345 */
346 for (block = 0; block < nftl->EraseSize / 512 ; block++) {
347 if (BlockLastState[block] != SECTOR_FREE &&
348 BlockMap[block] != BLOCK_NIL &&
349 BlockMap[block] != targetEUN) {
350 pr_debug("Setting inplace to 0. VUC %d, "
351 "block %d was %x lastEUN, "
352 "and is in EUN %d (%s) %d\n",
353 thisVUC, block, BlockLastState[block],
354 BlockMap[block],
355 BlockMap[block]== targetEUN ? "==" : "!=",
356 targetEUN);
357 inplace = 0;
358 break;
359 }
360 }
361
362 if (pendingblock >= (thisVUC * (nftl->EraseSize / 512)) &&
363 pendingblock < ((thisVUC + 1)* (nftl->EraseSize / 512)) &&
364 BlockLastState[pendingblock - (thisVUC * (nftl->EraseSize / 512))] !=
365 SECTOR_FREE) {
366 pr_debug("Pending write not free in EUN %d. "
367 "Folding out of place.\n", targetEUN);
368 inplace = 0;
369 }
370 }
371
372 if (!inplace) {
373 pr_debug("Cannot fold Virtual Unit Chain %d in place. "
374 "Trying out-of-place\n", thisVUC);
375 /* We need to find a targetEUN to fold into. */
376 targetEUN = NFTL_findfreeblock(nftl, 1);
377 if (targetEUN == BLOCK_NIL) {
378 /* Ouch. Now we're screwed. We need to do a
379 fold-in-place of another chain to make room
380 for this one. We need a better way of selecting
381 which chain to fold, because makefreeblock will
382 only ask us to fold the same one again.
383 */
384 printk(KERN_WARNING
385 "NFTL_findfreeblock(desperate) returns 0xffff.\n");
386 return BLOCK_NIL;
387 }
388 } else {
389 /* We put a fold mark in the chain we are folding only if we
390 fold in place to help the mount check code. If we do not fold in
391 place, it is possible to find the valid chain by selecting the
392 longer one */
393 oob.u.c.FoldMark = oob.u.c.FoldMark1 = cpu_to_le16(FOLD_MARK_IN_PROGRESS);
394 oob.u.c.unused = 0xffffffff;
395 nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 2 * 512 + 8,
396 8, &retlen, (char *)&oob.u);
397 }
398
399 /* OK. We now know the location of every block in the Virtual Unit Chain,
400 and the Erase Unit into which we are supposed to be copying.
401 Go for it.
402 */
403 pr_debug("Folding chain %d into unit %d\n", thisVUC, targetEUN);
404 for (block = 0; block < nftl->EraseSize / 512 ; block++) {
405 unsigned char movebuf[512];
406 int ret;
407
408 /* If it's in the target EUN already, or if it's pending write, do nothing */
409 if (BlockMap[block] == targetEUN ||
410 (pendingblock == (thisVUC * (nftl->EraseSize / 512) + block))) {
411 continue;
412 }
413
414 /* copy only in non free block (free blocks can only
415 happen in case of media errors or deleted blocks) */
416 if (BlockMap[block] == BLOCK_NIL)
417 continue;
418
419 ret = mtd_read(mtd,
420 (nftl->EraseSize * BlockMap[block]) + (block * 512),
421 512,
422 &retlen,
423 movebuf);
424 if (ret < 0 && !mtd_is_bitflip(ret)) {
425 ret = mtd_read(mtd,
426 (nftl->EraseSize * BlockMap[block]) + (block * 512),
427 512,
428 &retlen,
429 movebuf);
430 if (ret != -EIO)
431 printk("Error went away on retry.\n");
432 }
433 memset(&oob, 0xff, sizeof(struct nftl_oob));
434 oob.b.Status = oob.b.Status1 = SECTOR_USED;
435
436 nftl_write(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) +
437 (block * 512), 512, &retlen, movebuf, (char *)&oob);
438 }
439
440 /* add the header so that it is now a valid chain */
441 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
442 oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = BLOCK_NIL;
443
444 nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 8,
445 8, &retlen, (char *)&oob.u);
446
447 /* OK. We've moved the whole lot into the new block. Now we have to free the original blocks. */
448
449 /* At this point, we have two different chains for this Virtual Unit, and no way to tell
450 them apart. If we crash now, we get confused. However, both contain the same data, so we
451 shouldn't actually lose data in this case. It's just that when we load up on a medium which
452 has duplicate chains, we need to free one of the chains because it's not necessary any more.
453 */
454 thisEUN = nftl->EUNtable[thisVUC];
455 pr_debug("Want to erase\n");
456
457 /* For each block in the old chain (except the targetEUN of course),
458 free it and make it available for future use */
459 while (thisEUN <= nftl->lastEUN && thisEUN != targetEUN) {
460 unsigned int EUNtmp;
461
462 EUNtmp = nftl->ReplUnitTable[thisEUN];
463
464 if (NFTL_formatblock(nftl, thisEUN) < 0) {
465 /* could not erase : mark block as reserved
466 */
467 nftl->ReplUnitTable[thisEUN] = BLOCK_RESERVED;
468 } else {
469 /* correctly erased : mark it as free */
470 nftl->ReplUnitTable[thisEUN] = BLOCK_FREE;
471 nftl->numfreeEUNs++;
472 }
473 thisEUN = EUNtmp;
474 }
475
476 /* Make this the new start of chain for thisVUC */
477 nftl->ReplUnitTable[targetEUN] = BLOCK_NIL;
478 nftl->EUNtable[thisVUC] = targetEUN;
479
480 return targetEUN;
481}
482
483static u16 NFTL_makefreeblock( struct NFTLrecord *nftl , unsigned pendingblock)
484{
485 /* This is the part that needs some cleverness applied.
486 For now, I'm doing the minimum applicable to actually
487 get the thing to work.
488 Wear-levelling and other clever stuff needs to be implemented
489 and we also need to do some assessment of the results when
490 the system loses power half-way through the routine.
491 */
492 u16 LongestChain = 0;
493 u16 ChainLength = 0, thislen;
494 u16 chain, EUN;
495
496 for (chain = 0; chain < le32_to_cpu(nftl->MediaHdr.FormattedSize) / nftl->EraseSize; chain++) {
497 EUN = nftl->EUNtable[chain];
498 thislen = 0;
499
500 while (EUN <= nftl->lastEUN) {
501 thislen++;
502 //printk("VUC %d reaches len %d with EUN %d\n", chain, thislen, EUN);
503 EUN = nftl->ReplUnitTable[EUN] & 0x7fff;
504 if (thislen > 0xff00) {
505 printk("Endless loop in Virtual Chain %d: Unit %x\n",
506 chain, EUN);
507 }
508 if (thislen > 0xff10) {
509 /* Actually, don't return failure. Just ignore this chain and
510 get on with it. */
511 thislen = 0;
512 break;
513 }
514 }
515
516 if (thislen > ChainLength) {
517 //printk("New longest chain is %d with length %d\n", chain, thislen);
518 ChainLength = thislen;
519 LongestChain = chain;
520 }
521 }
522
523 if (ChainLength < 2) {
524 printk(KERN_WARNING "No Virtual Unit Chains available for folding. "
525 "Failing request\n");
526 return BLOCK_NIL;
527 }
528
529 return NFTL_foldchain (nftl, LongestChain, pendingblock);
530}
531
532/* NFTL_findwriteunit: Return the unit number into which we can write
533 for this block. Make it available if it isn't already
534*/
535static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
536{
537 u16 lastEUN;
538 u16 thisVUC = block / (nftl->EraseSize / 512);
539 struct mtd_info *mtd = nftl->mbd.mtd;
540 unsigned int writeEUN;
541 unsigned long blockofs = (block * 512) & (nftl->EraseSize -1);
542 size_t retlen;
543 int silly, silly2 = 3;
544 struct nftl_oob oob;
545
546 do {
547 /* Scan the media to find a unit in the VUC which has
548 a free space for the block in question.
549 */
550
551 /* This condition catches the 0x[7f]fff cases, as well as
552 being a sanity check for past-end-of-media access
553 */
554 lastEUN = BLOCK_NIL;
555 writeEUN = nftl->EUNtable[thisVUC];
556 silly = MAX_LOOPS;
557 while (writeEUN <= nftl->lastEUN) {
558 struct nftl_bci bci;
559 size_t retlen;
560 unsigned int status;
561
562 lastEUN = writeEUN;
563
564 nftl_read_oob(mtd,
565 (writeEUN * nftl->EraseSize) + blockofs,
566 8, &retlen, (char *)&bci);
567
568 pr_debug("Status of block %d in EUN %d is %x\n",
569 block , writeEUN, le16_to_cpu(bci.Status));
570
571 status = bci.Status | bci.Status1;
572 switch(status) {
573 case SECTOR_FREE:
574 return writeEUN;
575
576 case SECTOR_DELETED:
577 case SECTOR_USED:
578 case SECTOR_IGNORE:
579 break;
580 default:
581 // Invalid block. Don't use it any more. Must implement.
582 break;
583 }
584
585 if (!silly--) {
586 printk(KERN_WARNING
587 "Infinite loop in Virtual Unit Chain 0x%x\n",
588 thisVUC);
589 return BLOCK_NIL;
590 }
591
592 /* Skip to next block in chain */
593 writeEUN = nftl->ReplUnitTable[writeEUN];
594 }
595
596 /* OK. We didn't find one in the existing chain, or there
597 is no existing chain. */
598
599 /* Try to find an already-free block */
600 writeEUN = NFTL_findfreeblock(nftl, 0);
601
602 if (writeEUN == BLOCK_NIL) {
603 /* That didn't work - there were no free blocks just
604 waiting to be picked up. We're going to have to fold
605 a chain to make room.
606 */
607
608 /* First remember the start of this chain */
609 //u16 startEUN = nftl->EUNtable[thisVUC];
610
611 //printk("Write to VirtualUnitChain %d, calling makefreeblock()\n", thisVUC);
612 writeEUN = NFTL_makefreeblock(nftl, BLOCK_NIL);
613
614 if (writeEUN == BLOCK_NIL) {
615 /* OK, we accept that the above comment is
616 lying - there may have been free blocks
617 last time we called NFTL_findfreeblock(),
618 but they are reserved for when we're
619 desperate. Well, now we're desperate.
620 */
621 pr_debug("Using desperate==1 to find free EUN to accommodate write to VUC %d\n", thisVUC);
622 writeEUN = NFTL_findfreeblock(nftl, 1);
623 }
624 if (writeEUN == BLOCK_NIL) {
625 /* Ouch. This should never happen - we should
626 always be able to make some room somehow.
627 If we get here, we've allocated more storage
628 space than actual media, or our makefreeblock
629 routine is missing something.
630 */
631 printk(KERN_WARNING "Cannot make free space.\n");
632 return BLOCK_NIL;
633 }
634 //printk("Restarting scan\n");
635 lastEUN = BLOCK_NIL;
636 continue;
637 }
638
639 /* We've found a free block. Insert it into the chain. */
640
641 if (lastEUN != BLOCK_NIL) {
642 thisVUC |= 0x8000; /* It's a replacement block */
643 } else {
644 /* The first block in a new chain */
645 nftl->EUNtable[thisVUC] = writeEUN;
646 }
647
648 /* set up the actual EUN we're writing into */
649 /* Both in our cache... */
650 nftl->ReplUnitTable[writeEUN] = BLOCK_NIL;
651
652 /* ... and on the flash itself */
653 nftl_read_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
654 &retlen, (char *)&oob.u);
655
656 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
657
658 nftl_write_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
659 &retlen, (char *)&oob.u);
660
661 /* we link the new block to the chain only after the
662 block is ready. It avoids the case where the chain
663 could point to a free block */
664 if (lastEUN != BLOCK_NIL) {
665 /* Both in our cache... */
666 nftl->ReplUnitTable[lastEUN] = writeEUN;
667 /* ... and on the flash itself */
668 nftl_read_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
669 8, &retlen, (char *)&oob.u);
670
671 oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum
672 = cpu_to_le16(writeEUN);
673
674 nftl_write_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
675 8, &retlen, (char *)&oob.u);
676 }
677
678 return writeEUN;
679
680 } while (silly2--);
681
682 printk(KERN_WARNING "Error folding to make room for Virtual Unit Chain 0x%x\n",
683 thisVUC);
684 return BLOCK_NIL;
685}
686
687static int nftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block,
688 char *buffer)
689{
690 struct NFTLrecord *nftl = (void *)mbd;
691 u16 writeEUN;
692 unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
693 size_t retlen;
694 struct nftl_oob oob;
695
696 writeEUN = NFTL_findwriteunit(nftl, block);
697
698 if (writeEUN == BLOCK_NIL) {
699 printk(KERN_WARNING
700 "NFTL_writeblock(): Cannot find block to write to\n");
701 /* If we _still_ haven't got a block to use, we're screwed */
702 return 1;
703 }
704
705 memset(&oob, 0xff, sizeof(struct nftl_oob));
706 oob.b.Status = oob.b.Status1 = SECTOR_USED;
707
708 nftl_write(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs,
709 512, &retlen, (char *)buffer, (char *)&oob);
710 return 0;
711}
712#endif /* CONFIG_NFTL_RW */
713
714static int nftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
715 char *buffer)
716{
717 struct NFTLrecord *nftl = (void *)mbd;
718 struct mtd_info *mtd = nftl->mbd.mtd;
719 u16 lastgoodEUN;
720 u16 thisEUN = nftl->EUNtable[block / (nftl->EraseSize / 512)];
721 unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
722 unsigned int status;
723 int silly = MAX_LOOPS;
724 size_t retlen;
725 struct nftl_bci bci;
726
727 lastgoodEUN = BLOCK_NIL;
728
729 if (thisEUN != BLOCK_NIL) {
730 while (thisEUN < nftl->nb_blocks) {
731 if (nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
732 blockofs, 8, &retlen,
733 (char *)&bci) < 0)
734 status = SECTOR_IGNORE;
735 else
736 status = bci.Status | bci.Status1;
737
738 switch (status) {
739 case SECTOR_FREE:
740 /* no modification of a sector should follow a free sector */
741 goto the_end;
742 case SECTOR_DELETED:
743 lastgoodEUN = BLOCK_NIL;
744 break;
745 case SECTOR_USED:
746 lastgoodEUN = thisEUN;
747 break;
748 case SECTOR_IGNORE:
749 break;
750 default:
751 printk("Unknown status for block %ld in EUN %d: %x\n",
752 block, thisEUN, status);
753 break;
754 }
755
756 if (!silly--) {
757 printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%lx\n",
758 block / (nftl->EraseSize / 512));
759 return 1;
760 }
761 thisEUN = nftl->ReplUnitTable[thisEUN];
762 }
763 }
764
765 the_end:
766 if (lastgoodEUN == BLOCK_NIL) {
767 /* the requested block is not on the media, return all 0x00 */
768 memset(buffer, 0, 512);
769 } else {
770 loff_t ptr = (lastgoodEUN * nftl->EraseSize) + blockofs;
771 size_t retlen;
772 int res = mtd_read(mtd, ptr, 512, &retlen, buffer);
773
774 if (res < 0 && !mtd_is_bitflip(res))
775 return -EIO;
776 }
777 return 0;
778}
779
780static int nftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
781{
782 struct NFTLrecord *nftl = (void *)dev;
783
784 geo->heads = nftl->heads;
785 geo->sectors = nftl->sectors;
786 geo->cylinders = nftl->cylinders;
787
788 return 0;
789}
790
791/****************************************************************************
792 *
793 * Module stuff
794 *
795 ****************************************************************************/
796
797
798static struct mtd_blktrans_ops nftl_tr = {
799 .name = "nftl",
800 .major = NFTL_MAJOR,
801 .part_bits = NFTL_PARTN_BITS,
802 .blksize = 512,
803 .getgeo = nftl_getgeo,
804 .readsect = nftl_readblock,
805#ifdef CONFIG_NFTL_RW
806 .writesect = nftl_writeblock,
807#endif
808 .add_mtd = nftl_add_mtd,
809 .remove_dev = nftl_remove_dev,
810 .owner = THIS_MODULE,
811};
812
813static int __init init_nftl(void)
814{
815 return register_mtd_blktrans(&nftl_tr);
816}
817
818static void __exit cleanup_nftl(void)
819{
820 deregister_mtd_blktrans(&nftl_tr);
821}
822
823module_init(init_nftl);
824module_exit(cleanup_nftl);
825
826MODULE_LICENSE("GPL");
827MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
828MODULE_DESCRIPTION("Support code for NAND Flash Translation Layer, used on M-Systems DiskOnChip 2000 and Millennium");
829MODULE_ALIAS_BLOCKDEV_MAJOR(NFTL_MAJOR);