xref: /openbmc/linux/drivers/mtd/nftlcore.c (revision b830f94f)
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 
35 static 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 
109 static 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  */
123 int 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  */
144 int 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  */
167 static 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  */
190 static 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 
231 static 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 
470 static 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 */
522 static 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 			lastEUN = BLOCK_NIL;
623 			continue;
624 		}
625 
626 		/* We've found a free block. Insert it into the chain. */
627 
628 		if (lastEUN != BLOCK_NIL) {
629 			thisVUC |= 0x8000; /* It's a replacement block */
630 		} else {
631 			/* The first block in a new chain */
632 			nftl->EUNtable[thisVUC] = writeEUN;
633 		}
634 
635 		/* set up the actual EUN we're writing into */
636 		/* Both in our cache... */
637 		nftl->ReplUnitTable[writeEUN] = BLOCK_NIL;
638 
639 		/* ... and on the flash itself */
640 		nftl_read_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
641 			      &retlen, (char *)&oob.u);
642 
643 		oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
644 
645 		nftl_write_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
646 			       &retlen, (char *)&oob.u);
647 
648 		/* we link the new block to the chain only after the
649                    block is ready. It avoids the case where the chain
650                    could point to a free block */
651 		if (lastEUN != BLOCK_NIL) {
652 			/* Both in our cache... */
653 			nftl->ReplUnitTable[lastEUN] = writeEUN;
654 			/* ... and on the flash itself */
655 			nftl_read_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
656 				      8, &retlen, (char *)&oob.u);
657 
658 			oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum
659 				= cpu_to_le16(writeEUN);
660 
661 			nftl_write_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
662 				       8, &retlen, (char *)&oob.u);
663 		}
664 
665 		return writeEUN;
666 
667 	} while (silly2--);
668 
669 	printk(KERN_WARNING "Error folding to make room for Virtual Unit Chain 0x%x\n",
670 	       thisVUC);
671 	return BLOCK_NIL;
672 }
673 
674 static int nftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block,
675 			   char *buffer)
676 {
677 	struct NFTLrecord *nftl = (void *)mbd;
678 	u16 writeEUN;
679 	unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
680 	size_t retlen;
681 	struct nftl_oob oob;
682 
683 	writeEUN = NFTL_findwriteunit(nftl, block);
684 
685 	if (writeEUN == BLOCK_NIL) {
686 		printk(KERN_WARNING
687 		       "NFTL_writeblock(): Cannot find block to write to\n");
688 		/* If we _still_ haven't got a block to use, we're screwed */
689 		return 1;
690 	}
691 
692 	memset(&oob, 0xff, sizeof(struct nftl_oob));
693 	oob.b.Status = oob.b.Status1 = SECTOR_USED;
694 
695 	nftl_write(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs,
696 		   512, &retlen, (char *)buffer, (char *)&oob);
697 	return 0;
698 }
699 #endif /* CONFIG_NFTL_RW */
700 
701 static int nftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
702 			  char *buffer)
703 {
704 	struct NFTLrecord *nftl = (void *)mbd;
705 	struct mtd_info *mtd = nftl->mbd.mtd;
706 	u16 lastgoodEUN;
707 	u16 thisEUN = nftl->EUNtable[block / (nftl->EraseSize / 512)];
708 	unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
709 	unsigned int status;
710 	int silly = MAX_LOOPS;
711 	size_t retlen;
712 	struct nftl_bci bci;
713 
714 	lastgoodEUN = BLOCK_NIL;
715 
716 	if (thisEUN != BLOCK_NIL) {
717 		while (thisEUN < nftl->nb_blocks) {
718 			if (nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
719 					  blockofs, 8, &retlen,
720 					  (char *)&bci) < 0)
721 				status = SECTOR_IGNORE;
722 			else
723 				status = bci.Status | bci.Status1;
724 
725 			switch (status) {
726 			case SECTOR_FREE:
727 				/* no modification of a sector should follow a free sector */
728 				goto the_end;
729 			case SECTOR_DELETED:
730 				lastgoodEUN = BLOCK_NIL;
731 				break;
732 			case SECTOR_USED:
733 				lastgoodEUN = thisEUN;
734 				break;
735 			case SECTOR_IGNORE:
736 				break;
737 			default:
738 				printk("Unknown status for block %ld in EUN %d: %x\n",
739 				       block, thisEUN, status);
740 				break;
741 			}
742 
743 			if (!silly--) {
744 				printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%lx\n",
745 				       block / (nftl->EraseSize / 512));
746 				return 1;
747 			}
748 			thisEUN = nftl->ReplUnitTable[thisEUN];
749 		}
750 	}
751 
752  the_end:
753 	if (lastgoodEUN == BLOCK_NIL) {
754 		/* the requested block is not on the media, return all 0x00 */
755 		memset(buffer, 0, 512);
756 	} else {
757 		loff_t ptr = (lastgoodEUN * nftl->EraseSize) + blockofs;
758 		size_t retlen;
759 		int res = mtd_read(mtd, ptr, 512, &retlen, buffer);
760 
761 		if (res < 0 && !mtd_is_bitflip(res))
762 			return -EIO;
763 	}
764 	return 0;
765 }
766 
767 static int nftl_getgeo(struct mtd_blktrans_dev *dev,  struct hd_geometry *geo)
768 {
769 	struct NFTLrecord *nftl = (void *)dev;
770 
771 	geo->heads = nftl->heads;
772 	geo->sectors = nftl->sectors;
773 	geo->cylinders = nftl->cylinders;
774 
775 	return 0;
776 }
777 
778 /****************************************************************************
779  *
780  * Module stuff
781  *
782  ****************************************************************************/
783 
784 
785 static struct mtd_blktrans_ops nftl_tr = {
786 	.name		= "nftl",
787 	.major		= NFTL_MAJOR,
788 	.part_bits	= NFTL_PARTN_BITS,
789 	.blksize 	= 512,
790 	.getgeo		= nftl_getgeo,
791 	.readsect	= nftl_readblock,
792 #ifdef CONFIG_NFTL_RW
793 	.writesect	= nftl_writeblock,
794 #endif
795 	.add_mtd	= nftl_add_mtd,
796 	.remove_dev	= nftl_remove_dev,
797 	.owner		= THIS_MODULE,
798 };
799 
800 static int __init init_nftl(void)
801 {
802 	return register_mtd_blktrans(&nftl_tr);
803 }
804 
805 static void __exit cleanup_nftl(void)
806 {
807 	deregister_mtd_blktrans(&nftl_tr);
808 }
809 
810 module_init(init_nftl);
811 module_exit(cleanup_nftl);
812 
813 MODULE_LICENSE("GPL");
814 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
815 MODULE_DESCRIPTION("Support code for NAND Flash Translation Layer, used on M-Systems DiskOnChip 2000 and Millennium");
816 MODULE_ALIAS_BLOCKDEV_MAJOR(NFTL_MAJOR);
817