2 * MTD device concatenation layer
4 * Copyright © 2002 Robert Kaiser <rkaiser@sysgo.de>
5 * Copyright © 2002-2010 David Woodhouse <dwmw2@infradead.org>
7 * NAND support by Christian Gan <cgan@iders.ca>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/slab.h>
28 #include <linux/sched.h>
29 #include <linux/types.h>
30 #include <linux/backing-dev.h>
32 #include <linux/mtd/mtd.h>
33 #include <linux/mtd/concat.h>
35 #include <asm/div64.h>
38 * Our storage structure:
39 * Subdev points to an array of pointers to struct mtd_info objects
40 * which is allocated along with this structure
46 struct mtd_info
**subdev
;
50 * how to calculate the size required for the above structure,
51 * including the pointer array subdev points to:
53 #define SIZEOF_STRUCT_MTD_CONCAT(num_subdev) \
54 ((sizeof(struct mtd_concat) + (num_subdev) * sizeof(struct mtd_info *)))
57 * Given a pointer to the MTD object in the mtd_concat structure,
58 * we can retrieve the pointer to that structure with this macro.
60 #define CONCAT(x) ((struct mtd_concat *)(x))
63 * MTD methods which look up the relevant subdevice, translate the
64 * effective address and pass through to the subdevice.
68 concat_read(struct mtd_info
*mtd
, loff_t from
, size_t len
,
69 size_t * retlen
, u_char
* buf
)
71 struct mtd_concat
*concat
= CONCAT(mtd
);
77 for (i
= 0; i
< concat
->num_subdev
; i
++) {
78 struct mtd_info
*subdev
= concat
->subdev
[i
];
81 if (from
>= subdev
->size
) {
82 /* Not destined for this subdev */
87 if (from
+ len
> subdev
->size
)
88 /* First part goes into this subdev */
89 size
= subdev
->size
- from
;
91 /* Entire transaction goes into this subdev */
94 err
= subdev
->read(subdev
, from
, size
, &retsize
, buf
);
96 /* Save information about bitflips! */
98 if (err
== -EBADMSG
) {
99 mtd
->ecc_stats
.failed
++;
101 } else if (err
== -EUCLEAN
) {
102 mtd
->ecc_stats
.corrected
++;
103 /* Do not overwrite -EBADMSG !! */
122 concat_write(struct mtd_info
*mtd
, loff_t to
, size_t len
,
123 size_t * retlen
, const u_char
* buf
)
125 struct mtd_concat
*concat
= CONCAT(mtd
);
129 if (!(mtd
->flags
& MTD_WRITEABLE
))
134 for (i
= 0; i
< concat
->num_subdev
; i
++) {
135 struct mtd_info
*subdev
= concat
->subdev
[i
];
136 size_t size
, retsize
;
138 if (to
>= subdev
->size
) {
143 if (to
+ len
> subdev
->size
)
144 size
= subdev
->size
- to
;
148 if (!(subdev
->flags
& MTD_WRITEABLE
))
151 err
= subdev
->write(subdev
, to
, size
, &retsize
, buf
);
169 concat_writev(struct mtd_info
*mtd
, const struct kvec
*vecs
,
170 unsigned long count
, loff_t to
, size_t * retlen
)
172 struct mtd_concat
*concat
= CONCAT(mtd
);
173 struct kvec
*vecs_copy
;
174 unsigned long entry_low
, entry_high
;
175 size_t total_len
= 0;
179 if (!(mtd
->flags
& MTD_WRITEABLE
))
184 /* Calculate total length of data */
185 for (i
= 0; i
< count
; i
++)
186 total_len
+= vecs
[i
].iov_len
;
188 /* Do not allow write past end of device */
189 if ((to
+ total_len
) > mtd
->size
)
192 /* Check alignment */
193 if (mtd
->writesize
> 1) {
195 if (do_div(__to
, mtd
->writesize
) || (total_len
% mtd
->writesize
))
199 /* make a copy of vecs */
200 vecs_copy
= kmemdup(vecs
, sizeof(struct kvec
) * count
, GFP_KERNEL
);
205 for (i
= 0; i
< concat
->num_subdev
; i
++) {
206 struct mtd_info
*subdev
= concat
->subdev
[i
];
207 size_t size
, wsize
, retsize
, old_iov_len
;
209 if (to
>= subdev
->size
) {
214 size
= min_t(uint64_t, total_len
, subdev
->size
- to
);
215 wsize
= size
; /* store for future use */
217 entry_high
= entry_low
;
218 while (entry_high
< count
) {
219 if (size
<= vecs_copy
[entry_high
].iov_len
)
221 size
-= vecs_copy
[entry_high
++].iov_len
;
224 old_iov_len
= vecs_copy
[entry_high
].iov_len
;
225 vecs_copy
[entry_high
].iov_len
= size
;
227 if (!(subdev
->flags
& MTD_WRITEABLE
))
230 err
= subdev
->writev(subdev
, &vecs_copy
[entry_low
],
231 entry_high
- entry_low
+ 1, to
, &retsize
);
233 vecs_copy
[entry_high
].iov_len
= old_iov_len
- size
;
234 vecs_copy
[entry_high
].iov_base
+= size
;
236 entry_low
= entry_high
;
256 concat_read_oob(struct mtd_info
*mtd
, loff_t from
, struct mtd_oob_ops
*ops
)
258 struct mtd_concat
*concat
= CONCAT(mtd
);
259 struct mtd_oob_ops devops
= *ops
;
262 ops
->retlen
= ops
->oobretlen
= 0;
264 for (i
= 0; i
< concat
->num_subdev
; i
++) {
265 struct mtd_info
*subdev
= concat
->subdev
[i
];
267 if (from
>= subdev
->size
) {
268 from
-= subdev
->size
;
273 if (from
+ devops
.len
> subdev
->size
)
274 devops
.len
= subdev
->size
- from
;
276 err
= subdev
->read_oob(subdev
, from
, &devops
);
277 ops
->retlen
+= devops
.retlen
;
278 ops
->oobretlen
+= devops
.oobretlen
;
280 /* Save information about bitflips! */
282 if (err
== -EBADMSG
) {
283 mtd
->ecc_stats
.failed
++;
285 } else if (err
== -EUCLEAN
) {
286 mtd
->ecc_stats
.corrected
++;
287 /* Do not overwrite -EBADMSG !! */
295 devops
.len
= ops
->len
- ops
->retlen
;
298 devops
.datbuf
+= devops
.retlen
;
301 devops
.ooblen
= ops
->ooblen
- ops
->oobretlen
;
304 devops
.oobbuf
+= ops
->oobretlen
;
313 concat_write_oob(struct mtd_info
*mtd
, loff_t to
, struct mtd_oob_ops
*ops
)
315 struct mtd_concat
*concat
= CONCAT(mtd
);
316 struct mtd_oob_ops devops
= *ops
;
319 if (!(mtd
->flags
& MTD_WRITEABLE
))
324 for (i
= 0; i
< concat
->num_subdev
; i
++) {
325 struct mtd_info
*subdev
= concat
->subdev
[i
];
327 if (to
>= subdev
->size
) {
332 /* partial write ? */
333 if (to
+ devops
.len
> subdev
->size
)
334 devops
.len
= subdev
->size
- to
;
336 err
= subdev
->write_oob(subdev
, to
, &devops
);
337 ops
->retlen
+= devops
.retlen
;
342 devops
.len
= ops
->len
- ops
->retlen
;
345 devops
.datbuf
+= devops
.retlen
;
348 devops
.ooblen
= ops
->ooblen
- ops
->oobretlen
;
351 devops
.oobbuf
+= devops
.oobretlen
;
358 static void concat_erase_callback(struct erase_info
*instr
)
360 wake_up((wait_queue_head_t
*) instr
->priv
);
363 static int concat_dev_erase(struct mtd_info
*mtd
, struct erase_info
*erase
)
366 wait_queue_head_t waitq
;
367 DECLARE_WAITQUEUE(wait
, current
);
370 * This code was stol^H^H^H^Hinspired by mtdchar.c
372 init_waitqueue_head(&waitq
);
375 erase
->callback
= concat_erase_callback
;
376 erase
->priv
= (unsigned long) &waitq
;
379 * FIXME: Allow INTERRUPTIBLE. Which means
380 * not having the wait_queue head on the stack.
382 err
= mtd
->erase(mtd
, erase
);
384 set_current_state(TASK_UNINTERRUPTIBLE
);
385 add_wait_queue(&waitq
, &wait
);
386 if (erase
->state
!= MTD_ERASE_DONE
387 && erase
->state
!= MTD_ERASE_FAILED
)
389 remove_wait_queue(&waitq
, &wait
);
390 set_current_state(TASK_RUNNING
);
392 err
= (erase
->state
== MTD_ERASE_FAILED
) ? -EIO
: 0;
397 static int concat_erase(struct mtd_info
*mtd
, struct erase_info
*instr
)
399 struct mtd_concat
*concat
= CONCAT(mtd
);
400 struct mtd_info
*subdev
;
402 uint64_t length
, offset
= 0;
403 struct erase_info
*erase
;
405 if (!(mtd
->flags
& MTD_WRITEABLE
))
408 if (instr
->addr
> concat
->mtd
.size
)
411 if (instr
->len
+ instr
->addr
> concat
->mtd
.size
)
415 * Check for proper erase block alignment of the to-be-erased area.
416 * It is easier to do this based on the super device's erase
417 * region info rather than looking at each particular sub-device
420 if (!concat
->mtd
.numeraseregions
) {
421 /* the easy case: device has uniform erase block size */
422 if (instr
->addr
& (concat
->mtd
.erasesize
- 1))
424 if (instr
->len
& (concat
->mtd
.erasesize
- 1))
427 /* device has variable erase size */
428 struct mtd_erase_region_info
*erase_regions
=
429 concat
->mtd
.eraseregions
;
432 * Find the erase region where the to-be-erased area begins:
434 for (i
= 0; i
< concat
->mtd
.numeraseregions
&&
435 instr
->addr
>= erase_regions
[i
].offset
; i
++) ;
439 * Now erase_regions[i] is the region in which the
440 * to-be-erased area begins. Verify that the starting
441 * offset is aligned to this region's erase size:
443 if (i
< 0 || instr
->addr
& (erase_regions
[i
].erasesize
- 1))
447 * now find the erase region where the to-be-erased area ends:
449 for (; i
< concat
->mtd
.numeraseregions
&&
450 (instr
->addr
+ instr
->len
) >= erase_regions
[i
].offset
;
454 * check if the ending offset is aligned to this region's erase size
456 if (i
< 0 || ((instr
->addr
+ instr
->len
) &
457 (erase_regions
[i
].erasesize
- 1)))
461 instr
->fail_addr
= MTD_FAIL_ADDR_UNKNOWN
;
463 /* make a local copy of instr to avoid modifying the caller's struct */
464 erase
= kmalloc(sizeof (struct erase_info
), GFP_KERNEL
);
473 * find the subdevice where the to-be-erased area begins, adjust
474 * starting offset to be relative to the subdevice start
476 for (i
= 0; i
< concat
->num_subdev
; i
++) {
477 subdev
= concat
->subdev
[i
];
478 if (subdev
->size
<= erase
->addr
) {
479 erase
->addr
-= subdev
->size
;
480 offset
+= subdev
->size
;
486 /* must never happen since size limit has been verified above */
487 BUG_ON(i
>= concat
->num_subdev
);
489 /* now do the erase: */
491 for (; length
> 0; i
++) {
492 /* loop for all subdevices affected by this request */
493 subdev
= concat
->subdev
[i
]; /* get current subdevice */
495 /* limit length to subdevice's size: */
496 if (erase
->addr
+ length
> subdev
->size
)
497 erase
->len
= subdev
->size
- erase
->addr
;
501 if (!(subdev
->flags
& MTD_WRITEABLE
)) {
505 length
-= erase
->len
;
506 if ((err
= concat_dev_erase(subdev
, erase
))) {
507 /* sanity check: should never happen since
508 * block alignment has been checked above */
509 BUG_ON(err
== -EINVAL
);
510 if (erase
->fail_addr
!= MTD_FAIL_ADDR_UNKNOWN
)
511 instr
->fail_addr
= erase
->fail_addr
+ offset
;
515 * erase->addr specifies the offset of the area to be
516 * erased *within the current subdevice*. It can be
517 * non-zero only the first time through this loop, i.e.
518 * for the first subdevice where blocks need to be erased.
519 * All the following erases must begin at the start of the
520 * current subdevice, i.e. at offset zero.
523 offset
+= subdev
->size
;
525 instr
->state
= erase
->state
;
531 instr
->callback(instr
);
535 static int concat_lock(struct mtd_info
*mtd
, loff_t ofs
, uint64_t len
)
537 struct mtd_concat
*concat
= CONCAT(mtd
);
538 int i
, err
= -EINVAL
;
540 if ((len
+ ofs
) > mtd
->size
)
543 for (i
= 0; i
< concat
->num_subdev
; i
++) {
544 struct mtd_info
*subdev
= concat
->subdev
[i
];
547 if (ofs
>= subdev
->size
) {
552 if (ofs
+ len
> subdev
->size
)
553 size
= subdev
->size
- ofs
;
558 err
= subdev
->lock(subdev
, ofs
, size
);
575 static int concat_unlock(struct mtd_info
*mtd
, loff_t ofs
, uint64_t len
)
577 struct mtd_concat
*concat
= CONCAT(mtd
);
580 if ((len
+ ofs
) > mtd
->size
)
583 for (i
= 0; i
< concat
->num_subdev
; i
++) {
584 struct mtd_info
*subdev
= concat
->subdev
[i
];
587 if (ofs
>= subdev
->size
) {
592 if (ofs
+ len
> subdev
->size
)
593 size
= subdev
->size
- ofs
;
597 if (subdev
->unlock
) {
598 err
= subdev
->unlock(subdev
, ofs
, size
);
615 static void concat_sync(struct mtd_info
*mtd
)
617 struct mtd_concat
*concat
= CONCAT(mtd
);
620 for (i
= 0; i
< concat
->num_subdev
; i
++) {
621 struct mtd_info
*subdev
= concat
->subdev
[i
];
622 subdev
->sync(subdev
);
626 static int concat_suspend(struct mtd_info
*mtd
)
628 struct mtd_concat
*concat
= CONCAT(mtd
);
631 for (i
= 0; i
< concat
->num_subdev
; i
++) {
632 struct mtd_info
*subdev
= concat
->subdev
[i
];
633 if ((rc
= subdev
->suspend(subdev
)) < 0)
639 static void concat_resume(struct mtd_info
*mtd
)
641 struct mtd_concat
*concat
= CONCAT(mtd
);
644 for (i
= 0; i
< concat
->num_subdev
; i
++) {
645 struct mtd_info
*subdev
= concat
->subdev
[i
];
646 subdev
->resume(subdev
);
650 static int concat_block_isbad(struct mtd_info
*mtd
, loff_t ofs
)
652 struct mtd_concat
*concat
= CONCAT(mtd
);
655 if (!concat
->subdev
[0]->block_isbad
)
661 for (i
= 0; i
< concat
->num_subdev
; i
++) {
662 struct mtd_info
*subdev
= concat
->subdev
[i
];
664 if (ofs
>= subdev
->size
) {
669 res
= subdev
->block_isbad(subdev
, ofs
);
676 static int concat_block_markbad(struct mtd_info
*mtd
, loff_t ofs
)
678 struct mtd_concat
*concat
= CONCAT(mtd
);
679 int i
, err
= -EINVAL
;
681 if (!concat
->subdev
[0]->block_markbad
)
687 for (i
= 0; i
< concat
->num_subdev
; i
++) {
688 struct mtd_info
*subdev
= concat
->subdev
[i
];
690 if (ofs
>= subdev
->size
) {
695 err
= subdev
->block_markbad(subdev
, ofs
);
697 mtd
->ecc_stats
.badblocks
++;
705 * try to support NOMMU mmaps on concatenated devices
706 * - we don't support subdev spanning as we can't guarantee it'll work
708 static unsigned long concat_get_unmapped_area(struct mtd_info
*mtd
,
710 unsigned long offset
,
713 struct mtd_concat
*concat
= CONCAT(mtd
);
716 for (i
= 0; i
< concat
->num_subdev
; i
++) {
717 struct mtd_info
*subdev
= concat
->subdev
[i
];
719 if (offset
>= subdev
->size
) {
720 offset
-= subdev
->size
;
724 /* we've found the subdev over which the mapping will reside */
725 if (offset
+ len
> subdev
->size
)
726 return (unsigned long) -EINVAL
;
728 if (subdev
->get_unmapped_area
)
729 return subdev
->get_unmapped_area(subdev
, len
, offset
,
735 return (unsigned long) -ENOSYS
;
739 * This function constructs a virtual MTD device by concatenating
740 * num_devs MTD devices. A pointer to the new device object is
741 * stored to *new_dev upon success. This function does _not_
742 * register any devices: this is the caller's responsibility.
744 struct mtd_info
*mtd_concat_create(struct mtd_info
*subdev
[], /* subdevices to concatenate */
745 int num_devs
, /* number of subdevices */
747 { /* name for the new device */
750 struct mtd_concat
*concat
;
751 uint32_t max_erasesize
, curr_erasesize
;
752 int num_erase_region
;
754 printk(KERN_NOTICE
"Concatenating MTD devices:\n");
755 for (i
= 0; i
< num_devs
; i
++)
756 printk(KERN_NOTICE
"(%d): \"%s\"\n", i
, subdev
[i
]->name
);
757 printk(KERN_NOTICE
"into device \"%s\"\n", name
);
759 /* allocate the device structure */
760 size
= SIZEOF_STRUCT_MTD_CONCAT(num_devs
);
761 concat
= kzalloc(size
, GFP_KERNEL
);
764 ("memory allocation error while creating concatenated device \"%s\"\n",
768 concat
->subdev
= (struct mtd_info
**) (concat
+ 1);
771 * Set up the new "super" device's MTD object structure, check for
772 * incompatibilites between the subdevices.
774 concat
->mtd
.type
= subdev
[0]->type
;
775 concat
->mtd
.flags
= subdev
[0]->flags
;
776 concat
->mtd
.size
= subdev
[0]->size
;
777 concat
->mtd
.erasesize
= subdev
[0]->erasesize
;
778 concat
->mtd
.writesize
= subdev
[0]->writesize
;
779 concat
->mtd
.subpage_sft
= subdev
[0]->subpage_sft
;
780 concat
->mtd
.oobsize
= subdev
[0]->oobsize
;
781 concat
->mtd
.oobavail
= subdev
[0]->oobavail
;
782 if (subdev
[0]->writev
)
783 concat
->mtd
.writev
= concat_writev
;
784 if (subdev
[0]->read_oob
)
785 concat
->mtd
.read_oob
= concat_read_oob
;
786 if (subdev
[0]->write_oob
)
787 concat
->mtd
.write_oob
= concat_write_oob
;
788 if (subdev
[0]->block_isbad
)
789 concat
->mtd
.block_isbad
= concat_block_isbad
;
790 if (subdev
[0]->block_markbad
)
791 concat
->mtd
.block_markbad
= concat_block_markbad
;
793 concat
->mtd
.ecc_stats
.badblocks
= subdev
[0]->ecc_stats
.badblocks
;
795 concat
->mtd
.backing_dev_info
= subdev
[0]->backing_dev_info
;
797 concat
->subdev
[0] = subdev
[0];
799 for (i
= 1; i
< num_devs
; i
++) {
800 if (concat
->mtd
.type
!= subdev
[i
]->type
) {
802 printk("Incompatible device type on \"%s\"\n",
806 if (concat
->mtd
.flags
!= subdev
[i
]->flags
) {
808 * Expect all flags except MTD_WRITEABLE to be
809 * equal on all subdevices.
811 if ((concat
->mtd
.flags
^ subdev
[i
]->
812 flags
) & ~MTD_WRITEABLE
) {
814 printk("Incompatible device flags on \"%s\"\n",
818 /* if writeable attribute differs,
819 make super device writeable */
821 subdev
[i
]->flags
& MTD_WRITEABLE
;
824 /* only permit direct mapping if the BDIs are all the same
825 * - copy-mapping is still permitted
827 if (concat
->mtd
.backing_dev_info
!=
828 subdev
[i
]->backing_dev_info
)
829 concat
->mtd
.backing_dev_info
=
830 &default_backing_dev_info
;
832 concat
->mtd
.size
+= subdev
[i
]->size
;
833 concat
->mtd
.ecc_stats
.badblocks
+=
834 subdev
[i
]->ecc_stats
.badblocks
;
835 if (concat
->mtd
.writesize
!= subdev
[i
]->writesize
||
836 concat
->mtd
.subpage_sft
!= subdev
[i
]->subpage_sft
||
837 concat
->mtd
.oobsize
!= subdev
[i
]->oobsize
||
838 !concat
->mtd
.read_oob
!= !subdev
[i
]->read_oob
||
839 !concat
->mtd
.write_oob
!= !subdev
[i
]->write_oob
) {
841 printk("Incompatible OOB or ECC data on \"%s\"\n",
845 concat
->subdev
[i
] = subdev
[i
];
849 concat
->mtd
.ecclayout
= subdev
[0]->ecclayout
;
851 concat
->num_subdev
= num_devs
;
852 concat
->mtd
.name
= name
;
854 concat
->mtd
.erase
= concat_erase
;
855 concat
->mtd
.read
= concat_read
;
856 concat
->mtd
.write
= concat_write
;
857 concat
->mtd
.sync
= concat_sync
;
858 concat
->mtd
.lock
= concat_lock
;
859 concat
->mtd
.unlock
= concat_unlock
;
860 concat
->mtd
.suspend
= concat_suspend
;
861 concat
->mtd
.resume
= concat_resume
;
862 concat
->mtd
.get_unmapped_area
= concat_get_unmapped_area
;
865 * Combine the erase block size info of the subdevices:
867 * first, walk the map of the new device and see how
868 * many changes in erase size we have
870 max_erasesize
= curr_erasesize
= subdev
[0]->erasesize
;
871 num_erase_region
= 1;
872 for (i
= 0; i
< num_devs
; i
++) {
873 if (subdev
[i
]->numeraseregions
== 0) {
874 /* current subdevice has uniform erase size */
875 if (subdev
[i
]->erasesize
!= curr_erasesize
) {
876 /* if it differs from the last subdevice's erase size, count it */
878 curr_erasesize
= subdev
[i
]->erasesize
;
879 if (curr_erasesize
> max_erasesize
)
880 max_erasesize
= curr_erasesize
;
883 /* current subdevice has variable erase size */
885 for (j
= 0; j
< subdev
[i
]->numeraseregions
; j
++) {
887 /* walk the list of erase regions, count any changes */
888 if (subdev
[i
]->eraseregions
[j
].erasesize
!=
892 subdev
[i
]->eraseregions
[j
].
894 if (curr_erasesize
> max_erasesize
)
895 max_erasesize
= curr_erasesize
;
901 if (num_erase_region
== 1) {
903 * All subdevices have the same uniform erase size.
906 concat
->mtd
.erasesize
= curr_erasesize
;
907 concat
->mtd
.numeraseregions
= 0;
912 * erase block size varies across the subdevices: allocate
913 * space to store the data describing the variable erase regions
915 struct mtd_erase_region_info
*erase_region_p
;
916 uint64_t begin
, position
;
918 concat
->mtd
.erasesize
= max_erasesize
;
919 concat
->mtd
.numeraseregions
= num_erase_region
;
920 concat
->mtd
.eraseregions
= erase_region_p
=
921 kmalloc(num_erase_region
*
922 sizeof (struct mtd_erase_region_info
), GFP_KERNEL
);
923 if (!erase_region_p
) {
926 ("memory allocation error while creating erase region list"
927 " for device \"%s\"\n", name
);
932 * walk the map of the new device once more and fill in
933 * in erase region info:
935 curr_erasesize
= subdev
[0]->erasesize
;
936 begin
= position
= 0;
937 for (i
= 0; i
< num_devs
; i
++) {
938 if (subdev
[i
]->numeraseregions
== 0) {
939 /* current subdevice has uniform erase size */
940 if (subdev
[i
]->erasesize
!= curr_erasesize
) {
942 * fill in an mtd_erase_region_info structure for the area
943 * we have walked so far:
945 erase_region_p
->offset
= begin
;
946 erase_region_p
->erasesize
=
948 tmp64
= position
- begin
;
949 do_div(tmp64
, curr_erasesize
);
950 erase_region_p
->numblocks
= tmp64
;
953 curr_erasesize
= subdev
[i
]->erasesize
;
956 position
+= subdev
[i
]->size
;
958 /* current subdevice has variable erase size */
960 for (j
= 0; j
< subdev
[i
]->numeraseregions
; j
++) {
961 /* walk the list of erase regions, count any changes */
962 if (subdev
[i
]->eraseregions
[j
].
963 erasesize
!= curr_erasesize
) {
964 erase_region_p
->offset
= begin
;
965 erase_region_p
->erasesize
=
967 tmp64
= position
- begin
;
968 do_div(tmp64
, curr_erasesize
);
969 erase_region_p
->numblocks
= tmp64
;
973 subdev
[i
]->eraseregions
[j
].
978 subdev
[i
]->eraseregions
[j
].
979 numblocks
* (uint64_t)curr_erasesize
;
983 /* Now write the final entry */
984 erase_region_p
->offset
= begin
;
985 erase_region_p
->erasesize
= curr_erasesize
;
986 tmp64
= position
- begin
;
987 do_div(tmp64
, curr_erasesize
);
988 erase_region_p
->numblocks
= tmp64
;
995 * This function destroys an MTD object obtained from concat_mtd_devs()
998 void mtd_concat_destroy(struct mtd_info
*mtd
)
1000 struct mtd_concat
*concat
= CONCAT(mtd
);
1001 if (concat
->mtd
.numeraseregions
)
1002 kfree(concat
->mtd
.eraseregions
);
1006 EXPORT_SYMBOL(mtd_concat_create
);
1007 EXPORT_SYMBOL(mtd_concat_destroy
);
1009 MODULE_LICENSE("GPL");
1010 MODULE_AUTHOR("Robert Kaiser <rkaiser@sysgo.de>");
1011 MODULE_DESCRIPTION("Generic support for concatenating of MTD devices");
This page took 0.051707 seconds and 5 git commands to generate.