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