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