Merge from Linus' tree.
[linux-2.6] / drivers / mtd / nftlcore.c
1 /* Linux driver for NAND Flash Translation Layer      */
2 /* (c) 1999 Machine Vision Holdings, Inc.             */
3 /* Author: David Woodhouse <dwmw2@infradead.org>      */
4 /* $Id: nftlcore.c,v 1.97 2004/11/16 18:28:59 dwmw2 Exp $ */
5
6 /*
7   The contents of this file are distributed under the GNU General
8   Public License version 2. The author places no additional
9   restrictions of any kind on it.
10  */
11
12 #define PRERELEASE
13
14 #include <linux/config.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <asm/errno.h>
18 #include <asm/io.h>
19 #include <asm/uaccess.h>
20 #include <linux/miscdevice.h>
21 #include <linux/pci.h>
22 #include <linux/delay.h>
23 #include <linux/slab.h>
24 #include <linux/sched.h>
25 #include <linux/init.h>
26 #include <linux/hdreg.h>
27
28 #include <linux/kmod.h>
29 #include <linux/mtd/mtd.h>
30 #include <linux/mtd/nand.h>
31 #include <linux/mtd/nftl.h>
32 #include <linux/mtd/blktrans.h>
33
34 /* maximum number of loops while examining next block, to have a
35    chance to detect consistency problems (they should never happen
36    because of the checks done in the mounting */
37
38 #define MAX_LOOPS 10000
39
40
41 static void nftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
42 {
43         struct NFTLrecord *nftl;
44         unsigned long temp;
45
46         if (mtd->type != MTD_NANDFLASH)
47                 return;
48         /* OK, this is moderately ugly.  But probably safe.  Alternatives? */
49         if (memcmp(mtd->name, "DiskOnChip", 10))
50                 return;
51
52         if (!mtd->block_isbad) {
53                 printk(KERN_ERR
54 "NFTL no longer supports the old DiskOnChip drivers loaded via docprobe.\n"
55 "Please use the new diskonchip driver under the NAND subsystem.\n");
56                 return;
57         }
58
59         DEBUG(MTD_DEBUG_LEVEL1, "NFTL: add_mtd for %s\n", mtd->name);
60
61         nftl = kmalloc(sizeof(struct NFTLrecord), GFP_KERNEL);
62
63         if (!nftl) {
64                 printk(KERN_WARNING "NFTL: out of memory for data structures\n");
65                 return;
66         }
67         memset(nftl, 0, sizeof(*nftl));
68
69         nftl->mbd.mtd = mtd;
70         nftl->mbd.devnum = -1;
71         nftl->mbd.blksize = 512;
72         nftl->mbd.tr = tr;
73         memcpy(&nftl->oobinfo, &mtd->oobinfo, sizeof(struct nand_oobinfo));
74         nftl->oobinfo.useecc = MTD_NANDECC_PLACEONLY;
75
76         if (NFTL_mount(nftl) < 0) {
77                 printk(KERN_WARNING "NFTL: could not mount device\n");
78                 kfree(nftl);
79                 return;
80         }
81
82         /* OK, it's a new one. Set up all the data structures. */
83
84         /* Calculate geometry */
85         nftl->cylinders = 1024;
86         nftl->heads = 16;
87
88         temp = nftl->cylinders * nftl->heads;
89         nftl->sectors = nftl->mbd.size / temp;
90         if (nftl->mbd.size % temp) {
91                 nftl->sectors++;
92                 temp = nftl->cylinders * nftl->sectors;
93                 nftl->heads = nftl->mbd.size / temp;
94
95                 if (nftl->mbd.size % temp) {
96                         nftl->heads++;
97                         temp = nftl->heads * nftl->sectors;
98                         nftl->cylinders = nftl->mbd.size / temp;
99                 }
100         }
101
102         if (nftl->mbd.size != nftl->heads * nftl->cylinders * nftl->sectors) {
103                 /*
104                   Oh no we don't have 
105                    mbd.size == heads * cylinders * sectors
106                 */
107                 printk(KERN_WARNING "NFTL: cannot calculate a geometry to "
108                        "match size of 0x%lx.\n", nftl->mbd.size);
109                 printk(KERN_WARNING "NFTL: using C:%d H:%d S:%d "
110                         "(== 0x%lx sects)\n",
111                         nftl->cylinders, nftl->heads , nftl->sectors, 
112                         (long)nftl->cylinders * (long)nftl->heads *
113                         (long)nftl->sectors );
114         }
115
116         if (add_mtd_blktrans_dev(&nftl->mbd)) {
117                 if (nftl->ReplUnitTable)
118                         kfree(nftl->ReplUnitTable);
119                 if (nftl->EUNtable)
120                         kfree(nftl->EUNtable);
121                 kfree(nftl);
122                 return;
123         }
124 #ifdef PSYCHO_DEBUG
125         printk(KERN_INFO "NFTL: Found new nftl%c\n", nftl->mbd.devnum + 'a');
126 #endif
127 }
128
129 static void nftl_remove_dev(struct mtd_blktrans_dev *dev)
130 {
131         struct NFTLrecord *nftl = (void *)dev;
132
133         DEBUG(MTD_DEBUG_LEVEL1, "NFTL: remove_dev (i=%d)\n", dev->devnum);
134
135         del_mtd_blktrans_dev(dev);
136         if (nftl->ReplUnitTable)
137                 kfree(nftl->ReplUnitTable);
138         if (nftl->EUNtable)
139                 kfree(nftl->EUNtable);
140         kfree(nftl);
141 }
142
143 #ifdef CONFIG_NFTL_RW
144
145 /* Actual NFTL access routines */
146 /* NFTL_findfreeblock: Find a free Erase Unit on the NFTL partition. This function is used
147  *      when the give Virtual Unit Chain
148  */
149 static u16 NFTL_findfreeblock(struct NFTLrecord *nftl, int desperate )
150 {
151         /* For a given Virtual Unit Chain: find or create a free block and
152            add it to the chain */
153         /* We're passed the number of the last EUN in the chain, to save us from
154            having to look it up again */
155         u16 pot = nftl->LastFreeEUN;
156         int silly = nftl->nb_blocks;
157
158         /* Normally, we force a fold to happen before we run out of free blocks completely */
159         if (!desperate && nftl->numfreeEUNs < 2) {
160                 DEBUG(MTD_DEBUG_LEVEL1, "NFTL_findfreeblock: there are too few free EUNs\n");
161                 return 0xffff;
162         }
163
164         /* Scan for a free block */
165         do {
166                 if (nftl->ReplUnitTable[pot] == BLOCK_FREE) {
167                         nftl->LastFreeEUN = pot;
168                         nftl->numfreeEUNs--;
169                         return pot;
170                 }
171
172                 /* This will probably point to the MediaHdr unit itself,
173                    right at the beginning of the partition. But that unit
174                    (and the backup unit too) should have the UCI set
175                    up so that it's not selected for overwriting */
176                 if (++pot > nftl->lastEUN)
177                         pot = le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN);
178
179                 if (!silly--) {
180                         printk("Argh! No free blocks found! LastFreeEUN = %d, "
181                                "FirstEUN = %d\n", nftl->LastFreeEUN, 
182                                le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN));
183                         return 0xffff;
184                 }
185         } while (pot != nftl->LastFreeEUN);
186
187         return 0xffff;
188 }
189
190 static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned pendingblock )
191 {
192         u16 BlockMap[MAX_SECTORS_PER_UNIT];
193         unsigned char BlockLastState[MAX_SECTORS_PER_UNIT];
194         unsigned char BlockFreeFound[MAX_SECTORS_PER_UNIT];
195         unsigned int thisEUN;
196         int block;
197         int silly;
198         unsigned int targetEUN;
199         struct nftl_oob oob;
200         int inplace = 1;
201         size_t retlen;
202
203         memset(BlockMap, 0xff, sizeof(BlockMap));
204         memset(BlockFreeFound, 0, sizeof(BlockFreeFound));
205
206         thisEUN = nftl->EUNtable[thisVUC];
207
208         if (thisEUN == BLOCK_NIL) {
209                 printk(KERN_WARNING "Trying to fold non-existent "
210                        "Virtual Unit Chain %d!\n", thisVUC);
211                 return BLOCK_NIL;
212         }
213         
214         /* Scan to find the Erase Unit which holds the actual data for each
215            512-byte block within the Chain.
216         */
217         silly = MAX_LOOPS;
218         targetEUN = BLOCK_NIL;
219         while (thisEUN <= nftl->lastEUN ) {
220                 unsigned int status, foldmark;
221
222                 targetEUN = thisEUN;
223                 for (block = 0; block < nftl->EraseSize / 512; block ++) {
224                         MTD_READOOB(nftl->mbd.mtd,
225                                     (thisEUN * nftl->EraseSize) + (block * 512),
226                                     16 , &retlen, (char *)&oob);
227                         if (block == 2) {
228                                 foldmark = oob.u.c.FoldMark | oob.u.c.FoldMark1;
229                                 if (foldmark == FOLD_MARK_IN_PROGRESS) {
230                                         DEBUG(MTD_DEBUG_LEVEL1, 
231                                               "Write Inhibited on EUN %d\n", thisEUN);
232                                         inplace = 0;
233                                 } else {
234                                         /* There's no other reason not to do inplace,
235                                            except ones that come later. So we don't need
236                                            to preserve inplace */
237                                         inplace = 1;
238                                 }
239                         }
240                         status = oob.b.Status | oob.b.Status1;
241                         BlockLastState[block] = status;
242
243                         switch(status) {
244                         case SECTOR_FREE:
245                                 BlockFreeFound[block] = 1;
246                                 break;
247
248                         case SECTOR_USED:
249                                 if (!BlockFreeFound[block])
250                                         BlockMap[block] = thisEUN;
251                                 else
252                                         printk(KERN_WARNING 
253                                                "SECTOR_USED found after SECTOR_FREE "
254                                                "in Virtual Unit Chain %d for block %d\n",
255                                                thisVUC, block);
256                                 break;
257                         case SECTOR_DELETED:
258                                 if (!BlockFreeFound[block])
259                                         BlockMap[block] = BLOCK_NIL;
260                                 else
261                                         printk(KERN_WARNING 
262                                                "SECTOR_DELETED found after SECTOR_FREE "
263                                                "in Virtual Unit Chain %d for block %d\n",
264                                                thisVUC, block);
265                                 break;
266
267                         case SECTOR_IGNORE:
268                                 break;
269                         default:
270                                 printk("Unknown status for block %d in EUN %d: %x\n",
271                                        block, thisEUN, status);
272                         }
273                 }
274
275                 if (!silly--) {
276                         printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%x\n",
277                                thisVUC);
278                         return BLOCK_NIL;
279                 }
280                 
281                 thisEUN = nftl->ReplUnitTable[thisEUN];
282         }
283
284         if (inplace) {
285                 /* We're being asked to be a fold-in-place. Check
286                    that all blocks which actually have data associated
287                    with them (i.e. BlockMap[block] != BLOCK_NIL) are 
288                    either already present or SECTOR_FREE in the target
289                    block. If not, we're going to have to fold out-of-place
290                    anyway.
291                 */
292                 for (block = 0; block < nftl->EraseSize / 512 ; block++) {
293                         if (BlockLastState[block] != SECTOR_FREE &&
294                             BlockMap[block] != BLOCK_NIL &&
295                             BlockMap[block] != targetEUN) {
296                                 DEBUG(MTD_DEBUG_LEVEL1, "Setting inplace to 0. VUC %d, "
297                                       "block %d was %x lastEUN, "
298                                       "and is in EUN %d (%s) %d\n",
299                                       thisVUC, block, BlockLastState[block],
300                                       BlockMap[block], 
301                                       BlockMap[block]== targetEUN ? "==" : "!=",
302                                       targetEUN);
303                                 inplace = 0;
304                                 break;
305                         }
306                 }
307
308                 if (pendingblock >= (thisVUC * (nftl->EraseSize / 512)) &&
309                     pendingblock < ((thisVUC + 1)* (nftl->EraseSize / 512)) &&
310                     BlockLastState[pendingblock - (thisVUC * (nftl->EraseSize / 512))] !=
311                     SECTOR_FREE) {
312                         DEBUG(MTD_DEBUG_LEVEL1, "Pending write not free in EUN %d. "
313                               "Folding out of place.\n", targetEUN);
314                         inplace = 0;
315                 }
316         }
317         
318         if (!inplace) {
319                 DEBUG(MTD_DEBUG_LEVEL1, "Cannot fold Virtual Unit Chain %d in place. "
320                       "Trying out-of-place\n", thisVUC);
321                 /* We need to find a targetEUN to fold into. */
322                 targetEUN = NFTL_findfreeblock(nftl, 1);
323                 if (targetEUN == BLOCK_NIL) {
324                         /* Ouch. Now we're screwed. We need to do a 
325                            fold-in-place of another chain to make room
326                            for this one. We need a better way of selecting
327                            which chain to fold, because makefreeblock will 
328                            only ask us to fold the same one again.
329                         */
330                         printk(KERN_WARNING
331                                "NFTL_findfreeblock(desperate) returns 0xffff.\n");
332                         return BLOCK_NIL;
333                 }
334         } else {
335             /* We put a fold mark in the chain we are folding only if
336                we fold in place to help the mount check code. If we do
337                not fold in place, it is possible to find the valid
338                chain by selecting the longer one */
339             oob.u.c.FoldMark = oob.u.c.FoldMark1 = cpu_to_le16(FOLD_MARK_IN_PROGRESS);
340             oob.u.c.unused = 0xffffffff;
341             MTD_WRITEOOB(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) + 2 * 512 + 8, 
342                          8, &retlen, (char *)&oob.u);
343         }
344
345         /* OK. We now know the location of every block in the Virtual Unit Chain,
346            and the Erase Unit into which we are supposed to be copying.
347            Go for it.
348         */
349         DEBUG(MTD_DEBUG_LEVEL1,"Folding chain %d into unit %d\n", thisVUC, targetEUN);
350         for (block = 0; block < nftl->EraseSize / 512 ; block++) {
351                 unsigned char movebuf[512];
352                 int ret;
353
354                 /* If it's in the target EUN already, or if it's pending write, do nothing */
355                 if (BlockMap[block] == targetEUN ||
356                     (pendingblock == (thisVUC * (nftl->EraseSize / 512) + block))) {
357                         continue;
358                 }
359
360                 /* copy only in non free block (free blocks can only
361                    happen in case of media errors or deleted blocks) */
362                 if (BlockMap[block] == BLOCK_NIL)
363                         continue;
364                 
365                 ret = MTD_READ(nftl->mbd.mtd, (nftl->EraseSize * BlockMap[block]) + (block * 512),
366                                   512, &retlen, movebuf); 
367                 if (ret < 0) {
368                     ret = MTD_READ(nftl->mbd.mtd, (nftl->EraseSize * BlockMap[block])
369                                       + (block * 512), 512, &retlen,
370                                       movebuf); 
371                     if (ret != -EIO) 
372                         printk("Error went away on retry.\n");
373                 }
374                 memset(&oob, 0xff, sizeof(struct nftl_oob));
375                 oob.b.Status = oob.b.Status1 = SECTOR_USED;
376                 MTD_WRITEECC(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) + (block * 512),
377                              512, &retlen, movebuf, (char *)&oob, &nftl->oobinfo);
378         }
379         
380         /* add the header so that it is now a valid chain */
381         oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum
382                 = cpu_to_le16(thisVUC);
383         oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = 0xffff;
384         
385         MTD_WRITEOOB(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) + 8, 
386                      8, &retlen, (char *)&oob.u);
387
388         /* OK. We've moved the whole lot into the new block. Now we have to free the original blocks. */
389
390         /* At this point, we have two different chains for this Virtual Unit, and no way to tell 
391            them apart. If we crash now, we get confused. However, both contain the same data, so we
392            shouldn't actually lose data in this case. It's just that when we load up on a medium which
393            has duplicate chains, we need to free one of the chains because it's not necessary any more.
394         */
395         thisEUN = nftl->EUNtable[thisVUC];
396         DEBUG(MTD_DEBUG_LEVEL1,"Want to erase\n");
397
398         /* For each block in the old chain (except the targetEUN of course), 
399            free it and make it available for future use */
400         while (thisEUN <= nftl->lastEUN && thisEUN != targetEUN) {
401                 unsigned int EUNtmp;
402
403                 EUNtmp = nftl->ReplUnitTable[thisEUN];
404
405                 if (NFTL_formatblock(nftl, thisEUN) < 0) {
406                         /* could not erase : mark block as reserved
407                          */
408                         nftl->ReplUnitTable[thisEUN] = BLOCK_RESERVED;
409                 } else {
410                         /* correctly erased : mark it as free */
411                         nftl->ReplUnitTable[thisEUN] = BLOCK_FREE;
412                         nftl->numfreeEUNs++;
413                 }
414                 thisEUN = EUNtmp;
415         }
416         
417         /* Make this the new start of chain for thisVUC */
418         nftl->ReplUnitTable[targetEUN] = BLOCK_NIL;
419         nftl->EUNtable[thisVUC] = targetEUN;
420
421         return targetEUN;
422 }
423
424 static u16 NFTL_makefreeblock( struct NFTLrecord *nftl , unsigned pendingblock)
425 {
426         /* This is the part that needs some cleverness applied. 
427            For now, I'm doing the minimum applicable to actually
428            get the thing to work.
429            Wear-levelling and other clever stuff needs to be implemented
430            and we also need to do some assessment of the results when
431            the system loses power half-way through the routine.
432         */
433         u16 LongestChain = 0;
434         u16 ChainLength = 0, thislen;
435         u16 chain, EUN;
436
437         for (chain = 0; chain < le32_to_cpu(nftl->MediaHdr.FormattedSize) / nftl->EraseSize; chain++) {
438                 EUN = nftl->EUNtable[chain];
439                 thislen = 0;
440
441                 while (EUN <= nftl->lastEUN) {
442                         thislen++;
443                         //printk("VUC %d reaches len %d with EUN %d\n", chain, thislen, EUN);
444                         EUN = nftl->ReplUnitTable[EUN] & 0x7fff;
445                         if (thislen > 0xff00) {
446                                 printk("Endless loop in Virtual Chain %d: Unit %x\n",
447                                        chain, EUN);
448                         }
449                         if (thislen > 0xff10) {
450                                 /* Actually, don't return failure. Just ignore this chain and
451                                    get on with it. */
452                                 thislen = 0;
453                                 break;
454                         }
455                 }
456
457                 if (thislen > ChainLength) {
458                         //printk("New longest chain is %d with length %d\n", chain, thislen);
459                         ChainLength = thislen;
460                         LongestChain = chain;
461                 }
462         }
463
464         if (ChainLength < 2) {
465                 printk(KERN_WARNING "No Virtual Unit Chains available for folding. "
466                        "Failing request\n");
467                 return 0xffff;
468         }
469
470         return NFTL_foldchain (nftl, LongestChain, pendingblock);
471 }
472
473 /* NFTL_findwriteunit: Return the unit number into which we can write 
474                        for this block. Make it available if it isn't already
475 */
476 static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
477 {
478         u16 lastEUN;
479         u16 thisVUC = block / (nftl->EraseSize / 512);
480         unsigned int writeEUN;
481         unsigned long blockofs = (block * 512) & (nftl->EraseSize -1);
482         size_t retlen;
483         int silly, silly2 = 3;
484         struct nftl_oob oob;
485
486         do {
487                 /* Scan the media to find a unit in the VUC which has
488                    a free space for the block in question.
489                 */
490
491                 /* This condition catches the 0x[7f]fff cases, as well as 
492                    being a sanity check for past-end-of-media access
493                 */
494                 lastEUN = BLOCK_NIL;
495                 writeEUN = nftl->EUNtable[thisVUC];
496                 silly = MAX_LOOPS;
497                 while (writeEUN <= nftl->lastEUN) {
498                         struct nftl_bci bci;
499                         size_t retlen;
500                         unsigned int status;
501
502                         lastEUN = writeEUN;
503
504                         MTD_READOOB(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs,
505                                     8, &retlen, (char *)&bci);
506                         
507                         DEBUG(MTD_DEBUG_LEVEL2, "Status of block %d in EUN %d is %x\n",
508                               block , writeEUN, le16_to_cpu(bci.Status));
509
510                         status = bci.Status | bci.Status1;
511                         switch(status) {
512                         case SECTOR_FREE:
513                                 return writeEUN;
514
515                         case SECTOR_DELETED:
516                         case SECTOR_USED:
517                         case SECTOR_IGNORE:
518                                 break;
519                         default:
520                                 // Invalid block. Don't use it any more. Must implement.
521                                 break;                  
522                         }
523                         
524                         if (!silly--) { 
525                                 printk(KERN_WARNING
526                                        "Infinite loop in Virtual Unit Chain 0x%x\n",
527                                        thisVUC);
528                                 return 0xffff;
529                         }
530
531                         /* Skip to next block in chain */
532                         writeEUN = nftl->ReplUnitTable[writeEUN];
533                 }
534
535                 /* OK. We didn't find one in the existing chain, or there 
536                    is no existing chain. */
537
538                 /* Try to find an already-free block */
539                 writeEUN = NFTL_findfreeblock(nftl, 0);
540
541                 if (writeEUN == BLOCK_NIL) {
542                         /* That didn't work - there were no free blocks just
543                            waiting to be picked up. We're going to have to fold
544                            a chain to make room.
545                         */
546
547                         /* First remember the start of this chain */
548                         //u16 startEUN = nftl->EUNtable[thisVUC];
549                         
550                         //printk("Write to VirtualUnitChain %d, calling makefreeblock()\n", thisVUC);
551                         writeEUN = NFTL_makefreeblock(nftl, 0xffff);
552
553                         if (writeEUN == BLOCK_NIL) {
554                                 /* OK, we accept that the above comment is 
555                                    lying - there may have been free blocks
556                                    last time we called NFTL_findfreeblock(),
557                                    but they are reserved for when we're
558                                    desperate. Well, now we're desperate.
559                                 */
560                                 DEBUG(MTD_DEBUG_LEVEL1, "Using desperate==1 to find free EUN to accommodate write to VUC %d\n", thisVUC);
561                                 writeEUN = NFTL_findfreeblock(nftl, 1);
562                         }
563                         if (writeEUN == BLOCK_NIL) {
564                                 /* Ouch. This should never happen - we should
565                                    always be able to make some room somehow. 
566                                    If we get here, we've allocated more storage 
567                                    space than actual media, or our makefreeblock
568                                    routine is missing something.
569                                 */
570                                 printk(KERN_WARNING "Cannot make free space.\n");
571                                 return BLOCK_NIL;
572                         }                       
573                         //printk("Restarting scan\n");
574                         lastEUN = BLOCK_NIL;
575                         continue;
576                 }
577
578                 /* We've found a free block. Insert it into the chain. */
579                 
580                 if (lastEUN != BLOCK_NIL) {
581                     thisVUC |= 0x8000; /* It's a replacement block */
582                 } else {
583                     /* The first block in a new chain */
584                     nftl->EUNtable[thisVUC] = writeEUN;
585                 }
586
587                 /* set up the actual EUN we're writing into */
588                 /* Both in our cache... */
589                 nftl->ReplUnitTable[writeEUN] = BLOCK_NIL;
590
591                 /* ... and on the flash itself */
592                 MTD_READOOB(nftl->mbd.mtd, writeEUN * nftl->EraseSize + 8, 8,
593                             &retlen, (char *)&oob.u);
594
595                 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
596
597                 MTD_WRITEOOB(nftl->mbd.mtd, writeEUN * nftl->EraseSize + 8, 8,
598                              &retlen, (char *)&oob.u);
599
600                 /* we link the new block to the chain only after the
601                    block is ready. It avoids the case where the chain
602                    could point to a free block */
603                 if (lastEUN != BLOCK_NIL) {
604                         /* Both in our cache... */
605                         nftl->ReplUnitTable[lastEUN] = writeEUN;
606                         /* ... and on the flash itself */
607                         MTD_READOOB(nftl->mbd.mtd, (lastEUN * nftl->EraseSize) + 8,
608                                     8, &retlen, (char *)&oob.u);
609
610                         oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum
611                                 = cpu_to_le16(writeEUN);
612
613                         MTD_WRITEOOB(nftl->mbd.mtd, (lastEUN * nftl->EraseSize) + 8,
614                                      8, &retlen, (char *)&oob.u);
615                 }
616
617                 return writeEUN;
618
619         } while (silly2--);
620
621         printk(KERN_WARNING "Error folding to make room for Virtual Unit Chain 0x%x\n",
622                thisVUC);
623         return 0xffff;
624 }
625
626 static int nftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block,
627                            char *buffer)
628 {
629         struct NFTLrecord *nftl = (void *)mbd;
630         u16 writeEUN;
631         unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
632         size_t retlen;
633         struct nftl_oob oob;
634
635         writeEUN = NFTL_findwriteunit(nftl, block);
636
637         if (writeEUN == BLOCK_NIL) {
638                 printk(KERN_WARNING
639                        "NFTL_writeblock(): Cannot find block to write to\n");
640                 /* If we _still_ haven't got a block to use, we're screwed */
641                 return 1;
642         }
643
644         memset(&oob, 0xff, sizeof(struct nftl_oob));
645         oob.b.Status = oob.b.Status1 = SECTOR_USED;
646         MTD_WRITEECC(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs,
647                      512, &retlen, (char *)buffer, (char *)&oob, &nftl->oobinfo);
648         /* need to write SECTOR_USED flags since they are not written in mtd_writeecc */
649
650         return 0;
651 }
652 #endif /* CONFIG_NFTL_RW */
653
654 static int nftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
655                           char *buffer)
656 {
657         struct NFTLrecord *nftl = (void *)mbd;
658         u16 lastgoodEUN;
659         u16 thisEUN = nftl->EUNtable[block / (nftl->EraseSize / 512)];
660         unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
661         unsigned int status;
662         int silly = MAX_LOOPS;
663         size_t retlen;
664         struct nftl_bci bci;
665
666         lastgoodEUN = BLOCK_NIL;
667
668         if (thisEUN != BLOCK_NIL) {
669                 while (thisEUN < nftl->nb_blocks) {
670                         if (MTD_READOOB(nftl->mbd.mtd, (thisEUN * nftl->EraseSize) + blockofs,
671                                         8, &retlen, (char *)&bci) < 0)
672                                 status = SECTOR_IGNORE;
673                         else
674                                 status = bci.Status | bci.Status1;
675
676                         switch (status) {
677                         case SECTOR_FREE:
678                                 /* no modification of a sector should follow a free sector */
679                                 goto the_end;
680                         case SECTOR_DELETED:
681                                 lastgoodEUN = BLOCK_NIL;
682                                 break;
683                         case SECTOR_USED:
684                                 lastgoodEUN = thisEUN;
685                                 break;
686                         case SECTOR_IGNORE:
687                                 break;
688                         default:
689                                 printk("Unknown status for block %ld in EUN %d: %x\n",
690                                        block, thisEUN, status);
691                                 break;
692                         }
693
694                         if (!silly--) {
695                                 printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%lx\n",
696                                        block / (nftl->EraseSize / 512));
697                                 return 1;
698                         }
699                         thisEUN = nftl->ReplUnitTable[thisEUN];
700                 }
701         }
702
703  the_end:
704         if (lastgoodEUN == BLOCK_NIL) {
705                 /* the requested block is not on the media, return all 0x00 */
706                 memset(buffer, 0, 512);
707         } else {
708                 loff_t ptr = (lastgoodEUN * nftl->EraseSize) + blockofs;
709                 size_t retlen;
710                 if (MTD_READ(nftl->mbd.mtd, ptr, 512, &retlen, buffer))
711                         return -EIO;
712         }
713         return 0;
714 }
715
716 static int nftl_getgeo(struct mtd_blktrans_dev *dev,  struct hd_geometry *geo)
717 {
718         struct NFTLrecord *nftl = (void *)dev;
719
720         geo->heads = nftl->heads;
721         geo->sectors = nftl->sectors;
722         geo->cylinders = nftl->cylinders;
723
724         return 0;
725 }
726
727 /****************************************************************************
728  *
729  * Module stuff
730  *
731  ****************************************************************************/
732
733
734 static struct mtd_blktrans_ops nftl_tr = {
735         .name           = "nftl",
736         .major          = NFTL_MAJOR,
737         .part_bits      = NFTL_PARTN_BITS,
738         .getgeo         = nftl_getgeo,
739         .readsect       = nftl_readblock,
740 #ifdef CONFIG_NFTL_RW
741         .writesect      = nftl_writeblock,
742 #endif
743         .add_mtd        = nftl_add_mtd,
744         .remove_dev     = nftl_remove_dev,
745         .owner          = THIS_MODULE,
746 };
747
748 extern char nftlmountrev[];
749
750 static int __init init_nftl(void)
751 {
752         printk(KERN_INFO "NFTL driver: nftlcore.c $Revision: 1.97 $, nftlmount.c %s\n", nftlmountrev);
753
754         return register_mtd_blktrans(&nftl_tr);
755 }
756
757 static void __exit cleanup_nftl(void)
758 {
759         deregister_mtd_blktrans(&nftl_tr);
760 }
761
762 module_init(init_nftl);
763 module_exit(cleanup_nftl);
764
765 MODULE_LICENSE("GPL");
766 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
767 MODULE_DESCRIPTION("Support code for NAND Flash Translation Layer, used on M-Systems DiskOnChip 2000 and Millennium");