?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.33-rc6
[cris-mirror.git] / drivers / mtd / inftlcore.c
blob8aca5523a3370fd916595e146d2ed9df4c4d9de2
1 /*
2 * inftlcore.c -- Linux driver for Inverse Flash Translation Layer (INFTL)
3 *
4 * (C) Copyright 2002, Greg Ungerer (gerg@snapgear.com)
5 *
6 * Based heavily on the nftlcore.c code which is:
7 * (c) 1999 Machine Vision Holdings, Inc.
8 * Author: David Woodhouse <dwmw2@infradead.org>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/sched.h>
30 #include <linux/init.h>
31 #include <linux/kmod.h>
32 #include <linux/hdreg.h>
33 #include <linux/mtd/mtd.h>
34 #include <linux/mtd/nftl.h>
35 #include <linux/mtd/inftl.h>
36 #include <linux/mtd/nand.h>
37 #include <asm/uaccess.h>
38 #include <asm/errno.h>
39 #include <asm/io.h>
40
41 /*
42 * Maximum number of loops while examining next block, to have a
43 * chance to detect consistency problems (they should never happen
44 * because of the checks done in the mounting.
45 */
46 #define MAX_LOOPS 10000
47
48 static void inftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
49 {
50 struct INFTLrecord *inftl;
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->block_isbad) {
60 printk(KERN_ERR
61 "INFTL 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 DEBUG(MTD_DEBUG_LEVEL3, "INFTL: add_mtd for %s\n", mtd->name);
67
68 inftl = kzalloc(sizeof(*inftl), GFP_KERNEL);
69
70 if (!inftl) {
71 printk(KERN_WARNING "INFTL: Out of memory for data structures\n");
72 return;
73 }
74
75 inftl->mbd.mtd = mtd;
76 inftl->mbd.devnum = -1;
77
78 inftl->mbd.tr = tr;
79
80 if (INFTL_mount(inftl) < 0) {
81 printk(KERN_WARNING "INFTL: could not mount device\n");
82 kfree(inftl);
83 return;
84 }
85
86 /* OK, it's a new one. Set up all the data structures. */
87
88 /* Calculate geometry */
89 inftl->cylinders = 1024;
90 inftl->heads = 16;
91
92 temp = inftl->cylinders * inftl->heads;
93 inftl->sectors = inftl->mbd.size / temp;
94 if (inftl->mbd.size % temp) {
95 inftl->sectors++;
96 temp = inftl->cylinders * inftl->sectors;
97 inftl->heads = inftl->mbd.size / temp;
98
99 if (inftl->mbd.size % temp) {
100 inftl->heads++;
101 temp = inftl->heads * inftl->sectors;
102 inftl->cylinders = inftl->mbd.size / temp;
103 }
104 }
105
106 if (inftl->mbd.size != inftl->heads * inftl->cylinders * inftl->sectors) {
107 /*
108 Oh no we don't have
109 mbd.size == heads * cylinders * sectors
110 */
111 printk(KERN_WARNING "INFTL: cannot calculate a geometry to "
112 "match size of 0x%lx.\n", inftl->mbd.size);
113 printk(KERN_WARNING "INFTL: using C:%d H:%d S:%d "
114 "(== 0x%lx sects)\n",
115 inftl->cylinders, inftl->heads , inftl->sectors,
116 (long)inftl->cylinders * (long)inftl->heads *
117 (long)inftl->sectors );
118 }
119
120 if (add_mtd_blktrans_dev(&inftl->mbd)) {
121 kfree(inftl->PUtable);
122 kfree(inftl->VUtable);
123 kfree(inftl);
124 return;
125 }
126 #ifdef PSYCHO_DEBUG
127 printk(KERN_INFO "INFTL: Found new inftl%c\n", inftl->mbd.devnum + 'a');
128 #endif
129 return;
130 }
131
132 static void inftl_remove_dev(struct mtd_blktrans_dev *dev)
133 {
134 struct INFTLrecord *inftl = (void *)dev;
135
136 DEBUG(MTD_DEBUG_LEVEL3, "INFTL: remove_dev (i=%d)\n", dev->devnum);
137
138 del_mtd_blktrans_dev(dev);
139
140 kfree(inftl->PUtable);
141 kfree(inftl->VUtable);
142 kfree(inftl);
143 }
144
145 /*
146 * Actual INFTL access routines.
147 */
148
149 /*
150 * Read oob data from flash
151 */
152 int inftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
153 size_t *retlen, uint8_t *buf)
154 {
155 struct mtd_oob_ops ops;
156 int res;
157
158 ops.mode = MTD_OOB_PLACE;
159 ops.ooboffs = offs & (mtd->writesize - 1);
160 ops.ooblen = len;
161 ops.oobbuf = buf;
162 ops.datbuf = NULL;
163
164 res = mtd->read_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
165 *retlen = ops.oobretlen;
166 return res;
167 }
168
169 /*
170 * Write oob data to flash
171 */
172 int inftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
173 size_t *retlen, uint8_t *buf)
174 {
175 struct mtd_oob_ops ops;
176 int res;
177
178 ops.mode = MTD_OOB_PLACE;
179 ops.ooboffs = offs & (mtd->writesize - 1);
180 ops.ooblen = len;
181 ops.oobbuf = buf;
182 ops.datbuf = NULL;
183
184 res = mtd->write_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
185 *retlen = ops.oobretlen;
186 return res;
187 }
188
189 /*
190 * Write data and oob to flash
191 */
192 static int inftl_write(struct mtd_info *mtd, loff_t offs, size_t len,
193 size_t *retlen, uint8_t *buf, uint8_t *oob)
194 {
195 struct mtd_oob_ops ops;
196 int res;
197
198 ops.mode = MTD_OOB_PLACE;
199 ops.ooboffs = offs;
200 ops.ooblen = mtd->oobsize;
201 ops.oobbuf = oob;
202 ops.datbuf = buf;
203 ops.len = len;
204
205 res = mtd->write_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
206 *retlen = ops.retlen;
207 return res;
208 }
209
210 /*
211 * INFTL_findfreeblock: Find a free Erase Unit on the INFTL partition.
212 * This function is used when the give Virtual Unit Chain.
213 */
214 static u16 INFTL_findfreeblock(struct INFTLrecord *inftl, int desperate)
215 {
216 u16 pot = inftl->LastFreeEUN;
217 int silly = inftl->nb_blocks;
218
219 DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_findfreeblock(inftl=%p,"
220 "desperate=%d)\n", inftl, desperate);
221
222 /*
223 * Normally, we force a fold to happen before we run out of free
224 * blocks completely.
225 */
226 if (!desperate && inftl->numfreeEUNs < 2) {
227 DEBUG(MTD_DEBUG_LEVEL1, "INFTL: there are too few free "
228 "EUNs (%d)\n", inftl->numfreeEUNs);
229 return BLOCK_NIL;
230 }
231
232 /* Scan for a free block */
233 do {
234 if (inftl->PUtable[pot] == BLOCK_FREE) {
235 inftl->LastFreeEUN = pot;
236 return pot;
237 }
238
239 if (++pot > inftl->lastEUN)
240 pot = 0;
241
242 if (!silly--) {
243 printk(KERN_WARNING "INFTL: no free blocks found! "
244 "EUN range = %d - %d\n", 0, inftl->LastFreeEUN);
245 return BLOCK_NIL;
246 }
247 } while (pot != inftl->LastFreeEUN);
248
249 return BLOCK_NIL;
250 }
251
252 static u16 INFTL_foldchain(struct INFTLrecord *inftl, unsigned thisVUC, unsigned pendingblock)
253 {
254 u16 BlockMap[MAX_SECTORS_PER_UNIT];
255 unsigned char BlockDeleted[MAX_SECTORS_PER_UNIT];
256 unsigned int thisEUN, prevEUN, status;
257 struct mtd_info *mtd = inftl->mbd.mtd;
258 int block, silly;
259 unsigned int targetEUN;
260 struct inftl_oob oob;
261 size_t retlen;
262
263 DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_foldchain(inftl=%p,thisVUC=%d,"
264 "pending=%d)\n", inftl, thisVUC, pendingblock);
265
266 memset(BlockMap, 0xff, sizeof(BlockMap));
267 memset(BlockDeleted, 0, sizeof(BlockDeleted));
268
269 thisEUN = targetEUN = inftl->VUtable[thisVUC];
270
271 if (thisEUN == BLOCK_NIL) {
272 printk(KERN_WARNING "INFTL: trying to fold non-existent "
273 "Virtual Unit Chain %d!\n", thisVUC);
274 return BLOCK_NIL;
275 }
276
277 /*
278 * Scan to find the Erase Unit which holds the actual data for each
279 * 512-byte block within the Chain.
280 */
281 silly = MAX_LOOPS;
282 while (thisEUN < inftl->nb_blocks) {
283 for (block = 0; block < inftl->EraseSize/SECTORSIZE; block ++) {
284 if ((BlockMap[block] != BLOCK_NIL) ||
285 BlockDeleted[block])
286 continue;
287
288 if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize)
289 + (block * SECTORSIZE), 16, &retlen,
290 (char *)&oob) < 0)
291 status = SECTOR_IGNORE;
292 else
293 status = oob.b.Status | oob.b.Status1;
294
295 switch(status) {
296 case SECTOR_FREE:
297 case SECTOR_IGNORE:
298 break;
299 case SECTOR_USED:
300 BlockMap[block] = thisEUN;
301 continue;
302 case SECTOR_DELETED:
303 BlockDeleted[block] = 1;
304 continue;
305 default:
306 printk(KERN_WARNING "INFTL: unknown status "
307 "for block %d in EUN %d: %x\n",
308 block, thisEUN, status);
309 break;
310 }
311 }
312
313 if (!silly--) {
314 printk(KERN_WARNING "INFTL: infinite loop in Virtual "
315 "Unit Chain 0x%x\n", thisVUC);
316 return BLOCK_NIL;
317 }
318
319 thisEUN = inftl->PUtable[thisEUN];
320 }
321
322 /*
323 * OK. We now know the location of every block in the Virtual Unit
324 * Chain, and the Erase Unit into which we are supposed to be copying.
325 * Go for it.
326 */
327 DEBUG(MTD_DEBUG_LEVEL1, "INFTL: folding chain %d into unit %d\n",
328 thisVUC, targetEUN);
329
330 for (block = 0; block < inftl->EraseSize/SECTORSIZE ; block++) {
331 unsigned char movebuf[SECTORSIZE];
332 int ret;
333
334 /*
335 * If it's in the target EUN already, or if it's pending write,
336 * do nothing.
337 */
338 if (BlockMap[block] == targetEUN || (pendingblock ==
339 (thisVUC * (inftl->EraseSize / SECTORSIZE) + block))) {
340 continue;
341 }
342
343 /*
344 * Copy only in non free block (free blocks can only
345 * happen in case of media errors or deleted blocks).
346 */
347 if (BlockMap[block] == BLOCK_NIL)
348 continue;
349
350 ret = mtd->read(mtd, (inftl->EraseSize * BlockMap[block]) +
351 (block * SECTORSIZE), SECTORSIZE, &retlen,
352 movebuf);
353 if (ret < 0 && ret != -EUCLEAN) {
354 ret = mtd->read(mtd,
355 (inftl->EraseSize * BlockMap[block]) +
356 (block * SECTORSIZE), SECTORSIZE,
357 &retlen, movebuf);
358 if (ret != -EIO)
359 DEBUG(MTD_DEBUG_LEVEL1, "INFTL: error went "
360 "away on retry?\n");
361 }
362 memset(&oob, 0xff, sizeof(struct inftl_oob));
363 oob.b.Status = oob.b.Status1 = SECTOR_USED;
364
365 inftl_write(inftl->mbd.mtd, (inftl->EraseSize * targetEUN) +
366 (block * SECTORSIZE), SECTORSIZE, &retlen,
367 movebuf, (char *)&oob);
368 }
369
370 /*
371 * Newest unit in chain now contains data from _all_ older units.
372 * So go through and erase each unit in chain, oldest first. (This
373 * is important, by doing oldest first if we crash/reboot then it
374 * it is relatively simple to clean up the mess).
375 */
376 DEBUG(MTD_DEBUG_LEVEL1, "INFTL: want to erase virtual chain %d\n",
377 thisVUC);
378
379 for (;;) {
380 /* Find oldest unit in chain. */
381 thisEUN = inftl->VUtable[thisVUC];
382 prevEUN = BLOCK_NIL;
383 while (inftl->PUtable[thisEUN] != BLOCK_NIL) {
384 prevEUN = thisEUN;
385 thisEUN = inftl->PUtable[thisEUN];
386 }
387
388 /* Check if we are all done */
389 if (thisEUN == targetEUN)
390 break;
391
392 /* Unlink the last block from the chain. */
393 inftl->PUtable[prevEUN] = BLOCK_NIL;
394
395 /* Now try to erase it. */
396 if (INFTL_formatblock(inftl, thisEUN) < 0) {
397 /*
398 * Could not erase : mark block as reserved.
399 */
400 inftl->PUtable[thisEUN] = BLOCK_RESERVED;
401 } else {
402 /* Correctly erased : mark it as free */
403 inftl->PUtable[thisEUN] = BLOCK_FREE;
404 inftl->numfreeEUNs++;
405 }
406 }
407
408 return targetEUN;
409 }
410
411 static u16 INFTL_makefreeblock(struct INFTLrecord *inftl, unsigned pendingblock)
412 {
413 /*
414 * This is the part that needs some cleverness applied.
415 * For now, I'm doing the minimum applicable to actually
416 * get the thing to work.
417 * Wear-levelling and other clever stuff needs to be implemented
418 * and we also need to do some assessment of the results when
419 * the system loses power half-way through the routine.
420 */
421 u16 LongestChain = 0;
422 u16 ChainLength = 0, thislen;
423 u16 chain, EUN;
424
425 DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_makefreeblock(inftl=%p,"
426 "pending=%d)\n", inftl, pendingblock);
427
428 for (chain = 0; chain < inftl->nb_blocks; chain++) {
429 EUN = inftl->VUtable[chain];
430 thislen = 0;
431
432 while (EUN <= inftl->lastEUN) {
433 thislen++;
434 EUN = inftl->PUtable[EUN];
435 if (thislen > 0xff00) {
436 printk(KERN_WARNING "INFTL: endless loop in "
437 "Virtual Chain %d: Unit %x\n",
438 chain, EUN);
439 /*
440 * Actually, don't return failure.
441 * Just ignore this chain and get on with it.
442 */
443 thislen = 0;
444 break;
445 }
446 }
447
448 if (thislen > ChainLength) {
449 ChainLength = thislen;
450 LongestChain = chain;
451 }
452 }
453
454 if (ChainLength < 2) {
455 printk(KERN_WARNING "INFTL: no Virtual Unit Chains available "
456 "for folding. Failing request\n");
457 return BLOCK_NIL;
458 }
459
460 return INFTL_foldchain(inftl, LongestChain, pendingblock);
461 }
462
463 static int nrbits(unsigned int val, int bitcount)
464 {
465 int i, total = 0;
466
467 for (i = 0; (i < bitcount); i++)
468 total += (((0x1 << i) & val) ? 1 : 0);
469 return total;
470 }
471
472 /*
473 * INFTL_findwriteunit: Return the unit number into which we can write
474 * for this block. Make it available if it isn't already.
475 */
476 static inline u16 INFTL_findwriteunit(struct INFTLrecord *inftl, unsigned block)
477 {
478 unsigned int thisVUC = block / (inftl->EraseSize / SECTORSIZE);
479 unsigned int thisEUN, writeEUN, prev_block, status;
480 unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize -1);
481 struct mtd_info *mtd = inftl->mbd.mtd;
482 struct inftl_oob oob;
483 struct inftl_bci bci;
484 unsigned char anac, nacs, parity;
485 size_t retlen;
486 int silly, silly2 = 3;
487
488 DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_findwriteunit(inftl=%p,"
489 "block=%d)\n", inftl, block);
490
491 do {
492 /*
493 * Scan the media to find a unit in the VUC which has
494 * a free space for the block in question.
495 */
496 writeEUN = BLOCK_NIL;
497 thisEUN = inftl->VUtable[thisVUC];
498 silly = MAX_LOOPS;
499
500 while (thisEUN <= inftl->lastEUN) {
501 inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) +
502 blockofs, 8, &retlen, (char *)&bci);
503
504 status = bci.Status | bci.Status1;
505 DEBUG(MTD_DEBUG_LEVEL3, "INFTL: status of block %d in "
506 "EUN %d is %x\n", block , writeEUN, status);
507
508 switch(status) {
509 case SECTOR_FREE:
510 writeEUN = thisEUN;
511 break;
512 case SECTOR_DELETED:
513 case SECTOR_USED:
514 /* Can't go any further */
515 goto hitused;
516 case SECTOR_IGNORE:
517 break;
518 default:
519 /*
520 * Invalid block. Don't use it any more.
521 * Must implement.
522 */
523 break;
524 }
525
526 if (!silly--) {
527 printk(KERN_WARNING "INFTL: infinite loop in "
528 "Virtual Unit Chain 0x%x\n", thisVUC);
529 return BLOCK_NIL;
530 }
531
532 /* Skip to next block in chain */
533 thisEUN = inftl->PUtable[thisEUN];
534 }
535
536 hitused:
537 if (writeEUN != BLOCK_NIL)
538 return writeEUN;
539
540
541 /*
542 * OK. We didn't find one in the existing chain, or there
543 * is no existing chain. Allocate a new one.
544 */
545 writeEUN = INFTL_findfreeblock(inftl, 0);
546
547 if (writeEUN == BLOCK_NIL) {
548 /*
549 * That didn't work - there were no free blocks just
550 * waiting to be picked up. We're going to have to fold
551 * a chain to make room.
552 */
553 thisEUN = INFTL_makefreeblock(inftl, block);
554
555 /*
556 * Hopefully we free something, lets try again.
557 * This time we are desperate...
558 */
559 DEBUG(MTD_DEBUG_LEVEL1, "INFTL: using desperate==1 "
560 "to find free EUN to accommodate write to "
561 "VUC %d\n", thisVUC);
562 writeEUN = INFTL_findfreeblock(inftl, 1);
563 if (writeEUN == BLOCK_NIL) {
564 /*
565 * Ouch. This should never happen - we should
566 * always be able to make some room somehow.
567 * If we get here, we've allocated more storage
568 * space than actual media, or our makefreeblock
569 * routine is missing something.
570 */
571 printk(KERN_WARNING "INFTL: cannot make free "
572 "space.\n");
573 #ifdef DEBUG
574 INFTL_dumptables(inftl);
575 INFTL_dumpVUchains(inftl);
576 #endif
577 return BLOCK_NIL;
578 }
579 }
580
581 /*
582 * Insert new block into virtual chain. Firstly update the
583 * block headers in flash...
584 */
585 anac = 0;
586 nacs = 0;
587 thisEUN = inftl->VUtable[thisVUC];
588 if (thisEUN != BLOCK_NIL) {
589 inftl_read_oob(mtd, thisEUN * inftl->EraseSize
590 + 8, 8, &retlen, (char *)&oob.u);
591 anac = oob.u.a.ANAC + 1;
592 nacs = oob.u.a.NACs + 1;
593 }
594
595 prev_block = inftl->VUtable[thisVUC];
596 if (prev_block < inftl->nb_blocks)
597 prev_block -= inftl->firstEUN;
598
599 parity = (nrbits(thisVUC, 16) & 0x1) ? 0x1 : 0;
600 parity |= (nrbits(prev_block, 16) & 0x1) ? 0x2 : 0;
601 parity |= (nrbits(anac, 8) & 0x1) ? 0x4 : 0;
602 parity |= (nrbits(nacs, 8) & 0x1) ? 0x8 : 0;
603
604 oob.u.a.virtualUnitNo = cpu_to_le16(thisVUC);
605 oob.u.a.prevUnitNo = cpu_to_le16(prev_block);
606 oob.u.a.ANAC = anac;
607 oob.u.a.NACs = nacs;
608 oob.u.a.parityPerField = parity;
609 oob.u.a.discarded = 0xaa;
610
611 inftl_write_oob(mtd, writeEUN * inftl->EraseSize + 8, 8,
612 &retlen, (char *)&oob.u);
613
614 /* Also back up header... */
615 oob.u.b.virtualUnitNo = cpu_to_le16(thisVUC);
616 oob.u.b.prevUnitNo = cpu_to_le16(prev_block);
617 oob.u.b.ANAC = anac;
618 oob.u.b.NACs = nacs;
619 oob.u.b.parityPerField = parity;
620 oob.u.b.discarded = 0xaa;
621
622 inftl_write_oob(mtd, writeEUN * inftl->EraseSize +
623 SECTORSIZE * 4 + 8, 8, &retlen, (char *)&oob.u);
624
625 inftl->PUtable[writeEUN] = inftl->VUtable[thisVUC];
626 inftl->VUtable[thisVUC] = writeEUN;
627
628 inftl->numfreeEUNs--;
629 return writeEUN;
630
631 } while (silly2--);
632
633 printk(KERN_WARNING "INFTL: error folding to make room for Virtual "
634 "Unit Chain 0x%x\n", thisVUC);
635 return BLOCK_NIL;
636 }
637
638 /*
639 * Given a Virtual Unit Chain, see if it can be deleted, and if so do it.
640 */
641 static void INFTL_trydeletechain(struct INFTLrecord *inftl, unsigned thisVUC)
642 {
643 struct mtd_info *mtd = inftl->mbd.mtd;
644 unsigned char BlockUsed[MAX_SECTORS_PER_UNIT];
645 unsigned char BlockDeleted[MAX_SECTORS_PER_UNIT];
646 unsigned int thisEUN, status;
647 int block, silly;
648 struct inftl_bci bci;
649 size_t retlen;
650
651 DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_trydeletechain(inftl=%p,"
652 "thisVUC=%d)\n", inftl, thisVUC);
653
654 memset(BlockUsed, 0, sizeof(BlockUsed));
655 memset(BlockDeleted, 0, sizeof(BlockDeleted));
656
657 thisEUN = inftl->VUtable[thisVUC];
658 if (thisEUN == BLOCK_NIL) {
659 printk(KERN_WARNING "INFTL: trying to delete non-existent "
660 "Virtual Unit Chain %d!\n", thisVUC);
661 return;
662 }
663
664 /*
665 * Scan through the Erase Units to determine whether any data is in
666 * each of the 512-byte blocks within the Chain.
667 */
668 silly = MAX_LOOPS;
669 while (thisEUN < inftl->nb_blocks) {
670 for (block = 0; block < inftl->EraseSize/SECTORSIZE; block++) {
671 if (BlockUsed[block] || BlockDeleted[block])
672 continue;
673
674 if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize)
675 + (block * SECTORSIZE), 8 , &retlen,
676 (char *)&bci) < 0)
677 status = SECTOR_IGNORE;
678 else
679 status = bci.Status | bci.Status1;
680
681 switch(status) {
682 case SECTOR_FREE:
683 case SECTOR_IGNORE:
684 break;
685 case SECTOR_USED:
686 BlockUsed[block] = 1;
687 continue;
688 case SECTOR_DELETED:
689 BlockDeleted[block] = 1;
690 continue;
691 default:
692 printk(KERN_WARNING "INFTL: unknown status "
693 "for block %d in EUN %d: 0x%x\n",
694 block, thisEUN, status);
695 }
696 }
697
698 if (!silly--) {
699 printk(KERN_WARNING "INFTL: infinite loop in Virtual "
700 "Unit Chain 0x%x\n", thisVUC);
701 return;
702 }
703
704 thisEUN = inftl->PUtable[thisEUN];
705 }
706
707 for (block = 0; block < inftl->EraseSize/SECTORSIZE; block++)
708 if (BlockUsed[block])
709 return;
710
711 /*
712 * For each block in the chain free it and make it available
713 * for future use. Erase from the oldest unit first.
714 */
715 DEBUG(MTD_DEBUG_LEVEL1, "INFTL: deleting empty VUC %d\n", thisVUC);
716
717 for (;;) {
718 u16 *prevEUN = &inftl->VUtable[thisVUC];
719 thisEUN = *prevEUN;
720
721 /* If the chain is all gone already, we're done */
722 if (thisEUN == BLOCK_NIL) {
723 DEBUG(MTD_DEBUG_LEVEL2, "INFTL: Empty VUC %d for deletion was already absent\n", thisEUN);
724 return;
725 }
726
727 /* Find oldest unit in chain. */
728 while (inftl->PUtable[thisEUN] != BLOCK_NIL) {
729 BUG_ON(thisEUN >= inftl->nb_blocks);
730
731 prevEUN = &inftl->PUtable[thisEUN];
732 thisEUN = *prevEUN;
733 }
734
735 DEBUG(MTD_DEBUG_LEVEL3, "Deleting EUN %d from VUC %d\n",
736 thisEUN, thisVUC);
737
738 if (INFTL_formatblock(inftl, thisEUN) < 0) {
739 /*
740 * Could not erase : mark block as reserved.
741 */
742 inftl->PUtable[thisEUN] = BLOCK_RESERVED;
743 } else {
744 /* Correctly erased : mark it as free */
745 inftl->PUtable[thisEUN] = BLOCK_FREE;
746 inftl->numfreeEUNs++;
747 }
748
749 /* Now sort out whatever was pointing to it... */
750 *prevEUN = BLOCK_NIL;
751
752 /* Ideally we'd actually be responsive to new
753 requests while we're doing this -- if there's
754 free space why should others be made to wait? */
755 cond_resched();
756 }
757
758 inftl->VUtable[thisVUC] = BLOCK_NIL;
759 }
760
761 static int INFTL_deleteblock(struct INFTLrecord *inftl, unsigned block)
762 {
763 unsigned int thisEUN = inftl->VUtable[block / (inftl->EraseSize / SECTORSIZE)];
764 unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1);
765 struct mtd_info *mtd = inftl->mbd.mtd;
766 unsigned int status;
767 int silly = MAX_LOOPS;
768 size_t retlen;
769 struct inftl_bci bci;
770
771 DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_deleteblock(inftl=%p,"
772 "block=%d)\n", inftl, block);
773
774 while (thisEUN < inftl->nb_blocks) {
775 if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) +
776 blockofs, 8, &retlen, (char *)&bci) < 0)
777 status = SECTOR_IGNORE;
778 else
779 status = bci.Status | bci.Status1;
780
781 switch (status) {
782 case SECTOR_FREE:
783 case SECTOR_IGNORE:
784 break;
785 case SECTOR_DELETED:
786 thisEUN = BLOCK_NIL;
787 goto foundit;
788 case SECTOR_USED:
789 goto foundit;
790 default:
791 printk(KERN_WARNING "INFTL: unknown status for "
792 "block %d in EUN %d: 0x%x\n",
793 block, thisEUN, status);
794 break;
795 }
796
797 if (!silly--) {
798 printk(KERN_WARNING "INFTL: infinite loop in Virtual "
799 "Unit Chain 0x%x\n",
800 block / (inftl->EraseSize / SECTORSIZE));
801 return 1;
802 }
803 thisEUN = inftl->PUtable[thisEUN];
804 }
805
806 foundit:
807 if (thisEUN != BLOCK_NIL) {
808 loff_t ptr = (thisEUN * inftl->EraseSize) + blockofs;
809
810 if (inftl_read_oob(mtd, ptr, 8, &retlen, (char *)&bci) < 0)
811 return -EIO;
812 bci.Status = bci.Status1 = SECTOR_DELETED;
813 if (inftl_write_oob(mtd, ptr, 8, &retlen, (char *)&bci) < 0)
814 return -EIO;
815 INFTL_trydeletechain(inftl, block / (inftl->EraseSize / SECTORSIZE));
816 }
817 return 0;
818 }
819
820 static int inftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block,
821 char *buffer)
822 {
823 struct INFTLrecord *inftl = (void *)mbd;
824 unsigned int writeEUN;
825 unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1);
826 size_t retlen;
827 struct inftl_oob oob;
828 char *p, *pend;
829
830 DEBUG(MTD_DEBUG_LEVEL3, "INFTL: inftl_writeblock(inftl=%p,block=%ld,"
831 "buffer=%p)\n", inftl, block, buffer);
832
833 /* Is block all zero? */
834 pend = buffer + SECTORSIZE;
835 for (p = buffer; p < pend && !*p; p++)
836 ;
837
838 if (p < pend) {
839 writeEUN = INFTL_findwriteunit(inftl, block);
840
841 if (writeEUN == BLOCK_NIL) {
842 printk(KERN_WARNING "inftl_writeblock(): cannot find "
843 "block to write to\n");
844 /*
845 * If we _still_ haven't got a block to use,
846 * we're screwed.
847 */
848 return 1;
849 }
850
851 memset(&oob, 0xff, sizeof(struct inftl_oob));
852 oob.b.Status = oob.b.Status1 = SECTOR_USED;
853
854 inftl_write(inftl->mbd.mtd, (writeEUN * inftl->EraseSize) +
855 blockofs, SECTORSIZE, &retlen, (char *)buffer,
856 (char *)&oob);
857 /*
858 * need to write SECTOR_USED flags since they are not written
859 * in mtd_writeecc
860 */
861 } else {
862 INFTL_deleteblock(inftl, block);
863 }
864
865 return 0;
866 }
867
868 static int inftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
869 char *buffer)
870 {
871 struct INFTLrecord *inftl = (void *)mbd;
872 unsigned int thisEUN = inftl->VUtable[block / (inftl->EraseSize / SECTORSIZE)];
873 unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1);
874 struct mtd_info *mtd = inftl->mbd.mtd;
875 unsigned int status;
876 int silly = MAX_LOOPS;
877 struct inftl_bci bci;
878 size_t retlen;
879
880 DEBUG(MTD_DEBUG_LEVEL3, "INFTL: inftl_readblock(inftl=%p,block=%ld,"
881 "buffer=%p)\n", inftl, block, buffer);
882
883 while (thisEUN < inftl->nb_blocks) {
884 if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) +
885 blockofs, 8, &retlen, (char *)&bci) < 0)
886 status = SECTOR_IGNORE;
887 else
888 status = bci.Status | bci.Status1;
889
890 switch (status) {
891 case SECTOR_DELETED:
892 thisEUN = BLOCK_NIL;
893 goto foundit;
894 case SECTOR_USED:
895 goto foundit;
896 case SECTOR_FREE:
897 case SECTOR_IGNORE:
898 break;
899 default:
900 printk(KERN_WARNING "INFTL: unknown status for "
901 "block %ld in EUN %d: 0x%04x\n",
902 block, thisEUN, status);
903 break;
904 }
905
906 if (!silly--) {
907 printk(KERN_WARNING "INFTL: infinite loop in "
908 "Virtual Unit Chain 0x%lx\n",
909 block / (inftl->EraseSize / SECTORSIZE));
910 return 1;
911 }
912
913 thisEUN = inftl->PUtable[thisEUN];
914 }
915
916 foundit:
917 if (thisEUN == BLOCK_NIL) {
918 /* The requested block is not on the media, return all 0x00 */
919 memset(buffer, 0, SECTORSIZE);
920 } else {
921 size_t retlen;
922 loff_t ptr = (thisEUN * inftl->EraseSize) + blockofs;
923 int ret = mtd->read(mtd, ptr, SECTORSIZE, &retlen, buffer);
924
925 /* Handle corrected bit flips gracefully */
926 if (ret < 0 && ret != -EUCLEAN)
927 return -EIO;
928 }
929 return 0;
930 }
931
932 static int inftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
933 {
934 struct INFTLrecord *inftl = (void *)dev;
935
936 geo->heads = inftl->heads;
937 geo->sectors = inftl->sectors;
938 geo->cylinders = inftl->cylinders;
939
940 return 0;
941 }
942
943 static struct mtd_blktrans_ops inftl_tr = {
944 .name = "inftl",
945 .major = INFTL_MAJOR,
946 .part_bits = INFTL_PARTN_BITS,
947 .blksize = 512,
948 .getgeo = inftl_getgeo,
949 .readsect = inftl_readblock,
950 .writesect = inftl_writeblock,
951 .add_mtd = inftl_add_mtd,
952 .remove_dev = inftl_remove_dev,
953 .owner = THIS_MODULE,
954 };
955
956 static int __init init_inftl(void)
957 {
958 return register_mtd_blktrans(&inftl_tr);
959 }
960
961 static void __exit cleanup_inftl(void)
962 {
963 deregister_mtd_blktrans(&inftl_tr);
964 }
965
966 module_init(init_inftl);
967 module_exit(cleanup_inftl);
968
969 MODULE_LICENSE("GPL");
970 MODULE_AUTHOR("Greg Ungerer <gerg@snapgear.com>, David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
971 MODULE_DESCRIPTION("Support code for Inverse Flash Translation Layer, used on M-Systems DiskOnChip 2000, Millennium and Millennium Plus");
CRIS linux kernel tree