2 * Linux driver for NAND Flash Translation Layer
4 * Copyright © 1999 Machine Vision Holdings, Inc.
5 * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
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.
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.
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
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <asm/errno.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>
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>
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 */
45 #define MAX_LOOPS 10000
48 static void nftl_add_mtd(struct mtd_blktrans_ops
*tr
, struct mtd_info
*mtd
)
50 struct NFTLrecord
*nftl
;
53 if (mtd
->type
!= MTD_NANDFLASH
|| mtd
->size
> UINT_MAX
)
55 /* OK, this is moderately ugly. But probably safe. Alternatives? */
56 if (memcmp(mtd
->name
, "DiskOnChip", 10))
59 pr_debug("NFTL: add_mtd for %s\n", mtd
->name
);
61 nftl
= kzalloc(sizeof(struct NFTLrecord
), GFP_KERNEL
);
67 nftl
->mbd
.devnum
= -1;
71 if (NFTL_mount(nftl
) < 0) {
72 printk(KERN_WARNING
"NFTL: could not mount device\n");
77 /* OK, it's a new one. Set up all the data structures. */
79 /* Calculate geometry */
80 nftl
->cylinders
= 1024;
83 temp
= nftl
->cylinders
* nftl
->heads
;
84 nftl
->sectors
= nftl
->mbd
.size
/ temp
;
85 if (nftl
->mbd
.size
% temp
) {
87 temp
= nftl
->cylinders
* nftl
->sectors
;
88 nftl
->heads
= nftl
->mbd
.size
/ temp
;
90 if (nftl
->mbd
.size
% temp
) {
92 temp
= nftl
->heads
* nftl
->sectors
;
93 nftl
->cylinders
= nftl
->mbd
.size
/ temp
;
97 if (nftl
->mbd
.size
!= nftl
->heads
* nftl
->cylinders
* nftl
->sectors
) {
100 mbd.size == heads * cylinders * sectors
102 printk(KERN_WARNING
"NFTL: cannot calculate a geometry to "
103 "match size of 0x%lx.\n", nftl
->mbd
.size
);
104 printk(KERN_WARNING
"NFTL: using C:%d H:%d S:%d "
105 "(== 0x%lx sects)\n",
106 nftl
->cylinders
, nftl
->heads
, nftl
->sectors
,
107 (long)nftl
->cylinders
* (long)nftl
->heads
*
108 (long)nftl
->sectors
);
111 if (add_mtd_blktrans_dev(&nftl
->mbd
)) {
112 kfree(nftl
->ReplUnitTable
);
113 kfree(nftl
->EUNtable
);
118 printk(KERN_INFO
"NFTL: Found new nftl%c\n", nftl
->mbd
.devnum
+ 'a');
122 static void nftl_remove_dev(struct mtd_blktrans_dev
*dev
)
124 struct NFTLrecord
*nftl
= (void *)dev
;
126 pr_debug("NFTL: remove_dev (i=%d)\n", dev
->devnum
);
128 del_mtd_blktrans_dev(dev
);
129 kfree(nftl
->ReplUnitTable
);
130 kfree(nftl
->EUNtable
);
134 * Read oob data from flash
136 int nftl_read_oob(struct mtd_info
*mtd
, loff_t offs
, size_t len
,
137 size_t *retlen
, uint8_t *buf
)
139 loff_t mask
= mtd
->writesize
- 1;
140 struct mtd_oob_ops ops
;
143 ops
.mode
= MTD_OPS_PLACE_OOB
;
144 ops
.ooboffs
= offs
& mask
;
149 res
= mtd_read_oob(mtd
, offs
& ~mask
, &ops
);
150 *retlen
= ops
.oobretlen
;
155 * Write oob data to flash
157 int nftl_write_oob(struct mtd_info
*mtd
, loff_t offs
, size_t len
,
158 size_t *retlen
, uint8_t *buf
)
160 loff_t mask
= mtd
->writesize
- 1;
161 struct mtd_oob_ops ops
;
164 ops
.mode
= MTD_OPS_PLACE_OOB
;
165 ops
.ooboffs
= offs
& mask
;
170 res
= mtd_write_oob(mtd
, offs
& ~mask
, &ops
);
171 *retlen
= ops
.oobretlen
;
175 #ifdef CONFIG_NFTL_RW
178 * Write data and oob to flash
180 static int nftl_write(struct mtd_info
*mtd
, loff_t offs
, size_t len
,
181 size_t *retlen
, uint8_t *buf
, uint8_t *oob
)
183 loff_t mask
= mtd
->writesize
- 1;
184 struct mtd_oob_ops ops
;
187 ops
.mode
= MTD_OPS_PLACE_OOB
;
188 ops
.ooboffs
= offs
& mask
;
189 ops
.ooblen
= mtd
->oobsize
;
194 res
= mtd_write_oob(mtd
, offs
& ~mask
, &ops
);
195 *retlen
= ops
.retlen
;
199 /* Actual NFTL access routines */
200 /* NFTL_findfreeblock: Find a free Erase Unit on the NFTL partition. This function is used
201 * when the give Virtual Unit Chain
203 static u16
NFTL_findfreeblock(struct NFTLrecord
*nftl
, int desperate
)
205 /* For a given Virtual Unit Chain: find or create a free block and
206 add it to the chain */
207 /* We're passed the number of the last EUN in the chain, to save us from
208 having to look it up again */
209 u16 pot
= nftl
->LastFreeEUN
;
210 int silly
= nftl
->nb_blocks
;
212 /* Normally, we force a fold to happen before we run out of free blocks completely */
213 if (!desperate
&& nftl
->numfreeEUNs
< 2) {
214 pr_debug("NFTL_findfreeblock: there are too few free EUNs\n");
218 /* Scan for a free block */
220 if (nftl
->ReplUnitTable
[pot
] == BLOCK_FREE
) {
221 nftl
->LastFreeEUN
= pot
;
226 /* This will probably point to the MediaHdr unit itself,
227 right at the beginning of the partition. But that unit
228 (and the backup unit too) should have the UCI set
229 up so that it's not selected for overwriting */
230 if (++pot
> nftl
->lastEUN
)
231 pot
= le16_to_cpu(nftl
->MediaHdr
.FirstPhysicalEUN
);
234 printk("Argh! No free blocks found! LastFreeEUN = %d, "
235 "FirstEUN = %d\n", nftl
->LastFreeEUN
,
236 le16_to_cpu(nftl
->MediaHdr
.FirstPhysicalEUN
));
239 } while (pot
!= nftl
->LastFreeEUN
);
244 static u16
NFTL_foldchain (struct NFTLrecord
*nftl
, unsigned thisVUC
, unsigned pendingblock
)
246 struct mtd_info
*mtd
= nftl
->mbd
.mtd
;
247 u16 BlockMap
[MAX_SECTORS_PER_UNIT
];
248 unsigned char BlockLastState
[MAX_SECTORS_PER_UNIT
];
249 unsigned char BlockFreeFound
[MAX_SECTORS_PER_UNIT
];
250 unsigned int thisEUN
;
253 unsigned int targetEUN
;
258 memset(BlockMap
, 0xff, sizeof(BlockMap
));
259 memset(BlockFreeFound
, 0, sizeof(BlockFreeFound
));
261 thisEUN
= nftl
->EUNtable
[thisVUC
];
263 if (thisEUN
== BLOCK_NIL
) {
264 printk(KERN_WARNING
"Trying to fold non-existent "
265 "Virtual Unit Chain %d!\n", thisVUC
);
269 /* Scan to find the Erase Unit which holds the actual data for each
270 512-byte block within the Chain.
273 targetEUN
= BLOCK_NIL
;
274 while (thisEUN
<= nftl
->lastEUN
) {
275 unsigned int status
, foldmark
;
278 for (block
= 0; block
< nftl
->EraseSize
/ 512; block
++) {
279 nftl_read_oob(mtd
, (thisEUN
* nftl
->EraseSize
) +
280 (block
* 512), 16 , &retlen
,
283 foldmark
= oob
.u
.c
.FoldMark
| oob
.u
.c
.FoldMark1
;
284 if (foldmark
== FOLD_MARK_IN_PROGRESS
) {
285 pr_debug("Write Inhibited on EUN %d\n", thisEUN
);
288 /* There's no other reason not to do inplace,
289 except ones that come later. So we don't need
290 to preserve inplace */
294 status
= oob
.b
.Status
| oob
.b
.Status1
;
295 BlockLastState
[block
] = status
;
299 BlockFreeFound
[block
] = 1;
303 if (!BlockFreeFound
[block
])
304 BlockMap
[block
] = thisEUN
;
307 "SECTOR_USED found after SECTOR_FREE "
308 "in Virtual Unit Chain %d for block %d\n",
312 if (!BlockFreeFound
[block
])
313 BlockMap
[block
] = BLOCK_NIL
;
316 "SECTOR_DELETED found after SECTOR_FREE "
317 "in Virtual Unit Chain %d for block %d\n",
324 printk("Unknown status for block %d in EUN %d: %x\n",
325 block
, thisEUN
, status
);
330 printk(KERN_WARNING
"Infinite loop in Virtual Unit Chain 0x%x\n",
335 thisEUN
= nftl
->ReplUnitTable
[thisEUN
];
339 /* We're being asked to be a fold-in-place. Check
340 that all blocks which actually have data associated
341 with them (i.e. BlockMap[block] != BLOCK_NIL) are
342 either already present or SECTOR_FREE in the target
343 block. If not, we're going to have to fold out-of-place
346 for (block
= 0; block
< nftl
->EraseSize
/ 512 ; block
++) {
347 if (BlockLastState
[block
] != SECTOR_FREE
&&
348 BlockMap
[block
] != BLOCK_NIL
&&
349 BlockMap
[block
] != targetEUN
) {
350 pr_debug("Setting inplace to 0. VUC %d, "
351 "block %d was %x lastEUN, "
352 "and is in EUN %d (%s) %d\n",
353 thisVUC
, block
, BlockLastState
[block
],
355 BlockMap
[block
]== targetEUN
? "==" : "!=",
362 if (pendingblock
>= (thisVUC
* (nftl
->EraseSize
/ 512)) &&
363 pendingblock
< ((thisVUC
+ 1)* (nftl
->EraseSize
/ 512)) &&
364 BlockLastState
[pendingblock
- (thisVUC
* (nftl
->EraseSize
/ 512))] !=
366 pr_debug("Pending write not free in EUN %d. "
367 "Folding out of place.\n", targetEUN
);
373 pr_debug("Cannot fold Virtual Unit Chain %d in place. "
374 "Trying out-of-place\n", thisVUC
);
375 /* We need to find a targetEUN to fold into. */
376 targetEUN
= NFTL_findfreeblock(nftl
, 1);
377 if (targetEUN
== BLOCK_NIL
) {
378 /* Ouch. Now we're screwed. We need to do a
379 fold-in-place of another chain to make room
380 for this one. We need a better way of selecting
381 which chain to fold, because makefreeblock will
382 only ask us to fold the same one again.
385 "NFTL_findfreeblock(desperate) returns 0xffff.\n");
389 /* We put a fold mark in the chain we are folding only if we
390 fold in place to help the mount check code. If we do not fold in
391 place, it is possible to find the valid chain by selecting the
393 oob
.u
.c
.FoldMark
= oob
.u
.c
.FoldMark1
= cpu_to_le16(FOLD_MARK_IN_PROGRESS
);
394 oob
.u
.c
.unused
= 0xffffffff;
395 nftl_write_oob(mtd
, (nftl
->EraseSize
* targetEUN
) + 2 * 512 + 8,
396 8, &retlen
, (char *)&oob
.u
);
399 /* OK. We now know the location of every block in the Virtual Unit Chain,
400 and the Erase Unit into which we are supposed to be copying.
403 pr_debug("Folding chain %d into unit %d\n", thisVUC
, targetEUN
);
404 for (block
= 0; block
< nftl
->EraseSize
/ 512 ; block
++) {
405 unsigned char movebuf
[512];
408 /* If it's in the target EUN already, or if it's pending write, do nothing */
409 if (BlockMap
[block
] == targetEUN
||
410 (pendingblock
== (thisVUC
* (nftl
->EraseSize
/ 512) + block
))) {
414 /* copy only in non free block (free blocks can only
415 happen in case of media errors or deleted blocks) */
416 if (BlockMap
[block
] == BLOCK_NIL
)
420 (nftl
->EraseSize
* BlockMap
[block
]) + (block
* 512),
424 if (ret
< 0 && !mtd_is_bitflip(ret
)) {
426 (nftl
->EraseSize
* BlockMap
[block
]) + (block
* 512),
431 printk("Error went away on retry.\n");
433 memset(&oob
, 0xff, sizeof(struct nftl_oob
));
434 oob
.b
.Status
= oob
.b
.Status1
= SECTOR_USED
;
436 nftl_write(nftl
->mbd
.mtd
, (nftl
->EraseSize
* targetEUN
) +
437 (block
* 512), 512, &retlen
, movebuf
, (char *)&oob
);
440 /* add the header so that it is now a valid chain */
441 oob
.u
.a
.VirtUnitNum
= oob
.u
.a
.SpareVirtUnitNum
= cpu_to_le16(thisVUC
);
442 oob
.u
.a
.ReplUnitNum
= oob
.u
.a
.SpareReplUnitNum
= BLOCK_NIL
;
444 nftl_write_oob(mtd
, (nftl
->EraseSize
* targetEUN
) + 8,
445 8, &retlen
, (char *)&oob
.u
);
447 /* OK. We've moved the whole lot into the new block. Now we have to free the original blocks. */
449 /* At this point, we have two different chains for this Virtual Unit, and no way to tell
450 them apart. If we crash now, we get confused. However, both contain the same data, so we
451 shouldn't actually lose data in this case. It's just that when we load up on a medium which
452 has duplicate chains, we need to free one of the chains because it's not necessary any more.
454 thisEUN
= nftl
->EUNtable
[thisVUC
];
455 pr_debug("Want to erase\n");
457 /* For each block in the old chain (except the targetEUN of course),
458 free it and make it available for future use */
459 while (thisEUN
<= nftl
->lastEUN
&& thisEUN
!= targetEUN
) {
462 EUNtmp
= nftl
->ReplUnitTable
[thisEUN
];
464 if (NFTL_formatblock(nftl
, thisEUN
) < 0) {
465 /* could not erase : mark block as reserved
467 nftl
->ReplUnitTable
[thisEUN
] = BLOCK_RESERVED
;
469 /* correctly erased : mark it as free */
470 nftl
->ReplUnitTable
[thisEUN
] = BLOCK_FREE
;
476 /* Make this the new start of chain for thisVUC */
477 nftl
->ReplUnitTable
[targetEUN
] = BLOCK_NIL
;
478 nftl
->EUNtable
[thisVUC
] = targetEUN
;
483 static u16
NFTL_makefreeblock( struct NFTLrecord
*nftl
, unsigned pendingblock
)
485 /* This is the part that needs some cleverness applied.
486 For now, I'm doing the minimum applicable to actually
487 get the thing to work.
488 Wear-levelling and other clever stuff needs to be implemented
489 and we also need to do some assessment of the results when
490 the system loses power half-way through the routine.
492 u16 LongestChain
= 0;
493 u16 ChainLength
= 0, thislen
;
496 for (chain
= 0; chain
< le32_to_cpu(nftl
->MediaHdr
.FormattedSize
) / nftl
->EraseSize
; chain
++) {
497 EUN
= nftl
->EUNtable
[chain
];
500 while (EUN
<= nftl
->lastEUN
) {
502 //printk("VUC %d reaches len %d with EUN %d\n", chain, thislen, EUN);
503 EUN
= nftl
->ReplUnitTable
[EUN
] & 0x7fff;
504 if (thislen
> 0xff00) {
505 printk("Endless loop in Virtual Chain %d: Unit %x\n",
508 if (thislen
> 0xff10) {
509 /* Actually, don't return failure. Just ignore this chain and
516 if (thislen
> ChainLength
) {
517 //printk("New longest chain is %d with length %d\n", chain, thislen);
518 ChainLength
= thislen
;
519 LongestChain
= chain
;
523 if (ChainLength
< 2) {
524 printk(KERN_WARNING
"No Virtual Unit Chains available for folding. "
525 "Failing request\n");
529 return NFTL_foldchain (nftl
, LongestChain
, pendingblock
);
532 /* NFTL_findwriteunit: Return the unit number into which we can write
533 for this block. Make it available if it isn't already
535 static inline u16
NFTL_findwriteunit(struct NFTLrecord
*nftl
, unsigned block
)
538 u16 thisVUC
= block
/ (nftl
->EraseSize
/ 512);
539 struct mtd_info
*mtd
= nftl
->mbd
.mtd
;
540 unsigned int writeEUN
;
541 unsigned long blockofs
= (block
* 512) & (nftl
->EraseSize
-1);
543 int silly
, silly2
= 3;
547 /* Scan the media to find a unit in the VUC which has
548 a free space for the block in question.
551 /* This condition catches the 0x[7f]fff cases, as well as
552 being a sanity check for past-end-of-media access
555 writeEUN
= nftl
->EUNtable
[thisVUC
];
557 while (writeEUN
<= nftl
->lastEUN
) {
565 (writeEUN
* nftl
->EraseSize
) + blockofs
,
566 8, &retlen
, (char *)&bci
);
568 pr_debug("Status of block %d in EUN %d is %x\n",
569 block
, writeEUN
, le16_to_cpu(bci
.Status
));
571 status
= bci
.Status
| bci
.Status1
;
581 // Invalid block. Don't use it any more. Must implement.
587 "Infinite loop in Virtual Unit Chain 0x%x\n",
592 /* Skip to next block in chain */
593 writeEUN
= nftl
->ReplUnitTable
[writeEUN
];
596 /* OK. We didn't find one in the existing chain, or there
597 is no existing chain. */
599 /* Try to find an already-free block */
600 writeEUN
= NFTL_findfreeblock(nftl
, 0);
602 if (writeEUN
== BLOCK_NIL
) {
603 /* That didn't work - there were no free blocks just
604 waiting to be picked up. We're going to have to fold
605 a chain to make room.
608 /* First remember the start of this chain */
609 //u16 startEUN = nftl->EUNtable[thisVUC];
611 //printk("Write to VirtualUnitChain %d, calling makefreeblock()\n", thisVUC);
612 writeEUN
= NFTL_makefreeblock(nftl
, BLOCK_NIL
);
614 if (writeEUN
== BLOCK_NIL
) {
615 /* OK, we accept that the above comment is
616 lying - there may have been free blocks
617 last time we called NFTL_findfreeblock(),
618 but they are reserved for when we're
619 desperate. Well, now we're desperate.
621 pr_debug("Using desperate==1 to find free EUN to accommodate write to VUC %d\n", thisVUC
);
622 writeEUN
= NFTL_findfreeblock(nftl
, 1);
624 if (writeEUN
== BLOCK_NIL
) {
625 /* Ouch. This should never happen - we should
626 always be able to make some room somehow.
627 If we get here, we've allocated more storage
628 space than actual media, or our makefreeblock
629 routine is missing something.
631 printk(KERN_WARNING
"Cannot make free space.\n");
634 //printk("Restarting scan\n");
639 /* We've found a free block. Insert it into the chain. */
641 if (lastEUN
!= BLOCK_NIL
) {
642 thisVUC
|= 0x8000; /* It's a replacement block */
644 /* The first block in a new chain */
645 nftl
->EUNtable
[thisVUC
] = writeEUN
;
648 /* set up the actual EUN we're writing into */
649 /* Both in our cache... */
650 nftl
->ReplUnitTable
[writeEUN
] = BLOCK_NIL
;
652 /* ... and on the flash itself */
653 nftl_read_oob(mtd
, writeEUN
* nftl
->EraseSize
+ 8, 8,
654 &retlen
, (char *)&oob
.u
);
656 oob
.u
.a
.VirtUnitNum
= oob
.u
.a
.SpareVirtUnitNum
= cpu_to_le16(thisVUC
);
658 nftl_write_oob(mtd
, writeEUN
* nftl
->EraseSize
+ 8, 8,
659 &retlen
, (char *)&oob
.u
);
661 /* we link the new block to the chain only after the
662 block is ready. It avoids the case where the chain
663 could point to a free block */
664 if (lastEUN
!= BLOCK_NIL
) {
665 /* Both in our cache... */
666 nftl
->ReplUnitTable
[lastEUN
] = writeEUN
;
667 /* ... and on the flash itself */
668 nftl_read_oob(mtd
, (lastEUN
* nftl
->EraseSize
) + 8,
669 8, &retlen
, (char *)&oob
.u
);
671 oob
.u
.a
.ReplUnitNum
= oob
.u
.a
.SpareReplUnitNum
672 = cpu_to_le16(writeEUN
);
674 nftl_write_oob(mtd
, (lastEUN
* nftl
->EraseSize
) + 8,
675 8, &retlen
, (char *)&oob
.u
);
682 printk(KERN_WARNING
"Error folding to make room for Virtual Unit Chain 0x%x\n",
687 static int nftl_writeblock(struct mtd_blktrans_dev
*mbd
, unsigned long block
,
690 struct NFTLrecord
*nftl
= (void *)mbd
;
692 unsigned long blockofs
= (block
* 512) & (nftl
->EraseSize
- 1);
696 writeEUN
= NFTL_findwriteunit(nftl
, block
);
698 if (writeEUN
== BLOCK_NIL
) {
700 "NFTL_writeblock(): Cannot find block to write to\n");
701 /* If we _still_ haven't got a block to use, we're screwed */
705 memset(&oob
, 0xff, sizeof(struct nftl_oob
));
706 oob
.b
.Status
= oob
.b
.Status1
= SECTOR_USED
;
708 nftl_write(nftl
->mbd
.mtd
, (writeEUN
* nftl
->EraseSize
) + blockofs
,
709 512, &retlen
, (char *)buffer
, (char *)&oob
);
712 #endif /* CONFIG_NFTL_RW */
714 static int nftl_readblock(struct mtd_blktrans_dev
*mbd
, unsigned long block
,
717 struct NFTLrecord
*nftl
= (void *)mbd
;
718 struct mtd_info
*mtd
= nftl
->mbd
.mtd
;
720 u16 thisEUN
= nftl
->EUNtable
[block
/ (nftl
->EraseSize
/ 512)];
721 unsigned long blockofs
= (block
* 512) & (nftl
->EraseSize
- 1);
723 int silly
= MAX_LOOPS
;
727 lastgoodEUN
= BLOCK_NIL
;
729 if (thisEUN
!= BLOCK_NIL
) {
730 while (thisEUN
< nftl
->nb_blocks
) {
731 if (nftl_read_oob(mtd
, (thisEUN
* nftl
->EraseSize
) +
732 blockofs
, 8, &retlen
,
734 status
= SECTOR_IGNORE
;
736 status
= bci
.Status
| bci
.Status1
;
740 /* no modification of a sector should follow a free sector */
743 lastgoodEUN
= BLOCK_NIL
;
746 lastgoodEUN
= thisEUN
;
751 printk("Unknown status for block %ld in EUN %d: %x\n",
752 block
, thisEUN
, status
);
757 printk(KERN_WARNING
"Infinite loop in Virtual Unit Chain 0x%lx\n",
758 block
/ (nftl
->EraseSize
/ 512));
761 thisEUN
= nftl
->ReplUnitTable
[thisEUN
];
766 if (lastgoodEUN
== BLOCK_NIL
) {
767 /* the requested block is not on the media, return all 0x00 */
768 memset(buffer
, 0, 512);
770 loff_t ptr
= (lastgoodEUN
* nftl
->EraseSize
) + blockofs
;
772 int res
= mtd_read(mtd
, ptr
, 512, &retlen
, buffer
);
774 if (res
< 0 && !mtd_is_bitflip(res
))
780 static int nftl_getgeo(struct mtd_blktrans_dev
*dev
, struct hd_geometry
*geo
)
782 struct NFTLrecord
*nftl
= (void *)dev
;
784 geo
->heads
= nftl
->heads
;
785 geo
->sectors
= nftl
->sectors
;
786 geo
->cylinders
= nftl
->cylinders
;
791 /****************************************************************************
795 ****************************************************************************/
798 static struct mtd_blktrans_ops nftl_tr
= {
801 .part_bits
= NFTL_PARTN_BITS
,
803 .getgeo
= nftl_getgeo
,
804 .readsect
= nftl_readblock
,
805 #ifdef CONFIG_NFTL_RW
806 .writesect
= nftl_writeblock
,
808 .add_mtd
= nftl_add_mtd
,
809 .remove_dev
= nftl_remove_dev
,
810 .owner
= THIS_MODULE
,
813 static int __init
init_nftl(void)
815 return register_mtd_blktrans(&nftl_tr
);
818 static void __exit
cleanup_nftl(void)
820 deregister_mtd_blktrans(&nftl_tr
);
823 module_init(init_nftl
);
824 module_exit(cleanup_nftl
);
826 MODULE_LICENSE("GPL");
827 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
828 MODULE_DESCRIPTION("Support code for NAND Flash Translation Layer, used on M-Systems DiskOnChip 2000 and Millennium");
829 MODULE_ALIAS_BLOCKDEV_MAJOR(NFTL_MAJOR
);
This page took 0.047131 seconds and 6 git commands to generate.