2 * MTD device concatenation layer
4 * (C) 2002 Robert Kaiser <rkaiser@sysgo.de>
6 * NAND support by Christian Gan <cgan@iders.ca>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/sched.h>
15 #include <linux/types.h>
16 #include <linux/backing-dev.h>
18 #include <linux/mtd/mtd.h>
19 #include <linux/mtd/concat.h>
21 #include <asm/div64.h>
24 * Our storage structure:
25 * Subdev points to an array of pointers to struct mtd_info objects
26 * which is allocated along with this structure
32 struct mtd_info
**subdev
;
36 * how to calculate the size required for the above structure,
37 * including the pointer array subdev points to:
39 #define SIZEOF_STRUCT_MTD_CONCAT(num_subdev) \
40 ((sizeof(struct mtd_concat) + (num_subdev) * sizeof(struct mtd_info *)))
43 * Given a pointer to the MTD object in the mtd_concat structure,
44 * we can retrieve the pointer to that structure with this macro.
46 #define CONCAT(x) ((struct mtd_concat *)(x))
49 * MTD methods which look up the relevant subdevice, translate the
50 * effective address and pass through to the subdevice.
54 concat_read(struct mtd_info
*mtd
, loff_t from
, size_t len
,
55 size_t * retlen
, u_char
* buf
)
57 struct mtd_concat
*concat
= CONCAT(mtd
);
63 for (i
= 0; i
< concat
->num_subdev
; i
++) {
64 struct mtd_info
*subdev
= concat
->subdev
[i
];
67 if (from
>= subdev
->size
) {
68 /* Not destined for this subdev */
73 if (from
+ len
> subdev
->size
)
74 /* First part goes into this subdev */
75 size
= subdev
->size
- from
;
77 /* Entire transaction goes into this subdev */
80 err
= subdev
->read(subdev
, from
, size
, &retsize
, buf
);
82 /* Save information about bitflips! */
84 if (err
== -EBADMSG
) {
85 mtd
->ecc_stats
.failed
++;
87 } else if (err
== -EUCLEAN
) {
88 mtd
->ecc_stats
.corrected
++;
89 /* Do not overwrite -EBADMSG !! */
108 concat_write(struct mtd_info
*mtd
, loff_t to
, size_t len
,
109 size_t * retlen
, const u_char
* buf
)
111 struct mtd_concat
*concat
= CONCAT(mtd
);
115 if (!(mtd
->flags
& MTD_WRITEABLE
))
120 for (i
= 0; i
< concat
->num_subdev
; i
++) {
121 struct mtd_info
*subdev
= concat
->subdev
[i
];
122 size_t size
, retsize
;
124 if (to
>= subdev
->size
) {
129 if (to
+ len
> subdev
->size
)
130 size
= subdev
->size
- to
;
134 if (!(subdev
->flags
& MTD_WRITEABLE
))
137 err
= subdev
->write(subdev
, to
, size
, &retsize
, buf
);
155 concat_writev(struct mtd_info
*mtd
, const struct kvec
*vecs
,
156 unsigned long count
, loff_t to
, size_t * retlen
)
158 struct mtd_concat
*concat
= CONCAT(mtd
);
159 struct kvec
*vecs_copy
;
160 unsigned long entry_low
, entry_high
;
161 size_t total_len
= 0;
165 if (!(mtd
->flags
& MTD_WRITEABLE
))
170 /* Calculate total length of data */
171 for (i
= 0; i
< count
; i
++)
172 total_len
+= vecs
[i
].iov_len
;
174 /* Do not allow write past end of device */
175 if ((to
+ total_len
) > mtd
->size
)
178 /* Check alignment */
179 if (mtd
->writesize
> 1) {
181 if (do_div(__to
, mtd
->writesize
) || (total_len
% mtd
->writesize
))
185 /* make a copy of vecs */
186 vecs_copy
= kmemdup(vecs
, sizeof(struct kvec
) * count
, GFP_KERNEL
);
191 for (i
= 0; i
< concat
->num_subdev
; i
++) {
192 struct mtd_info
*subdev
= concat
->subdev
[i
];
193 size_t size
, wsize
, retsize
, old_iov_len
;
195 if (to
>= subdev
->size
) {
200 size
= min_t(uint64_t, total_len
, subdev
->size
- to
);
201 wsize
= size
; /* store for future use */
203 entry_high
= entry_low
;
204 while (entry_high
< count
) {
205 if (size
<= vecs_copy
[entry_high
].iov_len
)
207 size
-= vecs_copy
[entry_high
++].iov_len
;
210 old_iov_len
= vecs_copy
[entry_high
].iov_len
;
211 vecs_copy
[entry_high
].iov_len
= size
;
213 if (!(subdev
->flags
& MTD_WRITEABLE
))
216 err
= subdev
->writev(subdev
, &vecs_copy
[entry_low
],
217 entry_high
- entry_low
+ 1, to
, &retsize
);
219 vecs_copy
[entry_high
].iov_len
= old_iov_len
- size
;
220 vecs_copy
[entry_high
].iov_base
+= size
;
222 entry_low
= entry_high
;
242 concat_read_oob(struct mtd_info
*mtd
, loff_t from
, struct mtd_oob_ops
*ops
)
244 struct mtd_concat
*concat
= CONCAT(mtd
);
245 struct mtd_oob_ops devops
= *ops
;
248 ops
->retlen
= ops
->oobretlen
= 0;
250 for (i
= 0; i
< concat
->num_subdev
; i
++) {
251 struct mtd_info
*subdev
= concat
->subdev
[i
];
253 if (from
>= subdev
->size
) {
254 from
-= subdev
->size
;
259 if (from
+ devops
.len
> subdev
->size
)
260 devops
.len
= subdev
->size
- from
;
262 err
= subdev
->read_oob(subdev
, from
, &devops
);
263 ops
->retlen
+= devops
.retlen
;
264 ops
->oobretlen
+= devops
.oobretlen
;
266 /* Save information about bitflips! */
268 if (err
== -EBADMSG
) {
269 mtd
->ecc_stats
.failed
++;
271 } else if (err
== -EUCLEAN
) {
272 mtd
->ecc_stats
.corrected
++;
273 /* Do not overwrite -EBADMSG !! */
281 devops
.len
= ops
->len
- ops
->retlen
;
284 devops
.datbuf
+= devops
.retlen
;
287 devops
.ooblen
= ops
->ooblen
- ops
->oobretlen
;
290 devops
.oobbuf
+= ops
->oobretlen
;
299 concat_write_oob(struct mtd_info
*mtd
, loff_t to
, struct mtd_oob_ops
*ops
)
301 struct mtd_concat
*concat
= CONCAT(mtd
);
302 struct mtd_oob_ops devops
= *ops
;
305 if (!(mtd
->flags
& MTD_WRITEABLE
))
310 for (i
= 0; i
< concat
->num_subdev
; i
++) {
311 struct mtd_info
*subdev
= concat
->subdev
[i
];
313 if (to
>= subdev
->size
) {
318 /* partial write ? */
319 if (to
+ devops
.len
> subdev
->size
)
320 devops
.len
= subdev
->size
- to
;
322 err
= subdev
->write_oob(subdev
, to
, &devops
);
323 ops
->retlen
+= devops
.retlen
;
328 devops
.len
= ops
->len
- ops
->retlen
;
331 devops
.datbuf
+= devops
.retlen
;
334 devops
.ooblen
= ops
->ooblen
- ops
->oobretlen
;
337 devops
.oobbuf
+= devops
.oobretlen
;
344 static void concat_erase_callback(struct erase_info
*instr
)
346 wake_up((wait_queue_head_t
*) instr
->priv
);
349 static int concat_dev_erase(struct mtd_info
*mtd
, struct erase_info
*erase
)
352 wait_queue_head_t waitq
;
353 DECLARE_WAITQUEUE(wait
, current
);
356 * This code was stol^H^H^H^Hinspired by mtdchar.c
358 init_waitqueue_head(&waitq
);
361 erase
->callback
= concat_erase_callback
;
362 erase
->priv
= (unsigned long) &waitq
;
365 * FIXME: Allow INTERRUPTIBLE. Which means
366 * not having the wait_queue head on the stack.
368 err
= mtd
->erase(mtd
, erase
);
370 set_current_state(TASK_UNINTERRUPTIBLE
);
371 add_wait_queue(&waitq
, &wait
);
372 if (erase
->state
!= MTD_ERASE_DONE
373 && erase
->state
!= MTD_ERASE_FAILED
)
375 remove_wait_queue(&waitq
, &wait
);
376 set_current_state(TASK_RUNNING
);
378 err
= (erase
->state
== MTD_ERASE_FAILED
) ? -EIO
: 0;
383 static int concat_erase(struct mtd_info
*mtd
, struct erase_info
*instr
)
385 struct mtd_concat
*concat
= CONCAT(mtd
);
386 struct mtd_info
*subdev
;
388 uint64_t length
, offset
= 0;
389 struct erase_info
*erase
;
391 if (!(mtd
->flags
& MTD_WRITEABLE
))
394 if (instr
->addr
> concat
->mtd
.size
)
397 if (instr
->len
+ instr
->addr
> concat
->mtd
.size
)
401 * Check for proper erase block alignment of the to-be-erased area.
402 * It is easier to do this based on the super device's erase
403 * region info rather than looking at each particular sub-device
406 if (!concat
->mtd
.numeraseregions
) {
407 /* the easy case: device has uniform erase block size */
408 if (instr
->addr
& (concat
->mtd
.erasesize
- 1))
410 if (instr
->len
& (concat
->mtd
.erasesize
- 1))
413 /* device has variable erase size */
414 struct mtd_erase_region_info
*erase_regions
=
415 concat
->mtd
.eraseregions
;
418 * Find the erase region where the to-be-erased area begins:
420 for (i
= 0; i
< concat
->mtd
.numeraseregions
&&
421 instr
->addr
>= erase_regions
[i
].offset
; i
++) ;
425 * Now erase_regions[i] is the region in which the
426 * to-be-erased area begins. Verify that the starting
427 * offset is aligned to this region's erase size:
429 if (i
< 0 || instr
->addr
& (erase_regions
[i
].erasesize
- 1))
433 * now find the erase region where the to-be-erased area ends:
435 for (; i
< concat
->mtd
.numeraseregions
&&
436 (instr
->addr
+ instr
->len
) >= erase_regions
[i
].offset
;
440 * check if the ending offset is aligned to this region's erase size
442 if (i
< 0 || ((instr
->addr
+ instr
->len
) &
443 (erase_regions
[i
].erasesize
- 1)))
447 instr
->fail_addr
= MTD_FAIL_ADDR_UNKNOWN
;
449 /* make a local copy of instr to avoid modifying the caller's struct */
450 erase
= kmalloc(sizeof (struct erase_info
), GFP_KERNEL
);
459 * find the subdevice where the to-be-erased area begins, adjust
460 * starting offset to be relative to the subdevice start
462 for (i
= 0; i
< concat
->num_subdev
; i
++) {
463 subdev
= concat
->subdev
[i
];
464 if (subdev
->size
<= erase
->addr
) {
465 erase
->addr
-= subdev
->size
;
466 offset
+= subdev
->size
;
472 /* must never happen since size limit has been verified above */
473 BUG_ON(i
>= concat
->num_subdev
);
475 /* now do the erase: */
477 for (; length
> 0; i
++) {
478 /* loop for all subdevices affected by this request */
479 subdev
= concat
->subdev
[i
]; /* get current subdevice */
481 /* limit length to subdevice's size: */
482 if (erase
->addr
+ length
> subdev
->size
)
483 erase
->len
= subdev
->size
- erase
->addr
;
487 if (!(subdev
->flags
& MTD_WRITEABLE
)) {
491 length
-= erase
->len
;
492 if ((err
= concat_dev_erase(subdev
, erase
))) {
493 /* sanity check: should never happen since
494 * block alignment has been checked above */
495 BUG_ON(err
== -EINVAL
);
496 if (erase
->fail_addr
!= MTD_FAIL_ADDR_UNKNOWN
)
497 instr
->fail_addr
= erase
->fail_addr
+ offset
;
501 * erase->addr specifies the offset of the area to be
502 * erased *within the current subdevice*. It can be
503 * non-zero only the first time through this loop, i.e.
504 * for the first subdevice where blocks need to be erased.
505 * All the following erases must begin at the start of the
506 * current subdevice, i.e. at offset zero.
509 offset
+= subdev
->size
;
511 instr
->state
= erase
->state
;
517 instr
->callback(instr
);
521 static int concat_lock(struct mtd_info
*mtd
, loff_t ofs
, uint64_t len
)
523 struct mtd_concat
*concat
= CONCAT(mtd
);
524 int i
, err
= -EINVAL
;
526 if ((len
+ ofs
) > mtd
->size
)
529 for (i
= 0; i
< concat
->num_subdev
; i
++) {
530 struct mtd_info
*subdev
= concat
->subdev
[i
];
533 if (ofs
>= subdev
->size
) {
538 if (ofs
+ len
> subdev
->size
)
539 size
= subdev
->size
- ofs
;
544 err
= subdev
->lock(subdev
, ofs
, size
);
561 static int concat_unlock(struct mtd_info
*mtd
, loff_t ofs
, uint64_t len
)
563 struct mtd_concat
*concat
= CONCAT(mtd
);
566 if ((len
+ ofs
) > mtd
->size
)
569 for (i
= 0; i
< concat
->num_subdev
; i
++) {
570 struct mtd_info
*subdev
= concat
->subdev
[i
];
573 if (ofs
>= subdev
->size
) {
578 if (ofs
+ len
> subdev
->size
)
579 size
= subdev
->size
- ofs
;
583 if (subdev
->unlock
) {
584 err
= subdev
->unlock(subdev
, ofs
, size
);
601 static void concat_sync(struct mtd_info
*mtd
)
603 struct mtd_concat
*concat
= CONCAT(mtd
);
606 for (i
= 0; i
< concat
->num_subdev
; i
++) {
607 struct mtd_info
*subdev
= concat
->subdev
[i
];
608 subdev
->sync(subdev
);
612 static int concat_suspend(struct mtd_info
*mtd
)
614 struct mtd_concat
*concat
= CONCAT(mtd
);
617 for (i
= 0; i
< concat
->num_subdev
; i
++) {
618 struct mtd_info
*subdev
= concat
->subdev
[i
];
619 if ((rc
= subdev
->suspend(subdev
)) < 0)
625 static void concat_resume(struct mtd_info
*mtd
)
627 struct mtd_concat
*concat
= CONCAT(mtd
);
630 for (i
= 0; i
< concat
->num_subdev
; i
++) {
631 struct mtd_info
*subdev
= concat
->subdev
[i
];
632 subdev
->resume(subdev
);
636 static int concat_block_isbad(struct mtd_info
*mtd
, loff_t ofs
)
638 struct mtd_concat
*concat
= CONCAT(mtd
);
641 if (!concat
->subdev
[0]->block_isbad
)
647 for (i
= 0; i
< concat
->num_subdev
; i
++) {
648 struct mtd_info
*subdev
= concat
->subdev
[i
];
650 if (ofs
>= subdev
->size
) {
655 res
= subdev
->block_isbad(subdev
, ofs
);
662 static int concat_block_markbad(struct mtd_info
*mtd
, loff_t ofs
)
664 struct mtd_concat
*concat
= CONCAT(mtd
);
665 int i
, err
= -EINVAL
;
667 if (!concat
->subdev
[0]->block_markbad
)
673 for (i
= 0; i
< concat
->num_subdev
; i
++) {
674 struct mtd_info
*subdev
= concat
->subdev
[i
];
676 if (ofs
>= subdev
->size
) {
681 err
= subdev
->block_markbad(subdev
, ofs
);
683 mtd
->ecc_stats
.badblocks
++;
691 * try to support NOMMU mmaps on concatenated devices
692 * - we don't support subdev spanning as we can't guarantee it'll work
694 static unsigned long concat_get_unmapped_area(struct mtd_info
*mtd
,
696 unsigned long offset
,
699 struct mtd_concat
*concat
= CONCAT(mtd
);
702 for (i
= 0; i
< concat
->num_subdev
; i
++) {
703 struct mtd_info
*subdev
= concat
->subdev
[i
];
705 if (offset
>= subdev
->size
) {
706 offset
-= subdev
->size
;
710 /* we've found the subdev over which the mapping will reside */
711 if (offset
+ len
> subdev
->size
)
712 return (unsigned long) -EINVAL
;
714 if (subdev
->get_unmapped_area
)
715 return subdev
->get_unmapped_area(subdev
, len
, offset
,
721 return (unsigned long) -ENOSYS
;
725 * This function constructs a virtual MTD device by concatenating
726 * num_devs MTD devices. A pointer to the new device object is
727 * stored to *new_dev upon success. This function does _not_
728 * register any devices: this is the caller's responsibility.
730 struct mtd_info
*mtd_concat_create(struct mtd_info
*subdev
[], /* subdevices to concatenate */
731 int num_devs
, /* number of subdevices */
733 { /* name for the new device */
736 struct mtd_concat
*concat
;
737 uint32_t max_erasesize
, curr_erasesize
;
738 int num_erase_region
;
740 printk(KERN_NOTICE
"Concatenating MTD devices:\n");
741 for (i
= 0; i
< num_devs
; i
++)
742 printk(KERN_NOTICE
"(%d): \"%s\"\n", i
, subdev
[i
]->name
);
743 printk(KERN_NOTICE
"into device \"%s\"\n", name
);
745 /* allocate the device structure */
746 size
= SIZEOF_STRUCT_MTD_CONCAT(num_devs
);
747 concat
= kzalloc(size
, GFP_KERNEL
);
750 ("memory allocation error while creating concatenated device \"%s\"\n",
754 concat
->subdev
= (struct mtd_info
**) (concat
+ 1);
757 * Set up the new "super" device's MTD object structure, check for
758 * incompatibilites between the subdevices.
760 concat
->mtd
.type
= subdev
[0]->type
;
761 concat
->mtd
.flags
= subdev
[0]->flags
;
762 concat
->mtd
.size
= subdev
[0]->size
;
763 concat
->mtd
.erasesize
= subdev
[0]->erasesize
;
764 concat
->mtd
.writesize
= subdev
[0]->writesize
;
765 concat
->mtd
.subpage_sft
= subdev
[0]->subpage_sft
;
766 concat
->mtd
.oobsize
= subdev
[0]->oobsize
;
767 concat
->mtd
.oobavail
= subdev
[0]->oobavail
;
768 if (subdev
[0]->writev
)
769 concat
->mtd
.writev
= concat_writev
;
770 if (subdev
[0]->read_oob
)
771 concat
->mtd
.read_oob
= concat_read_oob
;
772 if (subdev
[0]->write_oob
)
773 concat
->mtd
.write_oob
= concat_write_oob
;
774 if (subdev
[0]->block_isbad
)
775 concat
->mtd
.block_isbad
= concat_block_isbad
;
776 if (subdev
[0]->block_markbad
)
777 concat
->mtd
.block_markbad
= concat_block_markbad
;
779 concat
->mtd
.ecc_stats
.badblocks
= subdev
[0]->ecc_stats
.badblocks
;
781 concat
->mtd
.backing_dev_info
= subdev
[0]->backing_dev_info
;
783 concat
->subdev
[0] = subdev
[0];
785 for (i
= 1; i
< num_devs
; i
++) {
786 if (concat
->mtd
.type
!= subdev
[i
]->type
) {
788 printk("Incompatible device type on \"%s\"\n",
792 if (concat
->mtd
.flags
!= subdev
[i
]->flags
) {
794 * Expect all flags except MTD_WRITEABLE to be
795 * equal on all subdevices.
797 if ((concat
->mtd
.flags
^ subdev
[i
]->
798 flags
) & ~MTD_WRITEABLE
) {
800 printk("Incompatible device flags on \"%s\"\n",
804 /* if writeable attribute differs,
805 make super device writeable */
807 subdev
[i
]->flags
& MTD_WRITEABLE
;
810 /* only permit direct mapping if the BDIs are all the same
811 * - copy-mapping is still permitted
813 if (concat
->mtd
.backing_dev_info
!=
814 subdev
[i
]->backing_dev_info
)
815 concat
->mtd
.backing_dev_info
=
816 &default_backing_dev_info
;
818 concat
->mtd
.size
+= subdev
[i
]->size
;
819 concat
->mtd
.ecc_stats
.badblocks
+=
820 subdev
[i
]->ecc_stats
.badblocks
;
821 if (concat
->mtd
.writesize
!= subdev
[i
]->writesize
||
822 concat
->mtd
.subpage_sft
!= subdev
[i
]->subpage_sft
||
823 concat
->mtd
.oobsize
!= subdev
[i
]->oobsize
||
824 !concat
->mtd
.read_oob
!= !subdev
[i
]->read_oob
||
825 !concat
->mtd
.write_oob
!= !subdev
[i
]->write_oob
) {
827 printk("Incompatible OOB or ECC data on \"%s\"\n",
831 concat
->subdev
[i
] = subdev
[i
];
835 concat
->mtd
.ecclayout
= subdev
[0]->ecclayout
;
837 concat
->num_subdev
= num_devs
;
838 concat
->mtd
.name
= name
;
840 concat
->mtd
.erase
= concat_erase
;
841 concat
->mtd
.read
= concat_read
;
842 concat
->mtd
.write
= concat_write
;
843 concat
->mtd
.sync
= concat_sync
;
844 concat
->mtd
.lock
= concat_lock
;
845 concat
->mtd
.unlock
= concat_unlock
;
846 concat
->mtd
.suspend
= concat_suspend
;
847 concat
->mtd
.resume
= concat_resume
;
848 concat
->mtd
.get_unmapped_area
= concat_get_unmapped_area
;
851 * Combine the erase block size info of the subdevices:
853 * first, walk the map of the new device and see how
854 * many changes in erase size we have
856 max_erasesize
= curr_erasesize
= subdev
[0]->erasesize
;
857 num_erase_region
= 1;
858 for (i
= 0; i
< num_devs
; i
++) {
859 if (subdev
[i
]->numeraseregions
== 0) {
860 /* current subdevice has uniform erase size */
861 if (subdev
[i
]->erasesize
!= curr_erasesize
) {
862 /* if it differs from the last subdevice's erase size, count it */
864 curr_erasesize
= subdev
[i
]->erasesize
;
865 if (curr_erasesize
> max_erasesize
)
866 max_erasesize
= curr_erasesize
;
869 /* current subdevice has variable erase size */
871 for (j
= 0; j
< subdev
[i
]->numeraseregions
; j
++) {
873 /* walk the list of erase regions, count any changes */
874 if (subdev
[i
]->eraseregions
[j
].erasesize
!=
878 subdev
[i
]->eraseregions
[j
].
880 if (curr_erasesize
> max_erasesize
)
881 max_erasesize
= curr_erasesize
;
887 if (num_erase_region
== 1) {
889 * All subdevices have the same uniform erase size.
892 concat
->mtd
.erasesize
= curr_erasesize
;
893 concat
->mtd
.numeraseregions
= 0;
898 * erase block size varies across the subdevices: allocate
899 * space to store the data describing the variable erase regions
901 struct mtd_erase_region_info
*erase_region_p
;
902 uint64_t begin
, position
;
904 concat
->mtd
.erasesize
= max_erasesize
;
905 concat
->mtd
.numeraseregions
= num_erase_region
;
906 concat
->mtd
.eraseregions
= erase_region_p
=
907 kmalloc(num_erase_region
*
908 sizeof (struct mtd_erase_region_info
), GFP_KERNEL
);
909 if (!erase_region_p
) {
912 ("memory allocation error while creating erase region list"
913 " for device \"%s\"\n", name
);
918 * walk the map of the new device once more and fill in
919 * in erase region info:
921 curr_erasesize
= subdev
[0]->erasesize
;
922 begin
= position
= 0;
923 for (i
= 0; i
< num_devs
; i
++) {
924 if (subdev
[i
]->numeraseregions
== 0) {
925 /* current subdevice has uniform erase size */
926 if (subdev
[i
]->erasesize
!= curr_erasesize
) {
928 * fill in an mtd_erase_region_info structure for the area
929 * we have walked so far:
931 erase_region_p
->offset
= begin
;
932 erase_region_p
->erasesize
=
934 tmp64
= position
- begin
;
935 do_div(tmp64
, curr_erasesize
);
936 erase_region_p
->numblocks
= tmp64
;
939 curr_erasesize
= subdev
[i
]->erasesize
;
942 position
+= subdev
[i
]->size
;
944 /* current subdevice has variable erase size */
946 for (j
= 0; j
< subdev
[i
]->numeraseregions
; j
++) {
947 /* walk the list of erase regions, count any changes */
948 if (subdev
[i
]->eraseregions
[j
].
949 erasesize
!= curr_erasesize
) {
950 erase_region_p
->offset
= begin
;
951 erase_region_p
->erasesize
=
953 tmp64
= position
- begin
;
954 do_div(tmp64
, curr_erasesize
);
955 erase_region_p
->numblocks
= tmp64
;
959 subdev
[i
]->eraseregions
[j
].
964 subdev
[i
]->eraseregions
[j
].
965 numblocks
* (uint64_t)curr_erasesize
;
969 /* Now write the final entry */
970 erase_region_p
->offset
= begin
;
971 erase_region_p
->erasesize
= curr_erasesize
;
972 tmp64
= position
- begin
;
973 do_div(tmp64
, curr_erasesize
);
974 erase_region_p
->numblocks
= tmp64
;
981 * This function destroys an MTD object obtained from concat_mtd_devs()
984 void mtd_concat_destroy(struct mtd_info
*mtd
)
986 struct mtd_concat
*concat
= CONCAT(mtd
);
987 if (concat
->mtd
.numeraseregions
)
988 kfree(concat
->mtd
.eraseregions
);
992 EXPORT_SYMBOL(mtd_concat_create
);
993 EXPORT_SYMBOL(mtd_concat_destroy
);
995 MODULE_LICENSE("GPL");
996 MODULE_AUTHOR("Robert Kaiser <rkaiser@sysgo.de>");
997 MODULE_DESCRIPTION("Generic support for concatenating of MTD devices");
This page took 0.051991 seconds and 5 git commands to generate.