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