1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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>
31
32#include <linux/mtd/mtd.h>
33#include <linux/mtd/concat.h>
34
35#include <asm/div64.h>
36
37
38
39
40
41
42
43struct mtd_concat {
44 struct mtd_info mtd;
45 int num_subdev;
46 struct mtd_info **subdev;
47};
48
49
50
51
52
53#define SIZEOF_STRUCT_MTD_CONCAT(num_subdev) \
54 ((sizeof(struct mtd_concat) + (num_subdev) * sizeof(struct mtd_info *)))
55
56
57
58
59
60#define CONCAT(x) ((struct mtd_concat *)(x))
61
62
63
64
65
66
67static int
68concat_read(struct mtd_info *mtd, loff_t from, size_t len,
69 size_t * retlen, u_char * buf)
70{
71 struct mtd_concat *concat = CONCAT(mtd);
72 int ret = 0, err;
73 int i;
74
75 for (i = 0; i < concat->num_subdev; i++) {
76 struct mtd_info *subdev = concat->subdev[i];
77 size_t size, retsize;
78
79 if (from >= subdev->size) {
80
81 size = 0;
82 from -= subdev->size;
83 continue;
84 }
85 if (from + len > subdev->size)
86
87 size = subdev->size - from;
88 else
89
90 size = len;
91
92 err = mtd_read(subdev, from, size, &retsize, buf);
93
94
95 if (unlikely(err)) {
96 if (mtd_is_eccerr(err)) {
97 mtd->ecc_stats.failed++;
98 ret = err;
99 } else if (mtd_is_bitflip(err)) {
100 mtd->ecc_stats.corrected++;
101
102 if (!ret)
103 ret = err;
104 } else
105 return err;
106 }
107
108 *retlen += retsize;
109 len -= size;
110 if (len == 0)
111 return ret;
112
113 buf += size;
114 from = 0;
115 }
116 return -EINVAL;
117}
118
119static int
120concat_write(struct mtd_info *mtd, loff_t to, size_t len,
121 size_t * retlen, const u_char * buf)
122{
123 struct mtd_concat *concat = CONCAT(mtd);
124 int err = -EINVAL;
125 int i;
126
127 for (i = 0; i < concat->num_subdev; i++) {
128 struct mtd_info *subdev = concat->subdev[i];
129 size_t size, retsize;
130
131 if (to >= subdev->size) {
132 size = 0;
133 to -= subdev->size;
134 continue;
135 }
136 if (to + len > subdev->size)
137 size = subdev->size - to;
138 else
139 size = len;
140
141 err = mtd_write(subdev, to, size, &retsize, buf);
142 if (err)
143 break;
144
145 *retlen += retsize;
146 len -= size;
147 if (len == 0)
148 break;
149
150 err = -EINVAL;
151 buf += size;
152 to = 0;
153 }
154 return err;
155}
156
157static int
158concat_writev(struct mtd_info *mtd, const struct kvec *vecs,
159 unsigned long count, loff_t to, size_t * retlen)
160{
161 struct mtd_concat *concat = CONCAT(mtd);
162 struct kvec *vecs_copy;
163 unsigned long entry_low, entry_high;
164 size_t total_len = 0;
165 int i;
166 int err = -EINVAL;
167
168
169 for (i = 0; i < count; i++)
170 total_len += vecs[i].iov_len;
171
172
173 if (mtd->writesize > 1) {
174 uint64_t __to = to;
175 if (do_div(__to, mtd->writesize) || (total_len % mtd->writesize))
176 return -EINVAL;
177 }
178
179
180 vecs_copy = kmemdup(vecs, sizeof(struct kvec) * count, GFP_KERNEL);
181 if (!vecs_copy)
182 return -ENOMEM;
183
184 entry_low = 0;
185 for (i = 0; i < concat->num_subdev; i++) {
186 struct mtd_info *subdev = concat->subdev[i];
187 size_t size, wsize, retsize, old_iov_len;
188
189 if (to >= subdev->size) {
190 to -= subdev->size;
191 continue;
192 }
193
194 size = min_t(uint64_t, total_len, subdev->size - to);
195 wsize = size;
196
197 entry_high = entry_low;
198 while (entry_high < count) {
199 if (size <= vecs_copy[entry_high].iov_len)
200 break;
201 size -= vecs_copy[entry_high++].iov_len;
202 }
203
204 old_iov_len = vecs_copy[entry_high].iov_len;
205 vecs_copy[entry_high].iov_len = size;
206
207 err = mtd_writev(subdev, &vecs_copy[entry_low],
208 entry_high - entry_low + 1, to, &retsize);
209
210 vecs_copy[entry_high].iov_len = old_iov_len - size;
211 vecs_copy[entry_high].iov_base += size;
212
213 entry_low = entry_high;
214
215 if (err)
216 break;
217
218 *retlen += retsize;
219 total_len -= wsize;
220
221 if (total_len == 0)
222 break;
223
224 err = -EINVAL;
225 to = 0;
226 }
227
228 kfree(vecs_copy);
229 return err;
230}
231
232static int
233concat_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops)
234{
235 struct mtd_concat *concat = CONCAT(mtd);
236 struct mtd_oob_ops devops = *ops;
237 int i, err, ret = 0;
238
239 ops->retlen = ops->oobretlen = 0;
240
241 for (i = 0; i < concat->num_subdev; i++) {
242 struct mtd_info *subdev = concat->subdev[i];
243
244 if (from >= subdev->size) {
245 from -= subdev->size;
246 continue;
247 }
248
249
250 if (from + devops.len > subdev->size)
251 devops.len = subdev->size - from;
252
253 err = mtd_read_oob(subdev, from, &devops);
254 ops->retlen += devops.retlen;
255 ops->oobretlen += devops.oobretlen;
256
257
258 if (unlikely(err)) {
259 if (mtd_is_eccerr(err)) {
260 mtd->ecc_stats.failed++;
261 ret = err;
262 } else if (mtd_is_bitflip(err)) {
263 mtd->ecc_stats.corrected++;
264
265 if (!ret)
266 ret = err;
267 } else
268 return err;
269 }
270
271 if (devops.datbuf) {
272 devops.len = ops->len - ops->retlen;
273 if (!devops.len)
274 return ret;
275 devops.datbuf += devops.retlen;
276 }
277 if (devops.oobbuf) {
278 devops.ooblen = ops->ooblen - ops->oobretlen;
279 if (!devops.ooblen)
280 return ret;
281 devops.oobbuf += ops->oobretlen;
282 }
283
284 from = 0;
285 }
286 return -EINVAL;
287}
288
289static int
290concat_write_oob(struct mtd_info *mtd, loff_t to, struct mtd_oob_ops *ops)
291{
292 struct mtd_concat *concat = CONCAT(mtd);
293 struct mtd_oob_ops devops = *ops;
294 int i, err;
295
296 if (!(mtd->flags & MTD_WRITEABLE))
297 return -EROFS;
298
299 ops->retlen = ops->oobretlen = 0;
300
301 for (i = 0; i < concat->num_subdev; i++) {
302 struct mtd_info *subdev = concat->subdev[i];
303
304 if (to >= subdev->size) {
305 to -= subdev->size;
306 continue;
307 }
308
309
310 if (to + devops.len > subdev->size)
311 devops.len = subdev->size - to;
312
313 err = mtd_write_oob(subdev, to, &devops);
314 ops->retlen += devops.retlen;
315 ops->oobretlen += devops.oobretlen;
316 if (err)
317 return err;
318
319 if (devops.datbuf) {
320 devops.len = ops->len - ops->retlen;
321 if (!devops.len)
322 return 0;
323 devops.datbuf += devops.retlen;
324 }
325 if (devops.oobbuf) {
326 devops.ooblen = ops->ooblen - ops->oobretlen;
327 if (!devops.ooblen)
328 return 0;
329 devops.oobbuf += devops.oobretlen;
330 }
331 to = 0;
332 }
333 return -EINVAL;
334}
335
336static int concat_erase(struct mtd_info *mtd, struct erase_info *instr)
337{
338 struct mtd_concat *concat = CONCAT(mtd);
339 struct mtd_info *subdev;
340 int i, err;
341 uint64_t length, offset = 0;
342 struct erase_info *erase;
343
344
345
346
347
348
349
350 if (!concat->mtd.numeraseregions) {
351
352 if (instr->addr & (concat->mtd.erasesize - 1))
353 return -EINVAL;
354 if (instr->len & (concat->mtd.erasesize - 1))
355 return -EINVAL;
356 } else {
357
358 struct mtd_erase_region_info *erase_regions =
359 concat->mtd.eraseregions;
360
361
362
363
364 for (i = 0; i < concat->mtd.numeraseregions &&
365 instr->addr >= erase_regions[i].offset; i++) ;
366 --i;
367
368
369
370
371
372
373 if (i < 0 || instr->addr & (erase_regions[i].erasesize - 1))
374 return -EINVAL;
375
376
377
378
379 for (; i < concat->mtd.numeraseregions &&
380 (instr->addr + instr->len) >= erase_regions[i].offset;
381 ++i) ;
382 --i;
383
384
385
386 if (i < 0 || ((instr->addr + instr->len) &
387 (erase_regions[i].erasesize - 1)))
388 return -EINVAL;
389 }
390
391
392 erase = kmalloc(sizeof (struct erase_info), GFP_KERNEL);
393
394 if (!erase)
395 return -ENOMEM;
396
397 *erase = *instr;
398 length = instr->len;
399
400
401
402
403
404 for (i = 0; i < concat->num_subdev; i++) {
405 subdev = concat->subdev[i];
406 if (subdev->size <= erase->addr) {
407 erase->addr -= subdev->size;
408 offset += subdev->size;
409 } else {
410 break;
411 }
412 }
413
414
415 BUG_ON(i >= concat->num_subdev);
416
417
418 err = 0;
419 for (; length > 0; i++) {
420
421 subdev = concat->subdev[i];
422
423
424 if (erase->addr + length > subdev->size)
425 erase->len = subdev->size - erase->addr;
426 else
427 erase->len = length;
428
429 length -= erase->len;
430 if ((err = mtd_erase(subdev, erase))) {
431
432
433 BUG_ON(err == -EINVAL);
434 if (erase->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
435 instr->fail_addr = erase->fail_addr + offset;
436 break;
437 }
438
439
440
441
442
443
444
445
446 erase->addr = 0;
447 offset += subdev->size;
448 }
449 kfree(erase);
450
451 return err;
452}
453
454static int concat_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
455{
456 struct mtd_concat *concat = CONCAT(mtd);
457 int i, err = -EINVAL;
458
459 for (i = 0; i < concat->num_subdev; i++) {
460 struct mtd_info *subdev = concat->subdev[i];
461 uint64_t size;
462
463 if (ofs >= subdev->size) {
464 size = 0;
465 ofs -= subdev->size;
466 continue;
467 }
468 if (ofs + len > subdev->size)
469 size = subdev->size - ofs;
470 else
471 size = len;
472
473 err = mtd_lock(subdev, ofs, size);
474 if (err)
475 break;
476
477 len -= size;
478 if (len == 0)
479 break;
480
481 err = -EINVAL;
482 ofs = 0;
483 }
484
485 return err;
486}
487
488static int concat_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
489{
490 struct mtd_concat *concat = CONCAT(mtd);
491 int i, err = 0;
492
493 for (i = 0; i < concat->num_subdev; i++) {
494 struct mtd_info *subdev = concat->subdev[i];
495 uint64_t size;
496
497 if (ofs >= subdev->size) {
498 size = 0;
499 ofs -= subdev->size;
500 continue;
501 }
502 if (ofs + len > subdev->size)
503 size = subdev->size - ofs;
504 else
505 size = len;
506
507 err = mtd_unlock(subdev, ofs, size);
508 if (err)
509 break;
510
511 len -= size;
512 if (len == 0)
513 break;
514
515 err = -EINVAL;
516 ofs = 0;
517 }
518
519 return err;
520}
521
522static void concat_sync(struct mtd_info *mtd)
523{
524 struct mtd_concat *concat = CONCAT(mtd);
525 int i;
526
527 for (i = 0; i < concat->num_subdev; i++) {
528 struct mtd_info *subdev = concat->subdev[i];
529 mtd_sync(subdev);
530 }
531}
532
533static int concat_suspend(struct mtd_info *mtd)
534{
535 struct mtd_concat *concat = CONCAT(mtd);
536 int i, rc = 0;
537
538 for (i = 0; i < concat->num_subdev; i++) {
539 struct mtd_info *subdev = concat->subdev[i];
540 if ((rc = mtd_suspend(subdev)) < 0)
541 return rc;
542 }
543 return rc;
544}
545
546static void concat_resume(struct mtd_info *mtd)
547{
548 struct mtd_concat *concat = CONCAT(mtd);
549 int i;
550
551 for (i = 0; i < concat->num_subdev; i++) {
552 struct mtd_info *subdev = concat->subdev[i];
553 mtd_resume(subdev);
554 }
555}
556
557static int concat_block_isbad(struct mtd_info *mtd, loff_t ofs)
558{
559 struct mtd_concat *concat = CONCAT(mtd);
560 int i, res = 0;
561
562 if (!mtd_can_have_bb(concat->subdev[0]))
563 return res;
564
565 for (i = 0; i < concat->num_subdev; i++) {
566 struct mtd_info *subdev = concat->subdev[i];
567
568 if (ofs >= subdev->size) {
569 ofs -= subdev->size;
570 continue;
571 }
572
573 res = mtd_block_isbad(subdev, ofs);
574 break;
575 }
576
577 return res;
578}
579
580static int concat_block_markbad(struct mtd_info *mtd, loff_t ofs)
581{
582 struct mtd_concat *concat = CONCAT(mtd);
583 int i, err = -EINVAL;
584
585 for (i = 0; i < concat->num_subdev; i++) {
586 struct mtd_info *subdev = concat->subdev[i];
587
588 if (ofs >= subdev->size) {
589 ofs -= subdev->size;
590 continue;
591 }
592
593 err = mtd_block_markbad(subdev, ofs);
594 if (!err)
595 mtd->ecc_stats.badblocks++;
596 break;
597 }
598
599 return err;
600}
601
602
603
604
605
606
607
608struct mtd_info *mtd_concat_create(struct mtd_info *subdev[],
609 int num_devs,
610 const char *name)
611{
612 int i;
613 size_t size;
614 struct mtd_concat *concat;
615 uint32_t max_erasesize, curr_erasesize;
616 int num_erase_region;
617 int max_writebufsize = 0;
618
619 printk(KERN_NOTICE "Concatenating MTD devices:\n");
620 for (i = 0; i < num_devs; i++)
621 printk(KERN_NOTICE "(%d): \"%s\"\n", i, subdev[i]->name);
622 printk(KERN_NOTICE "into device \"%s\"\n", name);
623
624
625 size = SIZEOF_STRUCT_MTD_CONCAT(num_devs);
626 concat = kzalloc(size, GFP_KERNEL);
627 if (!concat) {
628 printk
629 ("memory allocation error while creating concatenated device \"%s\"\n",
630 name);
631 return NULL;
632 }
633 concat->subdev = (struct mtd_info **) (concat + 1);
634
635
636
637
638
639 concat->mtd.type = subdev[0]->type;
640 concat->mtd.flags = subdev[0]->flags;
641 concat->mtd.size = subdev[0]->size;
642 concat->mtd.erasesize = subdev[0]->erasesize;
643 concat->mtd.writesize = subdev[0]->writesize;
644
645 for (i = 0; i < num_devs; i++)
646 if (max_writebufsize < subdev[i]->writebufsize)
647 max_writebufsize = subdev[i]->writebufsize;
648 concat->mtd.writebufsize = max_writebufsize;
649
650 concat->mtd.subpage_sft = subdev[0]->subpage_sft;
651 concat->mtd.oobsize = subdev[0]->oobsize;
652 concat->mtd.oobavail = subdev[0]->oobavail;
653 if (subdev[0]->_writev)
654 concat->mtd._writev = concat_writev;
655 if (subdev[0]->_read_oob)
656 concat->mtd._read_oob = concat_read_oob;
657 if (subdev[0]->_write_oob)
658 concat->mtd._write_oob = concat_write_oob;
659 if (subdev[0]->_block_isbad)
660 concat->mtd._block_isbad = concat_block_isbad;
661 if (subdev[0]->_block_markbad)
662 concat->mtd._block_markbad = concat_block_markbad;
663
664 concat->mtd.ecc_stats.badblocks = subdev[0]->ecc_stats.badblocks;
665
666 concat->subdev[0] = subdev[0];
667
668 for (i = 1; i < num_devs; i++) {
669 if (concat->mtd.type != subdev[i]->type) {
670 kfree(concat);
671 printk("Incompatible device type on \"%s\"\n",
672 subdev[i]->name);
673 return NULL;
674 }
675 if (concat->mtd.flags != subdev[i]->flags) {
676
677
678
679
680 if ((concat->mtd.flags ^ subdev[i]->
681 flags) & ~MTD_WRITEABLE) {
682 kfree(concat);
683 printk("Incompatible device flags on \"%s\"\n",
684 subdev[i]->name);
685 return NULL;
686 } else
687
688
689 concat->mtd.flags |=
690 subdev[i]->flags & MTD_WRITEABLE;
691 }
692
693 concat->mtd.size += subdev[i]->size;
694 concat->mtd.ecc_stats.badblocks +=
695 subdev[i]->ecc_stats.badblocks;
696 if (concat->mtd.writesize != subdev[i]->writesize ||
697 concat->mtd.subpage_sft != subdev[i]->subpage_sft ||
698 concat->mtd.oobsize != subdev[i]->oobsize ||
699 !concat->mtd._read_oob != !subdev[i]->_read_oob ||
700 !concat->mtd._write_oob != !subdev[i]->_write_oob) {
701 kfree(concat);
702 printk("Incompatible OOB or ECC data on \"%s\"\n",
703 subdev[i]->name);
704 return NULL;
705 }
706 concat->subdev[i] = subdev[i];
707
708 }
709
710 mtd_set_ooblayout(&concat->mtd, subdev[0]->ooblayout);
711
712 concat->num_subdev = num_devs;
713 concat->mtd.name = name;
714
715 concat->mtd._erase = concat_erase;
716 concat->mtd._read = concat_read;
717 concat->mtd._write = concat_write;
718 concat->mtd._sync = concat_sync;
719 concat->mtd._lock = concat_lock;
720 concat->mtd._unlock = concat_unlock;
721 concat->mtd._suspend = concat_suspend;
722 concat->mtd._resume = concat_resume;
723
724
725
726
727
728
729
730 max_erasesize = curr_erasesize = subdev[0]->erasesize;
731 num_erase_region = 1;
732 for (i = 0; i < num_devs; i++) {
733 if (subdev[i]->numeraseregions == 0) {
734
735 if (subdev[i]->erasesize != curr_erasesize) {
736
737 ++num_erase_region;
738 curr_erasesize = subdev[i]->erasesize;
739 if (curr_erasesize > max_erasesize)
740 max_erasesize = curr_erasesize;
741 }
742 } else {
743
744 int j;
745 for (j = 0; j < subdev[i]->numeraseregions; j++) {
746
747
748 if (subdev[i]->eraseregions[j].erasesize !=
749 curr_erasesize) {
750 ++num_erase_region;
751 curr_erasesize =
752 subdev[i]->eraseregions[j].
753 erasesize;
754 if (curr_erasesize > max_erasesize)
755 max_erasesize = curr_erasesize;
756 }
757 }
758 }
759 }
760
761 if (num_erase_region == 1) {
762
763
764
765
766 concat->mtd.erasesize = curr_erasesize;
767 concat->mtd.numeraseregions = 0;
768 } else {
769 uint64_t tmp64;
770
771
772
773
774
775 struct mtd_erase_region_info *erase_region_p;
776 uint64_t begin, position;
777
778 concat->mtd.erasesize = max_erasesize;
779 concat->mtd.numeraseregions = num_erase_region;
780 concat->mtd.eraseregions = erase_region_p =
781 kmalloc(num_erase_region *
782 sizeof (struct mtd_erase_region_info), GFP_KERNEL);
783 if (!erase_region_p) {
784 kfree(concat);
785 printk
786 ("memory allocation error while creating erase region list"
787 " for device \"%s\"\n", name);
788 return NULL;
789 }
790
791
792
793
794
795 curr_erasesize = subdev[0]->erasesize;
796 begin = position = 0;
797 for (i = 0; i < num_devs; i++) {
798 if (subdev[i]->numeraseregions == 0) {
799
800 if (subdev[i]->erasesize != curr_erasesize) {
801
802
803
804
805 erase_region_p->offset = begin;
806 erase_region_p->erasesize =
807 curr_erasesize;
808 tmp64 = position - begin;
809 do_div(tmp64, curr_erasesize);
810 erase_region_p->numblocks = tmp64;
811 begin = position;
812
813 curr_erasesize = subdev[i]->erasesize;
814 ++erase_region_p;
815 }
816 position += subdev[i]->size;
817 } else {
818
819 int j;
820 for (j = 0; j < subdev[i]->numeraseregions; j++) {
821
822 if (subdev[i]->eraseregions[j].
823 erasesize != curr_erasesize) {
824 erase_region_p->offset = begin;
825 erase_region_p->erasesize =
826 curr_erasesize;
827 tmp64 = position - begin;
828 do_div(tmp64, curr_erasesize);
829 erase_region_p->numblocks = tmp64;
830 begin = position;
831
832 curr_erasesize =
833 subdev[i]->eraseregions[j].
834 erasesize;
835 ++erase_region_p;
836 }
837 position +=
838 subdev[i]->eraseregions[j].
839 numblocks * (uint64_t)curr_erasesize;
840 }
841 }
842 }
843
844 erase_region_p->offset = begin;
845 erase_region_p->erasesize = curr_erasesize;
846 tmp64 = position - begin;
847 do_div(tmp64, curr_erasesize);
848 erase_region_p->numblocks = tmp64;
849 }
850
851 return &concat->mtd;
852}
853
854
855
856
857
858void mtd_concat_destroy(struct mtd_info *mtd)
859{
860 struct mtd_concat *concat = CONCAT(mtd);
861 if (concat->mtd.numeraseregions)
862 kfree(concat->mtd.eraseregions);
863 kfree(concat);
864}
865
866EXPORT_SYMBOL(mtd_concat_create);
867EXPORT_SYMBOL(mtd_concat_destroy);
868
869MODULE_LICENSE("GPL");
870MODULE_AUTHOR("Robert Kaiser <rkaiser@sysgo.de>");
871MODULE_DESCRIPTION("Generic support for concatenating of MTD devices");
872