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