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