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