2 * inftlcore.c -- Linux driver for Inverse Flash Translation Layer (INFTL)
4 * (C) Copyright 2002, Greg Ungerer (gerg@snapgear.com)
6 * Based heavily on the nftlcore.c code which is:
7 * (c) 1999 Machine Vision Holdings, Inc.
8 * Author: David Woodhouse <dwmw2@infradead.org>
10 * $Id: inftlcore.c,v 1.19 2005/11/07 11:14:20 gleixner Exp $
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include <linux/config.h>
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/delay.h>
31 #include <linux/slab.h>
32 #include <linux/sched.h>
33 #include <linux/init.h>
34 #include <linux/kmod.h>
35 #include <linux/hdreg.h>
36 #include <linux/mtd/mtd.h>
37 #include <linux/mtd/nftl.h>
38 #include <linux/mtd/inftl.h>
39 #include <linux/mtd/nand.h>
40 #include <asm/uaccess.h>
41 #include <asm/errno.h>
45 * Maximum number of loops while examining next block, to have a
46 * chance to detect consistency problems (they should never happen
47 * because of the checks done in the mounting.
49 #define MAX_LOOPS 10000
51 static void inftl_add_mtd(struct mtd_blktrans_ops
*tr
, struct mtd_info
*mtd
)
53 struct INFTLrecord
*inftl
;
56 if (mtd
->type
!= MTD_NANDFLASH
)
58 /* OK, this is moderately ugly. But probably safe. Alternatives? */
59 if (memcmp(mtd
->name
, "DiskOnChip", 10))
62 if (!mtd
->block_isbad
) {
64 "INFTL no longer supports the old DiskOnChip drivers loaded via docprobe.\n"
65 "Please use the new diskonchip driver under the NAND subsystem.\n");
69 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: add_mtd for %s\n", mtd
->name
);
71 inftl
= kmalloc(sizeof(*inftl
), GFP_KERNEL
);
74 printk(KERN_WARNING
"INFTL: Out of memory for data structures\n");
77 memset(inftl
, 0, sizeof(*inftl
));
80 inftl
->mbd
.devnum
= -1;
81 inftl
->mbd
.blksize
= 512;
84 if (INFTL_mount(inftl
) < 0) {
85 printk(KERN_WARNING
"INFTL: could not mount device\n");
90 /* OK, it's a new one. Set up all the data structures. */
92 /* Calculate geometry */
93 inftl
->cylinders
= 1024;
96 temp
= inftl
->cylinders
* inftl
->heads
;
97 inftl
->sectors
= inftl
->mbd
.size
/ temp
;
98 if (inftl
->mbd
.size
% temp
) {
100 temp
= inftl
->cylinders
* inftl
->sectors
;
101 inftl
->heads
= inftl
->mbd
.size
/ temp
;
103 if (inftl
->mbd
.size
% temp
) {
105 temp
= inftl
->heads
* inftl
->sectors
;
106 inftl
->cylinders
= inftl
->mbd
.size
/ temp
;
110 if (inftl
->mbd
.size
!= inftl
->heads
* inftl
->cylinders
* inftl
->sectors
) {
113 mbd.size == heads * cylinders * sectors
115 printk(KERN_WARNING
"INFTL: cannot calculate a geometry to "
116 "match size of 0x%lx.\n", inftl
->mbd
.size
);
117 printk(KERN_WARNING
"INFTL: using C:%d H:%d S:%d "
118 "(== 0x%lx sects)\n",
119 inftl
->cylinders
, inftl
->heads
, inftl
->sectors
,
120 (long)inftl
->cylinders
* (long)inftl
->heads
*
121 (long)inftl
->sectors
);
124 if (add_mtd_blktrans_dev(&inftl
->mbd
)) {
125 kfree(inftl
->PUtable
);
126 kfree(inftl
->VUtable
);
131 printk(KERN_INFO
"INFTL: Found new inftl%c\n", inftl
->mbd
.devnum
+ 'a');
136 static void inftl_remove_dev(struct mtd_blktrans_dev
*dev
)
138 struct INFTLrecord
*inftl
= (void *)dev
;
140 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: remove_dev (i=%d)\n", dev
->devnum
);
142 del_mtd_blktrans_dev(dev
);
144 kfree(inftl
->PUtable
);
145 kfree(inftl
->VUtable
);
150 * Actual INFTL access routines.
154 * Read oob data from flash
156 int inftl_read_oob(struct mtd_info
*mtd
, loff_t offs
, size_t len
,
157 size_t *retlen
, uint8_t *buf
)
159 struct mtd_oob_ops ops
;
162 ops
.mode
= MTD_OOB_PLACE
;
163 ops
.ooboffs
= offs
& (mtd
->writesize
- 1);
169 res
= mtd
->read_oob(mtd
, offs
& ~(mtd
->writesize
- 1), &ops
);
170 *retlen
= ops
.retlen
;
175 * Write oob data to flash
177 int inftl_write_oob(struct mtd_info
*mtd
, loff_t offs
, size_t len
,
178 size_t *retlen
, uint8_t *buf
)
180 struct mtd_oob_ops ops
;
183 ops
.mode
= MTD_OOB_PLACE
;
184 ops
.ooboffs
= offs
& (mtd
->writesize
- 1);
190 res
= mtd
->write_oob(mtd
, offs
& ~(mtd
->writesize
- 1), &ops
);
191 *retlen
= ops
.retlen
;
196 * Write data and oob to flash
198 static int inftl_write(struct mtd_info
*mtd
, loff_t offs
, size_t len
,
199 size_t *retlen
, uint8_t *buf
, uint8_t *oob
)
201 struct mtd_oob_ops ops
;
204 ops
.mode
= MTD_OOB_PLACE
;
206 ops
.ooblen
= mtd
->oobsize
;
211 res
= mtd
->write_oob(mtd
, offs
& ~(mtd
->writesize
- 1), &ops
);
212 *retlen
= ops
.retlen
;
217 * INFTL_findfreeblock: Find a free Erase Unit on the INFTL partition.
218 * This function is used when the give Virtual Unit Chain.
220 static u16
INFTL_findfreeblock(struct INFTLrecord
*inftl
, int desperate
)
222 u16 pot
= inftl
->LastFreeEUN
;
223 int silly
= inftl
->nb_blocks
;
225 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: INFTL_findfreeblock(inftl=%p,"
226 "desperate=%d)\n", inftl
, desperate
);
229 * Normally, we force a fold to happen before we run out of free
232 if (!desperate
&& inftl
->numfreeEUNs
< 2) {
233 DEBUG(MTD_DEBUG_LEVEL1
, "INFTL: there are too few free "
234 "EUNs (%d)\n", inftl
->numfreeEUNs
);
238 /* Scan for a free block */
240 if (inftl
->PUtable
[pot
] == BLOCK_FREE
) {
241 inftl
->LastFreeEUN
= pot
;
245 if (++pot
> inftl
->lastEUN
)
249 printk(KERN_WARNING
"INFTL: no free blocks found! "
250 "EUN range = %d - %d\n", 0, inftl
->LastFreeEUN
);
253 } while (pot
!= inftl
->LastFreeEUN
);
258 static u16
INFTL_foldchain(struct INFTLrecord
*inftl
, unsigned thisVUC
, unsigned pendingblock
)
260 u16 BlockMap
[MAX_SECTORS_PER_UNIT
];
261 unsigned char BlockDeleted
[MAX_SECTORS_PER_UNIT
];
262 unsigned int thisEUN
, prevEUN
, status
;
263 struct mtd_info
*mtd
= inftl
->mbd
.mtd
;
265 unsigned int targetEUN
;
266 struct inftl_oob oob
;
269 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: INFTL_foldchain(inftl=%p,thisVUC=%d,"
270 "pending=%d)\n", inftl
, thisVUC
, pendingblock
);
272 memset(BlockMap
, 0xff, sizeof(BlockMap
));
273 memset(BlockDeleted
, 0, sizeof(BlockDeleted
));
275 thisEUN
= targetEUN
= inftl
->VUtable
[thisVUC
];
277 if (thisEUN
== BLOCK_NIL
) {
278 printk(KERN_WARNING
"INFTL: trying to fold non-existent "
279 "Virtual Unit Chain %d!\n", thisVUC
);
284 * Scan to find the Erase Unit which holds the actual data for each
285 * 512-byte block within the Chain.
288 while (thisEUN
< inftl
->nb_blocks
) {
289 for (block
= 0; block
< inftl
->EraseSize
/SECTORSIZE
; block
++) {
290 if ((BlockMap
[block
] != 0xffff) || BlockDeleted
[block
])
293 if (inftl_read_oob(mtd
, (thisEUN
* inftl
->EraseSize
)
294 + (block
* SECTORSIZE
), 16, &retlen
,
296 status
= SECTOR_IGNORE
;
298 status
= oob
.b
.Status
| oob
.b
.Status1
;
305 BlockMap
[block
] = thisEUN
;
308 BlockDeleted
[block
] = 1;
311 printk(KERN_WARNING
"INFTL: unknown status "
312 "for block %d in EUN %d: %x\n",
313 block
, thisEUN
, status
);
319 printk(KERN_WARNING
"INFTL: infinite loop in Virtual "
320 "Unit Chain 0x%x\n", thisVUC
);
324 thisEUN
= inftl
->PUtable
[thisEUN
];
328 * OK. We now know the location of every block in the Virtual Unit
329 * Chain, and the Erase Unit into which we are supposed to be copying.
332 DEBUG(MTD_DEBUG_LEVEL1
, "INFTL: folding chain %d into unit %d\n",
335 for (block
= 0; block
< inftl
->EraseSize
/SECTORSIZE
; block
++) {
336 unsigned char movebuf
[SECTORSIZE
];
340 * If it's in the target EUN already, or if it's pending write,
343 if (BlockMap
[block
] == targetEUN
|| (pendingblock
==
344 (thisVUC
* (inftl
->EraseSize
/ SECTORSIZE
) + block
))) {
349 * Copy only in non free block (free blocks can only
350 * happen in case of media errors or deleted blocks).
352 if (BlockMap
[block
] == BLOCK_NIL
)
355 ret
= mtd
->read(mtd
, (inftl
->EraseSize
* BlockMap
[block
]) +
356 (block
* SECTORSIZE
), SECTORSIZE
, &retlen
,
358 if (ret
< 0 && ret
!= -EUCLEAN
) {
360 (inftl
->EraseSize
* BlockMap
[block
]) +
361 (block
* SECTORSIZE
), SECTORSIZE
,
364 DEBUG(MTD_DEBUG_LEVEL1
, "INFTL: error went "
367 memset(&oob
, 0xff, sizeof(struct inftl_oob
));
368 oob
.b
.Status
= oob
.b
.Status1
= SECTOR_USED
;
370 inftl_write(inftl
->mbd
.mtd
, (inftl
->EraseSize
* targetEUN
) +
371 (block
* SECTORSIZE
), SECTORSIZE
, &retlen
,
372 movebuf
, (char *)&oob
);
376 * Newest unit in chain now contains data from _all_ older units.
377 * So go through and erase each unit in chain, oldest first. (This
378 * is important, by doing oldest first if we crash/reboot then it
379 * it is relatively simple to clean up the mess).
381 DEBUG(MTD_DEBUG_LEVEL1
, "INFTL: want to erase virtual chain %d\n",
385 /* Find oldest unit in chain. */
386 thisEUN
= inftl
->VUtable
[thisVUC
];
388 while (inftl
->PUtable
[thisEUN
] != BLOCK_NIL
) {
390 thisEUN
= inftl
->PUtable
[thisEUN
];
393 /* Check if we are all done */
394 if (thisEUN
== targetEUN
)
397 if (INFTL_formatblock(inftl
, thisEUN
) < 0) {
399 * Could not erase : mark block as reserved.
401 inftl
->PUtable
[thisEUN
] = BLOCK_RESERVED
;
403 /* Correctly erased : mark it as free */
404 inftl
->PUtable
[thisEUN
] = BLOCK_FREE
;
405 inftl
->PUtable
[prevEUN
] = BLOCK_NIL
;
406 inftl
->numfreeEUNs
++;
413 static u16
INFTL_makefreeblock(struct INFTLrecord
*inftl
, unsigned pendingblock
)
416 * This is the part that needs some cleverness applied.
417 * For now, I'm doing the minimum applicable to actually
418 * get the thing to work.
419 * Wear-levelling and other clever stuff needs to be implemented
420 * and we also need to do some assessment of the results when
421 * the system loses power half-way through the routine.
423 u16 LongestChain
= 0;
424 u16 ChainLength
= 0, thislen
;
427 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: INFTL_makefreeblock(inftl=%p,"
428 "pending=%d)\n", inftl
, pendingblock
);
430 for (chain
= 0; chain
< inftl
->nb_blocks
; chain
++) {
431 EUN
= inftl
->VUtable
[chain
];
434 while (EUN
<= inftl
->lastEUN
) {
436 EUN
= inftl
->PUtable
[EUN
];
437 if (thislen
> 0xff00) {
438 printk(KERN_WARNING
"INFTL: endless loop in "
439 "Virtual Chain %d: Unit %x\n",
442 * Actually, don't return failure.
443 * Just ignore this chain and get on with it.
450 if (thislen
> ChainLength
) {
451 ChainLength
= thislen
;
452 LongestChain
= chain
;
456 if (ChainLength
< 2) {
457 printk(KERN_WARNING
"INFTL: no Virtual Unit Chains available "
458 "for folding. Failing request\n");
462 return INFTL_foldchain(inftl
, LongestChain
, pendingblock
);
465 static int nrbits(unsigned int val
, int bitcount
)
469 for (i
= 0; (i
< bitcount
); i
++)
470 total
+= (((0x1 << i
) & val
) ? 1 : 0);
475 * INFTL_findwriteunit: Return the unit number into which we can write
476 * for this block. Make it available if it isn't already.
478 static inline u16
INFTL_findwriteunit(struct INFTLrecord
*inftl
, unsigned block
)
480 unsigned int thisVUC
= block
/ (inftl
->EraseSize
/ SECTORSIZE
);
481 unsigned int thisEUN
, writeEUN
, prev_block
, status
;
482 unsigned long blockofs
= (block
* SECTORSIZE
) & (inftl
->EraseSize
-1);
483 struct mtd_info
*mtd
= inftl
->mbd
.mtd
;
484 struct inftl_oob oob
;
485 struct inftl_bci bci
;
486 unsigned char anac
, nacs
, parity
;
488 int silly
, silly2
= 3;
490 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: INFTL_findwriteunit(inftl=%p,"
491 "block=%d)\n", inftl
, block
);
495 * Scan the media to find a unit in the VUC which has
496 * a free space for the block in question.
498 writeEUN
= BLOCK_NIL
;
499 thisEUN
= inftl
->VUtable
[thisVUC
];
502 while (thisEUN
<= inftl
->lastEUN
) {
503 inftl_read_oob(mtd
, (thisEUN
* inftl
->EraseSize
) +
504 blockofs
, 8, &retlen
, (char *)&bci
);
506 status
= bci
.Status
| bci
.Status1
;
507 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: status of block %d in "
508 "EUN %d is %x\n", block
, writeEUN
, status
);
516 /* Can't go any further */
522 * Invalid block. Don't use it any more.
529 printk(KERN_WARNING
"INFTL: infinite loop in "
530 "Virtual Unit Chain 0x%x\n", thisVUC
);
534 /* Skip to next block in chain */
535 thisEUN
= inftl
->PUtable
[thisEUN
];
539 if (writeEUN
!= BLOCK_NIL
)
544 * OK. We didn't find one in the existing chain, or there
545 * is no existing chain. Allocate a new one.
547 writeEUN
= INFTL_findfreeblock(inftl
, 0);
549 if (writeEUN
== BLOCK_NIL
) {
551 * That didn't work - there were no free blocks just
552 * waiting to be picked up. We're going to have to fold
553 * a chain to make room.
555 thisEUN
= INFTL_makefreeblock(inftl
, 0xffff);
558 * Hopefully we free something, lets try again.
559 * This time we are desperate...
561 DEBUG(MTD_DEBUG_LEVEL1
, "INFTL: using desperate==1 "
562 "to find free EUN to accommodate write to "
563 "VUC %d\n", thisVUC
);
564 writeEUN
= INFTL_findfreeblock(inftl
, 1);
565 if (writeEUN
== BLOCK_NIL
) {
567 * Ouch. This should never happen - we should
568 * always be able to make some room somehow.
569 * If we get here, we've allocated more storage
570 * space than actual media, or our makefreeblock
571 * routine is missing something.
573 printk(KERN_WARNING
"INFTL: cannot make free "
576 INFTL_dumptables(inftl
);
577 INFTL_dumpVUchains(inftl
);
584 * Insert new block into virtual chain. Firstly update the
585 * block headers in flash...
589 thisEUN
= inftl
->VUtable
[thisVUC
];
590 if (thisEUN
!= BLOCK_NIL
) {
591 inftl_read_oob(mtd
, thisEUN
* inftl
->EraseSize
592 + 8, 8, &retlen
, (char *)&oob
.u
);
593 anac
= oob
.u
.a
.ANAC
+ 1;
594 nacs
= oob
.u
.a
.NACs
+ 1;
597 prev_block
= inftl
->VUtable
[thisVUC
];
598 if (prev_block
< inftl
->nb_blocks
)
599 prev_block
-= inftl
->firstEUN
;
601 parity
= (nrbits(thisVUC
, 16) & 0x1) ? 0x1 : 0;
602 parity
|= (nrbits(prev_block
, 16) & 0x1) ? 0x2 : 0;
603 parity
|= (nrbits(anac
, 8) & 0x1) ? 0x4 : 0;
604 parity
|= (nrbits(nacs
, 8) & 0x1) ? 0x8 : 0;
606 oob
.u
.a
.virtualUnitNo
= cpu_to_le16(thisVUC
);
607 oob
.u
.a
.prevUnitNo
= cpu_to_le16(prev_block
);
610 oob
.u
.a
.parityPerField
= parity
;
611 oob
.u
.a
.discarded
= 0xaa;
613 inftl_write_oob(mtd
, writeEUN
* inftl
->EraseSize
+ 8, 8,
614 &retlen
, (char *)&oob
.u
);
616 /* Also back up header... */
617 oob
.u
.b
.virtualUnitNo
= cpu_to_le16(thisVUC
);
618 oob
.u
.b
.prevUnitNo
= cpu_to_le16(prev_block
);
621 oob
.u
.b
.parityPerField
= parity
;
622 oob
.u
.b
.discarded
= 0xaa;
624 inftl_write_oob(mtd
, writeEUN
* inftl
->EraseSize
+
625 SECTORSIZE
* 4 + 8, 8, &retlen
, (char *)&oob
.u
);
627 inftl
->PUtable
[writeEUN
] = inftl
->VUtable
[thisVUC
];
628 inftl
->VUtable
[thisVUC
] = writeEUN
;
630 inftl
->numfreeEUNs
--;
635 printk(KERN_WARNING
"INFTL: error folding to make room for Virtual "
636 "Unit Chain 0x%x\n", thisVUC
);
641 * Given a Virtual Unit Chain, see if it can be deleted, and if so do it.
643 static void INFTL_trydeletechain(struct INFTLrecord
*inftl
, unsigned thisVUC
)
645 struct mtd_info
*mtd
= inftl
->mbd
.mtd
;
646 unsigned char BlockUsed
[MAX_SECTORS_PER_UNIT
];
647 unsigned char BlockDeleted
[MAX_SECTORS_PER_UNIT
];
648 unsigned int thisEUN
, status
;
650 struct inftl_bci bci
;
653 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: INFTL_trydeletechain(inftl=%p,"
654 "thisVUC=%d)\n", inftl
, thisVUC
);
656 memset(BlockUsed
, 0, sizeof(BlockUsed
));
657 memset(BlockDeleted
, 0, sizeof(BlockDeleted
));
659 thisEUN
= inftl
->VUtable
[thisVUC
];
660 if (thisEUN
== BLOCK_NIL
) {
661 printk(KERN_WARNING
"INFTL: trying to delete non-existent "
662 "Virtual Unit Chain %d!\n", thisVUC
);
667 * Scan through the Erase Units to determine whether any data is in
668 * each of the 512-byte blocks within the Chain.
671 while (thisEUN
< inftl
->nb_blocks
) {
672 for (block
= 0; block
< inftl
->EraseSize
/SECTORSIZE
; block
++) {
673 if (BlockUsed
[block
] || BlockDeleted
[block
])
676 if (inftl_read_oob(mtd
, (thisEUN
* inftl
->EraseSize
)
677 + (block
* SECTORSIZE
), 8 , &retlen
,
679 status
= SECTOR_IGNORE
;
681 status
= bci
.Status
| bci
.Status1
;
688 BlockUsed
[block
] = 1;
691 BlockDeleted
[block
] = 1;
694 printk(KERN_WARNING
"INFTL: unknown status "
695 "for block %d in EUN %d: 0x%x\n",
696 block
, thisEUN
, status
);
701 printk(KERN_WARNING
"INFTL: infinite loop in Virtual "
702 "Unit Chain 0x%x\n", thisVUC
);
706 thisEUN
= inftl
->PUtable
[thisEUN
];
709 for (block
= 0; block
< inftl
->EraseSize
/SECTORSIZE
; block
++)
710 if (BlockUsed
[block
])
714 * For each block in the chain free it and make it available
715 * for future use. Erase from the oldest unit first.
717 DEBUG(MTD_DEBUG_LEVEL1
, "INFTL: deleting empty VUC %d\n", thisVUC
);
720 u16
*prevEUN
= &inftl
->VUtable
[thisVUC
];
723 /* If the chain is all gone already, we're done */
724 if (thisEUN
== BLOCK_NIL
) {
725 DEBUG(MTD_DEBUG_LEVEL2
, "INFTL: Empty VUC %d for deletion was already absent\n", thisEUN
);
729 /* Find oldest unit in chain. */
730 while (inftl
->PUtable
[thisEUN
] != BLOCK_NIL
) {
731 BUG_ON(thisEUN
>= inftl
->nb_blocks
);
733 prevEUN
= &inftl
->PUtable
[thisEUN
];
737 DEBUG(MTD_DEBUG_LEVEL3
, "Deleting EUN %d from VUC %d\n",
740 if (INFTL_formatblock(inftl
, thisEUN
) < 0) {
742 * Could not erase : mark block as reserved.
744 inftl
->PUtable
[thisEUN
] = BLOCK_RESERVED
;
746 /* Correctly erased : mark it as free */
747 inftl
->PUtable
[thisEUN
] = BLOCK_FREE
;
748 inftl
->numfreeEUNs
++;
751 /* Now sort out whatever was pointing to it... */
752 *prevEUN
= BLOCK_NIL
;
754 /* Ideally we'd actually be responsive to new
755 requests while we're doing this -- if there's
756 free space why should others be made to wait? */
760 inftl
->VUtable
[thisVUC
] = BLOCK_NIL
;
763 static int INFTL_deleteblock(struct INFTLrecord
*inftl
, unsigned block
)
765 unsigned int thisEUN
= inftl
->VUtable
[block
/ (inftl
->EraseSize
/ SECTORSIZE
)];
766 unsigned long blockofs
= (block
* SECTORSIZE
) & (inftl
->EraseSize
- 1);
767 struct mtd_info
*mtd
= inftl
->mbd
.mtd
;
769 int silly
= MAX_LOOPS
;
771 struct inftl_bci bci
;
773 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: INFTL_deleteblock(inftl=%p,"
774 "block=%d)\n", inftl
, block
);
776 while (thisEUN
< inftl
->nb_blocks
) {
777 if (inftl_read_oob(mtd
, (thisEUN
* inftl
->EraseSize
) +
778 blockofs
, 8, &retlen
, (char *)&bci
) < 0)
779 status
= SECTOR_IGNORE
;
781 status
= bci
.Status
| bci
.Status1
;
793 printk(KERN_WARNING
"INFTL: unknown status for "
794 "block %d in EUN %d: 0x%x\n",
795 block
, thisEUN
, status
);
800 printk(KERN_WARNING
"INFTL: infinite loop in Virtual "
802 block
/ (inftl
->EraseSize
/ SECTORSIZE
));
805 thisEUN
= inftl
->PUtable
[thisEUN
];
809 if (thisEUN
!= BLOCK_NIL
) {
810 loff_t ptr
= (thisEUN
* inftl
->EraseSize
) + blockofs
;
812 if (inftl_read_oob(mtd
, ptr
, 8, &retlen
, (char *)&bci
) < 0)
814 bci
.Status
= bci
.Status1
= SECTOR_DELETED
;
815 if (inftl_write_oob(mtd
, ptr
, 8, &retlen
, (char *)&bci
) < 0)
817 INFTL_trydeletechain(inftl
, block
/ (inftl
->EraseSize
/ SECTORSIZE
));
822 static int inftl_writeblock(struct mtd_blktrans_dev
*mbd
, unsigned long block
,
825 struct INFTLrecord
*inftl
= (void *)mbd
;
826 unsigned int writeEUN
;
827 unsigned long blockofs
= (block
* SECTORSIZE
) & (inftl
->EraseSize
- 1);
829 struct inftl_oob oob
;
832 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: inftl_writeblock(inftl=%p,block=%ld,"
833 "buffer=%p)\n", inftl
, block
, buffer
);
835 /* Is block all zero? */
836 pend
= buffer
+ SECTORSIZE
;
837 for (p
= buffer
; p
< pend
&& !*p
; p
++)
841 writeEUN
= INFTL_findwriteunit(inftl
, block
);
843 if (writeEUN
== BLOCK_NIL
) {
844 printk(KERN_WARNING
"inftl_writeblock(): cannot find "
845 "block to write to\n");
847 * If we _still_ haven't got a block to use,
853 memset(&oob
, 0xff, sizeof(struct inftl_oob
));
854 oob
.b
.Status
= oob
.b
.Status1
= SECTOR_USED
;
856 inftl_write(inftl
->mbd
.mtd
, (writeEUN
* inftl
->EraseSize
) +
857 blockofs
, SECTORSIZE
, &retlen
, (char *)buffer
,
860 * need to write SECTOR_USED flags since they are not written
864 INFTL_deleteblock(inftl
, block
);
870 static int inftl_readblock(struct mtd_blktrans_dev
*mbd
, unsigned long block
,
873 struct INFTLrecord
*inftl
= (void *)mbd
;
874 unsigned int thisEUN
= inftl
->VUtable
[block
/ (inftl
->EraseSize
/ SECTORSIZE
)];
875 unsigned long blockofs
= (block
* SECTORSIZE
) & (inftl
->EraseSize
- 1);
876 struct mtd_info
*mtd
= inftl
->mbd
.mtd
;
878 int silly
= MAX_LOOPS
;
879 struct inftl_bci bci
;
882 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: inftl_readblock(inftl=%p,block=%ld,"
883 "buffer=%p)\n", inftl
, block
, buffer
);
885 while (thisEUN
< inftl
->nb_blocks
) {
886 if (inftl_read_oob(mtd
, (thisEUN
* inftl
->EraseSize
) +
887 blockofs
, 8, &retlen
, (char *)&bci
) < 0)
888 status
= SECTOR_IGNORE
;
890 status
= bci
.Status
| bci
.Status1
;
902 printk(KERN_WARNING
"INFTL: unknown status for "
903 "block %ld in EUN %d: 0x%04x\n",
904 block
, thisEUN
, status
);
909 printk(KERN_WARNING
"INFTL: infinite loop in "
910 "Virtual Unit Chain 0x%lx\n",
911 block
/ (inftl
->EraseSize
/ SECTORSIZE
));
915 thisEUN
= inftl
->PUtable
[thisEUN
];
919 if (thisEUN
== BLOCK_NIL
) {
920 /* The requested block is not on the media, return all 0x00 */
921 memset(buffer
, 0, SECTORSIZE
);
924 loff_t ptr
= (thisEUN
* inftl
->EraseSize
) + blockofs
;
925 int ret
= mtd
->read(mtd
, ptr
, SECTORSIZE
, &retlen
, buffer
);
927 /* Handle corrected bit flips gracefully */
928 if (ret
< 0 && ret
!= -EUCLEAN
)
934 static int inftl_getgeo(struct mtd_blktrans_dev
*dev
, struct hd_geometry
*geo
)
936 struct INFTLrecord
*inftl
= (void *)dev
;
938 geo
->heads
= inftl
->heads
;
939 geo
->sectors
= inftl
->sectors
;
940 geo
->cylinders
= inftl
->cylinders
;
945 static struct mtd_blktrans_ops inftl_tr
= {
947 .major
= INFTL_MAJOR
,
948 .part_bits
= INFTL_PARTN_BITS
,
949 .getgeo
= inftl_getgeo
,
950 .readsect
= inftl_readblock
,
951 .writesect
= inftl_writeblock
,
952 .add_mtd
= inftl_add_mtd
,
953 .remove_dev
= inftl_remove_dev
,
954 .owner
= THIS_MODULE
,
957 static int __init
init_inftl(void)
959 printk(KERN_INFO
"INFTL: inftlcore.c $Revision: 1.19 $, "
960 "inftlmount.c %s\n", inftlmountrev
);
962 return register_mtd_blktrans(&inftl_tr
);
965 static void __exit
cleanup_inftl(void)
967 deregister_mtd_blktrans(&inftl_tr
);
970 module_init(init_inftl
);
971 module_exit(cleanup_inftl
);
973 MODULE_LICENSE("GPL");
974 MODULE_AUTHOR("Greg Ungerer <gerg@snapgear.com>, David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
975 MODULE_DESCRIPTION("Support code for Inverse Flash Translation Layer, used on M-Systems DiskOnChip 2000, Millennium and Millennium Plus");