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 <asm/uaccess.h>
40 #include <asm/errno.h>
44 * Maximum number of loops while examining next block, to have a
45 * chance to detect consistency problems (they should never happen
46 * because of the checks done in the mounting.
48 #define MAX_LOOPS 10000
50 static void inftl_add_mtd(struct mtd_blktrans_ops
*tr
, struct mtd_info
*mtd
)
52 struct INFTLrecord
*inftl
;
55 if (mtd
->type
!= MTD_NANDFLASH
)
57 /* OK, this is moderately ugly. But probably safe. Alternatives? */
58 if (memcmp(mtd
->name
, "DiskOnChip", 10))
61 if (!mtd
->block_isbad
) {
63 "INFTL no longer supports the old DiskOnChip drivers loaded via docprobe.\n"
64 "Please use the new diskonchip driver under the NAND subsystem.\n");
68 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: add_mtd for %s\n", mtd
->name
);
70 inftl
= kmalloc(sizeof(*inftl
), GFP_KERNEL
);
73 printk(KERN_WARNING
"INFTL: Out of memory for data structures\n");
76 memset(inftl
, 0, sizeof(*inftl
));
79 inftl
->mbd
.devnum
= -1;
80 inftl
->mbd
.blksize
= 512;
82 memcpy(&inftl
->oobinfo
, &mtd
->oobinfo
, sizeof(struct nand_oobinfo
));
83 inftl
->oobinfo
.useecc
= MTD_NANDECC_PLACEONLY
;
85 if (INFTL_mount(inftl
) < 0) {
86 printk(KERN_WARNING
"INFTL: could not mount device\n");
91 /* OK, it's a new one. Set up all the data structures. */
93 /* Calculate geometry */
94 inftl
->cylinders
= 1024;
97 temp
= inftl
->cylinders
* inftl
->heads
;
98 inftl
->sectors
= inftl
->mbd
.size
/ temp
;
99 if (inftl
->mbd
.size
% temp
) {
101 temp
= inftl
->cylinders
* inftl
->sectors
;
102 inftl
->heads
= inftl
->mbd
.size
/ temp
;
104 if (inftl
->mbd
.size
% temp
) {
106 temp
= inftl
->heads
* inftl
->sectors
;
107 inftl
->cylinders
= inftl
->mbd
.size
/ temp
;
111 if (inftl
->mbd
.size
!= inftl
->heads
* inftl
->cylinders
* inftl
->sectors
) {
114 mbd.size == heads * cylinders * sectors
116 printk(KERN_WARNING
"INFTL: cannot calculate a geometry to "
117 "match size of 0x%lx.\n", inftl
->mbd
.size
);
118 printk(KERN_WARNING
"INFTL: using C:%d H:%d S:%d "
119 "(== 0x%lx sects)\n",
120 inftl
->cylinders
, inftl
->heads
, inftl
->sectors
,
121 (long)inftl
->cylinders
* (long)inftl
->heads
*
122 (long)inftl
->sectors
);
125 if (add_mtd_blktrans_dev(&inftl
->mbd
)) {
126 kfree(inftl
->PUtable
);
127 kfree(inftl
->VUtable
);
132 printk(KERN_INFO
"INFTL: Found new inftl%c\n", inftl
->mbd
.devnum
+ 'a');
137 static void inftl_remove_dev(struct mtd_blktrans_dev
*dev
)
139 struct INFTLrecord
*inftl
= (void *)dev
;
141 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: remove_dev (i=%d)\n", dev
->devnum
);
143 del_mtd_blktrans_dev(dev
);
145 kfree(inftl
->PUtable
);
146 kfree(inftl
->VUtable
);
151 * Actual INFTL access routines.
155 * INFTL_findfreeblock: Find a free Erase Unit on the INFTL partition.
156 * This function is used when the give Virtual Unit Chain.
158 static u16
INFTL_findfreeblock(struct INFTLrecord
*inftl
, int desperate
)
160 u16 pot
= inftl
->LastFreeEUN
;
161 int silly
= inftl
->nb_blocks
;
163 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: INFTL_findfreeblock(inftl=%p,"
164 "desperate=%d)\n", inftl
, desperate
);
167 * Normally, we force a fold to happen before we run out of free
170 if (!desperate
&& inftl
->numfreeEUNs
< 2) {
171 DEBUG(MTD_DEBUG_LEVEL1
, "INFTL: there are too few free "
172 "EUNs (%d)\n", inftl
->numfreeEUNs
);
176 /* Scan for a free block */
178 if (inftl
->PUtable
[pot
] == BLOCK_FREE
) {
179 inftl
->LastFreeEUN
= pot
;
183 if (++pot
> inftl
->lastEUN
)
187 printk(KERN_WARNING
"INFTL: no free blocks found! "
188 "EUN range = %d - %d\n", 0, inftl
->LastFreeEUN
);
191 } while (pot
!= inftl
->LastFreeEUN
);
196 static u16
INFTL_foldchain(struct INFTLrecord
*inftl
, unsigned thisVUC
, unsigned pendingblock
)
198 u16 BlockMap
[MAX_SECTORS_PER_UNIT
];
199 unsigned char BlockDeleted
[MAX_SECTORS_PER_UNIT
];
200 unsigned int thisEUN
, prevEUN
, status
;
202 unsigned int targetEUN
;
203 struct inftl_oob oob
;
206 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: INFTL_foldchain(inftl=%p,thisVUC=%d,"
207 "pending=%d)\n", inftl
, thisVUC
, pendingblock
);
209 memset(BlockMap
, 0xff, sizeof(BlockMap
));
210 memset(BlockDeleted
, 0, sizeof(BlockDeleted
));
212 thisEUN
= targetEUN
= inftl
->VUtable
[thisVUC
];
214 if (thisEUN
== BLOCK_NIL
) {
215 printk(KERN_WARNING
"INFTL: trying to fold non-existent "
216 "Virtual Unit Chain %d!\n", thisVUC
);
221 * Scan to find the Erase Unit which holds the actual data for each
222 * 512-byte block within the Chain.
225 while (thisEUN
< inftl
->nb_blocks
) {
226 for (block
= 0; block
< inftl
->EraseSize
/SECTORSIZE
; block
++) {
227 if ((BlockMap
[block
] != 0xffff) || BlockDeleted
[block
])
230 if (MTD_READOOB(inftl
->mbd
.mtd
, (thisEUN
* inftl
->EraseSize
)
231 + (block
* SECTORSIZE
), 16 , &retlen
,
233 status
= SECTOR_IGNORE
;
235 status
= oob
.b
.Status
| oob
.b
.Status1
;
242 BlockMap
[block
] = thisEUN
;
245 BlockDeleted
[block
] = 1;
248 printk(KERN_WARNING
"INFTL: unknown status "
249 "for block %d in EUN %d: %x\n",
250 block
, thisEUN
, status
);
256 printk(KERN_WARNING
"INFTL: infinite loop in Virtual "
257 "Unit Chain 0x%x\n", thisVUC
);
261 thisEUN
= inftl
->PUtable
[thisEUN
];
265 * OK. We now know the location of every block in the Virtual Unit
266 * Chain, and the Erase Unit into which we are supposed to be copying.
269 DEBUG(MTD_DEBUG_LEVEL1
, "INFTL: folding chain %d into unit %d\n",
272 for (block
= 0; block
< inftl
->EraseSize
/SECTORSIZE
; block
++) {
273 unsigned char movebuf
[SECTORSIZE
];
277 * If it's in the target EUN already, or if it's pending write,
280 if (BlockMap
[block
] == targetEUN
|| (pendingblock
==
281 (thisVUC
* (inftl
->EraseSize
/ SECTORSIZE
) + block
))) {
286 * Copy only in non free block (free blocks can only
287 * happen in case of media errors or deleted blocks).
289 if (BlockMap
[block
] == BLOCK_NIL
)
292 ret
= MTD_READ(inftl
->mbd
.mtd
, (inftl
->EraseSize
*
293 BlockMap
[block
]) + (block
* SECTORSIZE
), SECTORSIZE
,
296 ret
= MTD_READ(inftl
->mbd
.mtd
, (inftl
->EraseSize
*
297 BlockMap
[block
]) + (block
* SECTORSIZE
),
298 SECTORSIZE
, &retlen
, movebuf
);
300 DEBUG(MTD_DEBUG_LEVEL1
, "INFTL: error went "
303 memset(&oob
, 0xff, sizeof(struct inftl_oob
));
304 oob
.b
.Status
= oob
.b
.Status1
= SECTOR_USED
;
305 MTD_WRITEECC(inftl
->mbd
.mtd
, (inftl
->EraseSize
* targetEUN
) +
306 (block
* SECTORSIZE
), SECTORSIZE
, &retlen
,
307 movebuf
, (char *)&oob
, &inftl
->oobinfo
);
311 * Newest unit in chain now contains data from _all_ older units.
312 * So go through and erase each unit in chain, oldest first. (This
313 * is important, by doing oldest first if we crash/reboot then it
314 * it is relatively simple to clean up the mess).
316 DEBUG(MTD_DEBUG_LEVEL1
, "INFTL: want to erase virtual chain %d\n",
320 /* Find oldest unit in chain. */
321 thisEUN
= inftl
->VUtable
[thisVUC
];
323 while (inftl
->PUtable
[thisEUN
] != BLOCK_NIL
) {
325 thisEUN
= inftl
->PUtable
[thisEUN
];
328 /* Check if we are all done */
329 if (thisEUN
== targetEUN
)
332 if (INFTL_formatblock(inftl
, thisEUN
) < 0) {
334 * Could not erase : mark block as reserved.
336 inftl
->PUtable
[thisEUN
] = BLOCK_RESERVED
;
338 /* Correctly erased : mark it as free */
339 inftl
->PUtable
[thisEUN
] = BLOCK_FREE
;
340 inftl
->PUtable
[prevEUN
] = BLOCK_NIL
;
341 inftl
->numfreeEUNs
++;
348 static u16
INFTL_makefreeblock(struct INFTLrecord
*inftl
, unsigned pendingblock
)
351 * This is the part that needs some cleverness applied.
352 * For now, I'm doing the minimum applicable to actually
353 * get the thing to work.
354 * Wear-levelling and other clever stuff needs to be implemented
355 * and we also need to do some assessment of the results when
356 * the system loses power half-way through the routine.
358 u16 LongestChain
= 0;
359 u16 ChainLength
= 0, thislen
;
362 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: INFTL_makefreeblock(inftl=%p,"
363 "pending=%d)\n", inftl
, pendingblock
);
365 for (chain
= 0; chain
< inftl
->nb_blocks
; chain
++) {
366 EUN
= inftl
->VUtable
[chain
];
369 while (EUN
<= inftl
->lastEUN
) {
371 EUN
= inftl
->PUtable
[EUN
];
372 if (thislen
> 0xff00) {
373 printk(KERN_WARNING
"INFTL: endless loop in "
374 "Virtual Chain %d: Unit %x\n",
377 * Actually, don't return failure.
378 * Just ignore this chain and get on with it.
385 if (thislen
> ChainLength
) {
386 ChainLength
= thislen
;
387 LongestChain
= chain
;
391 if (ChainLength
< 2) {
392 printk(KERN_WARNING
"INFTL: no Virtual Unit Chains available "
393 "for folding. Failing request\n");
397 return INFTL_foldchain(inftl
, LongestChain
, pendingblock
);
400 static int nrbits(unsigned int val
, int bitcount
)
404 for (i
= 0; (i
< bitcount
); i
++)
405 total
+= (((0x1 << i
) & val
) ? 1 : 0);
410 * INFTL_findwriteunit: Return the unit number into which we can write
411 * for this block. Make it available if it isn't already.
413 static inline u16
INFTL_findwriteunit(struct INFTLrecord
*inftl
, unsigned block
)
415 unsigned int thisVUC
= block
/ (inftl
->EraseSize
/ SECTORSIZE
);
416 unsigned int thisEUN
, writeEUN
, prev_block
, status
;
417 unsigned long blockofs
= (block
* SECTORSIZE
) & (inftl
->EraseSize
-1);
418 struct inftl_oob oob
;
419 struct inftl_bci bci
;
420 unsigned char anac
, nacs
, parity
;
422 int silly
, silly2
= 3;
424 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: INFTL_findwriteunit(inftl=%p,"
425 "block=%d)\n", inftl
, block
);
429 * Scan the media to find a unit in the VUC which has
430 * a free space for the block in question.
432 writeEUN
= BLOCK_NIL
;
433 thisEUN
= inftl
->VUtable
[thisVUC
];
436 while (thisEUN
<= inftl
->lastEUN
) {
437 MTD_READOOB(inftl
->mbd
.mtd
, (thisEUN
* inftl
->EraseSize
) +
438 blockofs
, 8, &retlen
, (char *)&bci
);
440 status
= bci
.Status
| bci
.Status1
;
441 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: status of block %d in "
442 "EUN %d is %x\n", block
, writeEUN
, status
);
450 /* Can't go any further */
456 * Invalid block. Don't use it any more.
463 printk(KERN_WARNING
"INFTL: infinite loop in "
464 "Virtual Unit Chain 0x%x\n", thisVUC
);
468 /* Skip to next block in chain */
469 thisEUN
= inftl
->PUtable
[thisEUN
];
473 if (writeEUN
!= BLOCK_NIL
)
478 * OK. We didn't find one in the existing chain, or there
479 * is no existing chain. Allocate a new one.
481 writeEUN
= INFTL_findfreeblock(inftl
, 0);
483 if (writeEUN
== BLOCK_NIL
) {
485 * That didn't work - there were no free blocks just
486 * waiting to be picked up. We're going to have to fold
487 * a chain to make room.
489 thisEUN
= INFTL_makefreeblock(inftl
, 0xffff);
492 * Hopefully we free something, lets try again.
493 * This time we are desperate...
495 DEBUG(MTD_DEBUG_LEVEL1
, "INFTL: using desperate==1 "
496 "to find free EUN to accommodate write to "
497 "VUC %d\n", thisVUC
);
498 writeEUN
= INFTL_findfreeblock(inftl
, 1);
499 if (writeEUN
== BLOCK_NIL
) {
501 * Ouch. This should never happen - we should
502 * always be able to make some room somehow.
503 * If we get here, we've allocated more storage
504 * space than actual media, or our makefreeblock
505 * routine is missing something.
507 printk(KERN_WARNING
"INFTL: cannot make free "
510 INFTL_dumptables(inftl
);
511 INFTL_dumpVUchains(inftl
);
518 * Insert new block into virtual chain. Firstly update the
519 * block headers in flash...
523 thisEUN
= inftl
->VUtable
[thisVUC
];
524 if (thisEUN
!= BLOCK_NIL
) {
525 MTD_READOOB(inftl
->mbd
.mtd
, thisEUN
* inftl
->EraseSize
526 + 8, 8, &retlen
, (char *)&oob
.u
);
527 anac
= oob
.u
.a
.ANAC
+ 1;
528 nacs
= oob
.u
.a
.NACs
+ 1;
531 prev_block
= inftl
->VUtable
[thisVUC
];
532 if (prev_block
< inftl
->nb_blocks
)
533 prev_block
-= inftl
->firstEUN
;
535 parity
= (nrbits(thisVUC
, 16) & 0x1) ? 0x1 : 0;
536 parity
|= (nrbits(prev_block
, 16) & 0x1) ? 0x2 : 0;
537 parity
|= (nrbits(anac
, 8) & 0x1) ? 0x4 : 0;
538 parity
|= (nrbits(nacs
, 8) & 0x1) ? 0x8 : 0;
540 oob
.u
.a
.virtualUnitNo
= cpu_to_le16(thisVUC
);
541 oob
.u
.a
.prevUnitNo
= cpu_to_le16(prev_block
);
544 oob
.u
.a
.parityPerField
= parity
;
545 oob
.u
.a
.discarded
= 0xaa;
547 MTD_WRITEOOB(inftl
->mbd
.mtd
, writeEUN
* inftl
->EraseSize
+ 8, 8,
548 &retlen
, (char *)&oob
.u
);
550 /* Also back up header... */
551 oob
.u
.b
.virtualUnitNo
= cpu_to_le16(thisVUC
);
552 oob
.u
.b
.prevUnitNo
= cpu_to_le16(prev_block
);
555 oob
.u
.b
.parityPerField
= parity
;
556 oob
.u
.b
.discarded
= 0xaa;
558 MTD_WRITEOOB(inftl
->mbd
.mtd
, writeEUN
* inftl
->EraseSize
+
559 SECTORSIZE
* 4 + 8, 8, &retlen
, (char *)&oob
.u
);
561 inftl
->PUtable
[writeEUN
] = inftl
->VUtable
[thisVUC
];
562 inftl
->VUtable
[thisVUC
] = writeEUN
;
564 inftl
->numfreeEUNs
--;
569 printk(KERN_WARNING
"INFTL: error folding to make room for Virtual "
570 "Unit Chain 0x%x\n", thisVUC
);
575 * Given a Virtual Unit Chain, see if it can be deleted, and if so do it.
577 static void INFTL_trydeletechain(struct INFTLrecord
*inftl
, unsigned thisVUC
)
579 unsigned char BlockUsed
[MAX_SECTORS_PER_UNIT
];
580 unsigned char BlockDeleted
[MAX_SECTORS_PER_UNIT
];
581 unsigned int thisEUN
, status
;
583 struct inftl_bci bci
;
586 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: INFTL_trydeletechain(inftl=%p,"
587 "thisVUC=%d)\n", inftl
, thisVUC
);
589 memset(BlockUsed
, 0, sizeof(BlockUsed
));
590 memset(BlockDeleted
, 0, sizeof(BlockDeleted
));
592 thisEUN
= inftl
->VUtable
[thisVUC
];
593 if (thisEUN
== BLOCK_NIL
) {
594 printk(KERN_WARNING
"INFTL: trying to delete non-existent "
595 "Virtual Unit Chain %d!\n", thisVUC
);
600 * Scan through the Erase Units to determine whether any data is in
601 * each of the 512-byte blocks within the Chain.
604 while (thisEUN
< inftl
->nb_blocks
) {
605 for (block
= 0; block
< inftl
->EraseSize
/SECTORSIZE
; block
++) {
606 if (BlockUsed
[block
] || BlockDeleted
[block
])
609 if (MTD_READOOB(inftl
->mbd
.mtd
, (thisEUN
* inftl
->EraseSize
)
610 + (block
* SECTORSIZE
), 8 , &retlen
,
612 status
= SECTOR_IGNORE
;
614 status
= bci
.Status
| bci
.Status1
;
621 BlockUsed
[block
] = 1;
624 BlockDeleted
[block
] = 1;
627 printk(KERN_WARNING
"INFTL: unknown status "
628 "for block %d in EUN %d: 0x%x\n",
629 block
, thisEUN
, status
);
634 printk(KERN_WARNING
"INFTL: infinite loop in Virtual "
635 "Unit Chain 0x%x\n", thisVUC
);
639 thisEUN
= inftl
->PUtable
[thisEUN
];
642 for (block
= 0; block
< inftl
->EraseSize
/SECTORSIZE
; block
++)
643 if (BlockUsed
[block
])
647 * For each block in the chain free it and make it available
648 * for future use. Erase from the oldest unit first.
650 DEBUG(MTD_DEBUG_LEVEL1
, "INFTL: deleting empty VUC %d\n", thisVUC
);
653 u16
*prevEUN
= &inftl
->VUtable
[thisVUC
];
656 /* If the chain is all gone already, we're done */
657 if (thisEUN
== BLOCK_NIL
) {
658 DEBUG(MTD_DEBUG_LEVEL2
, "INFTL: Empty VUC %d for deletion was already absent\n", thisEUN
);
662 /* Find oldest unit in chain. */
663 while (inftl
->PUtable
[thisEUN
] != BLOCK_NIL
) {
664 BUG_ON(thisEUN
>= inftl
->nb_blocks
);
666 prevEUN
= &inftl
->PUtable
[thisEUN
];
670 DEBUG(MTD_DEBUG_LEVEL3
, "Deleting EUN %d from VUC %d\n",
673 if (INFTL_formatblock(inftl
, thisEUN
) < 0) {
675 * Could not erase : mark block as reserved.
677 inftl
->PUtable
[thisEUN
] = BLOCK_RESERVED
;
679 /* Correctly erased : mark it as free */
680 inftl
->PUtable
[thisEUN
] = BLOCK_FREE
;
681 inftl
->numfreeEUNs
++;
684 /* Now sort out whatever was pointing to it... */
685 *prevEUN
= BLOCK_NIL
;
687 /* Ideally we'd actually be responsive to new
688 requests while we're doing this -- if there's
689 free space why should others be made to wait? */
693 inftl
->VUtable
[thisVUC
] = BLOCK_NIL
;
696 static int INFTL_deleteblock(struct INFTLrecord
*inftl
, unsigned block
)
698 unsigned int thisEUN
= inftl
->VUtable
[block
/ (inftl
->EraseSize
/ SECTORSIZE
)];
699 unsigned long blockofs
= (block
* SECTORSIZE
) & (inftl
->EraseSize
- 1);
701 int silly
= MAX_LOOPS
;
703 struct inftl_bci bci
;
705 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: INFTL_deleteblock(inftl=%p,"
706 "block=%d)\n", inftl
, block
);
708 while (thisEUN
< inftl
->nb_blocks
) {
709 if (MTD_READOOB(inftl
->mbd
.mtd
, (thisEUN
* inftl
->EraseSize
) +
710 blockofs
, 8, &retlen
, (char *)&bci
) < 0)
711 status
= SECTOR_IGNORE
;
713 status
= bci
.Status
| bci
.Status1
;
725 printk(KERN_WARNING
"INFTL: unknown status for "
726 "block %d in EUN %d: 0x%x\n",
727 block
, thisEUN
, status
);
732 printk(KERN_WARNING
"INFTL: infinite loop in Virtual "
734 block
/ (inftl
->EraseSize
/ SECTORSIZE
));
737 thisEUN
= inftl
->PUtable
[thisEUN
];
741 if (thisEUN
!= BLOCK_NIL
) {
742 loff_t ptr
= (thisEUN
* inftl
->EraseSize
) + blockofs
;
744 if (MTD_READOOB(inftl
->mbd
.mtd
, ptr
, 8, &retlen
, (char *)&bci
) < 0)
746 bci
.Status
= bci
.Status1
= SECTOR_DELETED
;
747 if (MTD_WRITEOOB(inftl
->mbd
.mtd
, ptr
, 8, &retlen
, (char *)&bci
) < 0)
749 INFTL_trydeletechain(inftl
, block
/ (inftl
->EraseSize
/ SECTORSIZE
));
754 static int inftl_writeblock(struct mtd_blktrans_dev
*mbd
, unsigned long block
,
757 struct INFTLrecord
*inftl
= (void *)mbd
;
758 unsigned int writeEUN
;
759 unsigned long blockofs
= (block
* SECTORSIZE
) & (inftl
->EraseSize
- 1);
761 struct inftl_oob oob
;
764 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: inftl_writeblock(inftl=%p,block=%ld,"
765 "buffer=%p)\n", inftl
, block
, buffer
);
767 /* Is block all zero? */
768 pend
= buffer
+ SECTORSIZE
;
769 for (p
= buffer
; p
< pend
&& !*p
; p
++)
773 writeEUN
= INFTL_findwriteunit(inftl
, block
);
775 if (writeEUN
== BLOCK_NIL
) {
776 printk(KERN_WARNING
"inftl_writeblock(): cannot find "
777 "block to write to\n");
779 * If we _still_ haven't got a block to use,
785 memset(&oob
, 0xff, sizeof(struct inftl_oob
));
786 oob
.b
.Status
= oob
.b
.Status1
= SECTOR_USED
;
787 MTD_WRITEECC(inftl
->mbd
.mtd
, (writeEUN
* inftl
->EraseSize
) +
788 blockofs
, SECTORSIZE
, &retlen
, (char *)buffer
,
789 (char *)&oob
, &inftl
->oobinfo
);
791 * need to write SECTOR_USED flags since they are not written
795 INFTL_deleteblock(inftl
, block
);
801 static int inftl_readblock(struct mtd_blktrans_dev
*mbd
, unsigned long block
,
804 struct INFTLrecord
*inftl
= (void *)mbd
;
805 unsigned int thisEUN
= inftl
->VUtable
[block
/ (inftl
->EraseSize
/ SECTORSIZE
)];
806 unsigned long blockofs
= (block
* SECTORSIZE
) & (inftl
->EraseSize
- 1);
808 int silly
= MAX_LOOPS
;
809 struct inftl_bci bci
;
812 DEBUG(MTD_DEBUG_LEVEL3
, "INFTL: inftl_readblock(inftl=%p,block=%ld,"
813 "buffer=%p)\n", inftl
, block
, buffer
);
815 while (thisEUN
< inftl
->nb_blocks
) {
816 if (MTD_READOOB(inftl
->mbd
.mtd
, (thisEUN
* inftl
->EraseSize
) +
817 blockofs
, 8, &retlen
, (char *)&bci
) < 0)
818 status
= SECTOR_IGNORE
;
820 status
= bci
.Status
| bci
.Status1
;
832 printk(KERN_WARNING
"INFTL: unknown status for "
833 "block %ld in EUN %d: 0x%04x\n",
834 block
, thisEUN
, status
);
839 printk(KERN_WARNING
"INFTL: infinite loop in "
840 "Virtual Unit Chain 0x%lx\n",
841 block
/ (inftl
->EraseSize
/ SECTORSIZE
));
845 thisEUN
= inftl
->PUtable
[thisEUN
];
849 if (thisEUN
== BLOCK_NIL
) {
850 /* The requested block is not on the media, return all 0x00 */
851 memset(buffer
, 0, SECTORSIZE
);
854 loff_t ptr
= (thisEUN
* inftl
->EraseSize
) + blockofs
;
855 if (MTD_READ(inftl
->mbd
.mtd
, ptr
, SECTORSIZE
, &retlen
,
862 static int inftl_getgeo(struct mtd_blktrans_dev
*dev
, struct hd_geometry
*geo
)
864 struct INFTLrecord
*inftl
= (void *)dev
;
866 geo
->heads
= inftl
->heads
;
867 geo
->sectors
= inftl
->sectors
;
868 geo
->cylinders
= inftl
->cylinders
;
873 static struct mtd_blktrans_ops inftl_tr
= {
875 .major
= INFTL_MAJOR
,
876 .part_bits
= INFTL_PARTN_BITS
,
877 .getgeo
= inftl_getgeo
,
878 .readsect
= inftl_readblock
,
879 .writesect
= inftl_writeblock
,
880 .add_mtd
= inftl_add_mtd
,
881 .remove_dev
= inftl_remove_dev
,
882 .owner
= THIS_MODULE
,
885 static int __init
init_inftl(void)
887 printk(KERN_INFO
"INFTL: inftlcore.c $Revision: 1.19 $, "
888 "inftlmount.c %s\n", inftlmountrev
);
890 return register_mtd_blktrans(&inftl_tr
);
893 static void __exit
cleanup_inftl(void)
895 deregister_mtd_blktrans(&inftl_tr
);
898 module_init(init_inftl
);
899 module_exit(cleanup_inftl
);
901 MODULE_LICENSE("GPL");
902 MODULE_AUTHOR("Greg Ungerer <gerg@snapgear.com>, David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
903 MODULE_DESCRIPTION("Support code for Inverse Flash Translation Layer, used on M-Systems DiskOnChip 2000, Millennium and Millennium Plus");