?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
e1000e: cleanup whitespace and indentation
[linux-2.6.git] / drivers / mtd / nftlcore.c
bloba75382aff5f68d17f419307b70eb4427f7c07507
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 <asm/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
48 static 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 != MTD_NANDFLASH || 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 if (!mtd_can_have_bb(mtd)) {
60 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
66 pr_debug("NFTL: add_mtd for %s\n", mtd->name);
67
68 nftl = kzalloc(sizeof(struct NFTLrecord), GFP_KERNEL);
69
70 if (!nftl)
71 return;
72
73 nftl->mbd.mtd = mtd;
74 nftl->mbd.devnum = -1;
75
76 nftl->mbd.tr = tr;
77
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 /*
106 Oh no we don't have
107 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",
113 nftl->cylinders, nftl->heads , nftl->sectors,
114 (long)nftl->cylinders * (long)nftl->heads *
115 (long)nftl->sectors );
116 }
117
118 if (add_mtd_blktrans_dev(&nftl->mbd)) {
119 kfree(nftl->ReplUnitTable);
120 kfree(nftl->EUNtable);
121 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
129 static void nftl_remove_dev(struct mtd_blktrans_dev *dev)
130 {
131 struct NFTLrecord *nftl = (void *)dev;
132
133 pr_debug("NFTL: remove_dev (i=%d)\n", dev->devnum);
134
135 del_mtd_blktrans_dev(dev);
136 kfree(nftl->ReplUnitTable);
137 kfree(nftl->EUNtable);
138 }
139
140 /*
141 * Read oob data from flash
142 */
143 int nftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
144 size_t *retlen, uint8_t *buf)
145 {
146 loff_t mask = mtd->writesize - 1;
147 struct mtd_oob_ops ops;
148 int res;
149
150 ops.mode = MTD_OPS_PLACE_OOB;
151 ops.ooboffs = offs & mask;
152 ops.ooblen = len;
153 ops.oobbuf = buf;
154 ops.datbuf = NULL;
155
156 res = mtd_read_oob(mtd, offs & ~mask, &ops);
157 *retlen = ops.oobretlen;
158 return res;
159 }
160
161 /*
162 * Write oob data to flash
163 */
164 int nftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
165 size_t *retlen, uint8_t *buf)
166 {
167 loff_t mask = mtd->writesize - 1;
168 struct mtd_oob_ops ops;
169 int res;
170
171 ops.mode = MTD_OPS_PLACE_OOB;
172 ops.ooboffs = offs & mask;
173 ops.ooblen = len;
174 ops.oobbuf = buf;
175 ops.datbuf = NULL;
176
177 res = mtd_write_oob(mtd, offs & ~mask, &ops);
178 *retlen = ops.oobretlen;
179 return res;
180 }
181
182 #ifdef CONFIG_NFTL_RW
183
184 /*
185 * Write data and oob to flash
186 */
187 static int nftl_write(struct mtd_info *mtd, loff_t offs, size_t len,
188 size_t *retlen, uint8_t *buf, uint8_t *oob)
189 {
190 loff_t mask = mtd->writesize - 1;
191 struct mtd_oob_ops ops;
192 int res;
193
194 ops.mode = MTD_OPS_PLACE_OOB;
195 ops.ooboffs = offs & mask;
196 ops.ooblen = mtd->oobsize;
197 ops.oobbuf = oob;
198 ops.datbuf = buf;
199 ops.len = len;
200
201 res = mtd_write_oob(mtd, offs & ~mask, &ops);
202 *retlen = ops.retlen;
203 return res;
204 }
205
206 /* 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 */
210 static 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) {
221 pr_debug("NFTL_findfreeblock: there are too few free EUNs\n");
222 return BLOCK_NIL;
223 }
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, "
242 "FirstEUN = %d\n", nftl->LastFreeEUN,
243 le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN));
244 return BLOCK_NIL;
245 }
246 } while (pot != nftl->LastFreeEUN);
247
248 return BLOCK_NIL;
249 }
250
251 static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned pendingblock )
252 {
253 struct mtd_info *mtd = nftl->mbd.mtd;
254 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;
263 size_t retlen;
264
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 }
275
276 /* Scan to find the Erase Unit which holds the actual data for each
277 512-byte block within the Chain.
278 */
279 silly = MAX_LOOPS;
280 targetEUN = BLOCK_NIL;
281 while (thisEUN <= nftl->lastEUN ) {
282 unsigned int status, foldmark;
283
284 targetEUN = thisEUN;
285 for (block = 0; block < nftl->EraseSize / 512; block ++) {
286 nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
287 (block * 512), 16 , &retlen,
288 (char *)&oob);
289 if (block == 2) {
290 foldmark = oob.u.c.FoldMark | oob.u.c.FoldMark1;
291 if (foldmark == FOLD_MARK_IN_PROGRESS) {
292 pr_debug("Write Inhibited on EUN %d\n", thisEUN);
293 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 }
301 status = oob.b.Status | oob.b.Status1;
302 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
313 printk(KERN_WARNING
314 "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
322 printk(KERN_WARNING
323 "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 }
341
342 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
348 with them (i.e. BlockMap[block] != BLOCK_NIL) are
349 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) {
357 pr_debug("Setting inplace to 0. VUC %d, "
358 "block %d was %x lastEUN, "
359 "and is in EUN %d (%s) %d\n",
360 thisVUC, block, BlockLastState[block],
361 BlockMap[block],
362 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) {
373 pr_debug("Pending write not free in EUN %d. "
374 "Folding out of place.\n", targetEUN);
375 inplace = 0;
376 }
377 }
378
379 if (!inplace) {
380 pr_debug("Cannot fold Virtual Unit Chain %d in place. "
381 "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) {
385 /* Ouch. Now we're screwed. We need to do a
386 fold-in-place of another chain to make room
387 for this one. We need a better way of selecting
388 which chain to fold, because makefreeblock will
389 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 {
396 /* 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;
402 nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 2 * 512 + 8,
403 8, &retlen, (char *)&oob.u);
404 }
405
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 */
410 pr_debug("Folding chain %d into unit %d\n", thisVUC, targetEUN);
411 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
421 /* copy only in non free block (free blocks can only
422 happen in case of media errors or deleted blocks) */
423 if (BlockMap[block] == BLOCK_NIL)
424 continue;
425
426 ret = mtd_read(mtd,
427 (nftl->EraseSize * BlockMap[block]) + (block * 512),
428 512,
429 &retlen,
430 movebuf);
431 if (ret < 0 && !mtd_is_bitflip(ret)) {
432 ret = mtd_read(mtd,
433 (nftl->EraseSize * BlockMap[block]) + (block * 512),
434 512,
435 &retlen,
436 movebuf);
437 if (ret != -EIO)
438 printk("Error went away on retry.\n");
439 }
440 memset(&oob, 0xff, sizeof(struct nftl_oob));
441 oob.b.Status = oob.b.Status1 = SECTOR_USED;
442
443 nftl_write(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) +
444 (block * 512), 512, &retlen, movebuf, (char *)&oob);
445 }
446
447 /* add the header so that it is now a valid chain */
448 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
449 oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = BLOCK_NIL;
450
451 nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 8,
452 8, &retlen, (char *)&oob.u);
453
454 /* OK. We've moved the whole lot into the new block. Now we have to free the original blocks. */
455
456 /* At this point, we have two different chains for this Virtual Unit, and no way to tell
457 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];
462 pr_debug("Want to erase\n");
463
464 /* For each block in the old chain (except the targetEUN of course),
465 free it and make it available for future use */
466 while (thisEUN <= nftl->lastEUN && thisEUN != targetEUN) {
467 unsigned int EUNtmp;
468
469 EUNtmp = nftl->ReplUnitTable[thisEUN];
470
471 if (NFTL_formatblock(nftl, thisEUN) < 0) {
472 /* could not erase : mark block as reserved
473 */
474 nftl->ReplUnitTable[thisEUN] = BLOCK_RESERVED;
475 } else {
476 /* correctly erased : mark it as free */
477 nftl->ReplUnitTable[thisEUN] = BLOCK_FREE;
478 nftl->numfreeEUNs++;
479 }
480 thisEUN = EUNtmp;
481 }
482
483 /* 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
490 static u16 NFTL_makefreeblock( struct NFTLrecord *nftl , unsigned pendingblock)
491 {
492 /* This is the part that needs some cleverness applied.
493 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");
533 return BLOCK_NIL;
534 }
535
536 return NFTL_foldchain (nftl, LongestChain, pendingblock);
537 }
538
539 /* NFTL_findwriteunit: Return the unit number into which we can write
540 for this block. Make it available if it isn't already
541 */
542 static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
543 {
544 u16 lastEUN;
545 u16 thisVUC = block / (nftl->EraseSize / 512);
546 struct mtd_info *mtd = nftl->mbd.mtd;
547 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
558 /* This condition catches the 0x[7f]fff cases, as well as
559 being a sanity check for past-end-of-media access
560 */
561 lastEUN = BLOCK_NIL;
562 writeEUN = nftl->EUNtable[thisVUC];
563 silly = MAX_LOOPS;
564 while (writeEUN <= nftl->lastEUN) {
565 struct nftl_bci bci;
566 size_t retlen;
567 unsigned int status;
568
569 lastEUN = writeEUN;
570
571 nftl_read_oob(mtd,
572 (writeEUN * nftl->EraseSize) + blockofs,
573 8, &retlen, (char *)&bci);
574
575 pr_debug("Status of block %d in EUN %d is %x\n",
576 block , writeEUN, le16_to_cpu(bci.Status));
577
578 status = bci.Status | bci.Status1;
579 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.
589 break;
590 }
591
592 if (!silly--) {
593 printk(KERN_WARNING
594 "Infinite loop in Virtual Unit Chain 0x%x\n",
595 thisVUC);
596 return BLOCK_NIL;
597 }
598
599 /* Skip to next block in chain */
600 writeEUN = nftl->ReplUnitTable[writeEUN];
601 }
602
603 /* OK. We didn't find one in the existing chain, or there
604 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];
617
618 //printk("Write to VirtualUnitChain %d, calling makefreeblock()\n", thisVUC);
619 writeEUN = NFTL_makefreeblock(nftl, BLOCK_NIL);
620
621 if (writeEUN == BLOCK_NIL) {
622 /* OK, we accept that the above comment is
623 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 */
628 pr_debug("Using desperate==1 to find free EUN to accommodate write to VUC %d\n", thisVUC);
629 writeEUN = NFTL_findfreeblock(nftl, 1);
630 }
631 if (writeEUN == BLOCK_NIL) {
632 /* Ouch. This should never happen - we should
633 always be able to make some room somehow.
634 If we get here, we've allocated more storage
635 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;
640 }
641 //printk("Restarting scan\n");
642 lastEUN = BLOCK_NIL;
643 continue;
644 }
645
646 /* We've found a free block. Insert it into the chain. */
647
648 if (lastEUN != BLOCK_NIL) {
649 thisVUC |= 0x8000; /* It's a replacement block */
650 } else {
651 /* The first block in a new chain */
652 nftl->EUNtable[thisVUC] = writeEUN;
653 }
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 */
660 nftl_read_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
661 &retlen, (char *)&oob.u);
662
663 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
664
665 nftl_write_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
666 &retlen, (char *)&oob.u);
667
668 /* we link the new block to the chain only after the
669 block is ready. It avoids the case where the chain
670 could point to a free block */
671 if (lastEUN != BLOCK_NIL) {
672 /* Both in our cache... */
673 nftl->ReplUnitTable[lastEUN] = writeEUN;
674 /* ... and on the flash itself */
675 nftl_read_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
676 8, &retlen, (char *)&oob.u);
677
678 oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum
679 = cpu_to_le16(writeEUN);
680
681 nftl_write_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
682 8, &retlen, (char *)&oob.u);
683 }
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);
691 return BLOCK_NIL;
692 }
693
694 static 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;
714
715 nftl_write(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs,
716 512, &retlen, (char *)buffer, (char *)&oob);
717 return 0;
718 }
719 #endif /* CONFIG_NFTL_RW */
720
721 static int nftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
722 char *buffer)
723 {
724 struct NFTLrecord *nftl = (void *)mbd;
725 struct mtd_info *mtd = nftl->mbd.mtd;
726 u16 lastgoodEUN;
727 u16 thisEUN = nftl->EUNtable[block / (nftl->EraseSize / 512)];
728 unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
729 unsigned int status;
730 int silly = MAX_LOOPS;
731 size_t retlen;
732 struct nftl_bci bci;
733
734 lastgoodEUN = BLOCK_NIL;
735
736 if (thisEUN != BLOCK_NIL) {
737 while (thisEUN < nftl->nb_blocks) {
738 if (nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
739 blockofs, 8, &retlen,
740 (char *)&bci) < 0)
741 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 }
770 }
771
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;
779 int res = mtd_read(mtd, ptr, 512, &retlen, buffer);
780
781 if (res < 0 && !mtd_is_bitflip(res))
782 return -EIO;
783 }
784 return 0;
785 }
786
787 static 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
805 static struct mtd_blktrans_ops nftl_tr = {
806 .name = "nftl",
807 .major = NFTL_MAJOR,
808 .part_bits = NFTL_PARTN_BITS,
809 .blksize = 512,
810 .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
820 static int __init init_nftl(void)
821 {
822 return register_mtd_blktrans(&nftl_tr);
823 }
824
825 static void __exit cleanup_nftl(void)
826 {
827 deregister_mtd_blktrans(&nftl_tr);
828 }
829
830 module_init(init_nftl);
831 module_exit(cleanup_nftl);
832
833 MODULE_LICENSE("GPL");
834 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
835 MODULE_DESCRIPTION("Support code for NAND Flash Translation Layer, used on M-Systems DiskOnChip 2000 and Millennium");
836 MODULE_ALIAS_BLOCKDEV_MAJOR(NFTL_MAJOR);
Linus' kernel tree