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