[MTD] core: Clean up trailing white spaces
[linux-2.6.git] / drivers / mtd / mtdconcat.c
1 /*
2  * MTD device concatenation layer
3  *
4  * (C) 2002 Robert Kaiser <rkaiser@sysgo.de>
5  *
6  * NAND support by Christian Gan <cgan@iders.ca>
7  *
8  * This code is GPL
9  *
10  * $Id: mtdconcat.c,v 1.11 2005/11/07 11:14:20 gleixner Exp $
11  */
12
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/sched.h>
17 #include <linux/types.h>
18
19 #include <linux/mtd/mtd.h>
20 #include <linux/mtd/concat.h>
21
22 /*
23  * Our storage structure:
24  * Subdev points to an array of pointers to struct mtd_info objects
25  * which is allocated along with this structure
26  *
27  */
28 struct mtd_concat {
29         struct mtd_info mtd;
30         int num_subdev;
31         struct mtd_info **subdev;
32 };
33
34 /*
35  * how to calculate the size required for the above structure,
36  * including the pointer array subdev points to:
37  */
38 #define SIZEOF_STRUCT_MTD_CONCAT(num_subdev)    \
39         ((sizeof(struct mtd_concat) + (num_subdev) * sizeof(struct mtd_info *)))
40
41 /*
42  * Given a pointer to the MTD object in the mtd_concat structure,
43  * we can retrieve the pointer to that structure with this macro.
44  */
45 #define CONCAT(x)  ((struct mtd_concat *)(x))
46
47 /*
48  * MTD methods which look up the relevant subdevice, translate the
49  * effective address and pass through to the subdevice.
50  */
51
52 static int
53 concat_read(struct mtd_info *mtd, loff_t from, size_t len,
54             size_t * retlen, u_char * buf)
55 {
56         struct mtd_concat *concat = CONCAT(mtd);
57         int err = -EINVAL;
58         int i;
59
60         *retlen = 0;
61
62         for (i = 0; i < concat->num_subdev; i++) {
63                 struct mtd_info *subdev = concat->subdev[i];
64                 size_t size, retsize;
65
66                 if (from >= subdev->size) {
67                         /* Not destined for this subdev */
68                         size = 0;
69                         from -= subdev->size;
70                         continue;
71                 }
72                 if (from + len > subdev->size)
73                         /* First part goes into this subdev */
74                         size = subdev->size - from;
75                 else
76                         /* Entire transaction goes into this subdev */
77                         size = len;
78
79                 err = subdev->read(subdev, from, size, &retsize, buf);
80
81                 if (err)
82                         break;
83
84                 *retlen += retsize;
85                 len -= size;
86                 if (len == 0)
87                         break;
88
89                 err = -EINVAL;
90                 buf += size;
91                 from = 0;
92         }
93         return err;
94 }
95
96 static int
97 concat_write(struct mtd_info *mtd, loff_t to, size_t len,
98              size_t * retlen, const u_char * buf)
99 {
100         struct mtd_concat *concat = CONCAT(mtd);
101         int err = -EINVAL;
102         int i;
103
104         if (!(mtd->flags & MTD_WRITEABLE))
105                 return -EROFS;
106
107         *retlen = 0;
108
109         for (i = 0; i < concat->num_subdev; i++) {
110                 struct mtd_info *subdev = concat->subdev[i];
111                 size_t size, retsize;
112
113                 if (to >= subdev->size) {
114                         size = 0;
115                         to -= subdev->size;
116                         continue;
117                 }
118                 if (to + len > subdev->size)
119                         size = subdev->size - to;
120                 else
121                         size = len;
122
123                 if (!(subdev->flags & MTD_WRITEABLE))
124                         err = -EROFS;
125                 else
126                         err = subdev->write(subdev, to, size, &retsize, buf);
127
128                 if (err)
129                         break;
130
131                 *retlen += retsize;
132                 len -= size;
133                 if (len == 0)
134                         break;
135
136                 err = -EINVAL;
137                 buf += size;
138                 to = 0;
139         }
140         return err;
141 }
142
143 static int
144 concat_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
145                 size_t * retlen, u_char * buf, u_char * eccbuf,
146                 struct nand_oobinfo *oobsel)
147 {
148         struct mtd_concat *concat = CONCAT(mtd);
149         int err = -EINVAL;
150         int i;
151
152         *retlen = 0;
153
154         for (i = 0; i < concat->num_subdev; i++) {
155                 struct mtd_info *subdev = concat->subdev[i];
156                 size_t size, retsize;
157
158                 if (from >= subdev->size) {
159                         /* Not destined for this subdev */
160                         size = 0;
161                         from -= subdev->size;
162                         continue;
163                 }
164
165                 if (from + len > subdev->size)
166                         /* First part goes into this subdev */
167                         size = subdev->size - from;
168                 else
169                         /* Entire transaction goes into this subdev */
170                         size = len;
171
172                 if (subdev->read_ecc)
173                         err = subdev->read_ecc(subdev, from, size,
174                                                &retsize, buf, eccbuf, oobsel);
175                 else
176                         err = -EINVAL;
177
178                 if (err)
179                         break;
180
181                 *retlen += retsize;
182                 len -= size;
183                 if (len == 0)
184                         break;
185
186                 err = -EINVAL;
187                 buf += size;
188                 if (eccbuf) {
189                         eccbuf += subdev->oobsize;
190                         /* in nand.c at least, eccbufs are
191                            tagged with 2 (int)eccstatus'; we
192                            must account for these */
193                         eccbuf += 2 * (sizeof (int));
194                 }
195                 from = 0;
196         }
197         return err;
198 }
199
200 static int
201 concat_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
202                  size_t * retlen, const u_char * buf, u_char * eccbuf,
203                  struct nand_oobinfo *oobsel)
204 {
205         struct mtd_concat *concat = CONCAT(mtd);
206         int err = -EINVAL;
207         int i;
208
209         if (!(mtd->flags & MTD_WRITEABLE))
210                 return -EROFS;
211
212         *retlen = 0;
213
214         for (i = 0; i < concat->num_subdev; i++) {
215                 struct mtd_info *subdev = concat->subdev[i];
216                 size_t size, retsize;
217
218                 if (to >= subdev->size) {
219                         size = 0;
220                         to -= subdev->size;
221                         continue;
222                 }
223                 if (to + len > subdev->size)
224                         size = subdev->size - to;
225                 else
226                         size = len;
227
228                 if (!(subdev->flags & MTD_WRITEABLE))
229                         err = -EROFS;
230                 else if (subdev->write_ecc)
231                         err = subdev->write_ecc(subdev, to, size,
232                                                 &retsize, buf, eccbuf, oobsel);
233                 else
234                         err = -EINVAL;
235
236                 if (err)
237                         break;
238
239                 *retlen += retsize;
240                 len -= size;
241                 if (len == 0)
242                         break;
243
244                 err = -EINVAL;
245                 buf += size;
246                 if (eccbuf)
247                         eccbuf += subdev->oobsize;
248                 to = 0;
249         }
250         return err;
251 }
252
253 static int
254 concat_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
255                 size_t * retlen, u_char * buf)
256 {
257         struct mtd_concat *concat = CONCAT(mtd);
258         int err = -EINVAL;
259         int i;
260
261         *retlen = 0;
262
263         for (i = 0; i < concat->num_subdev; i++) {
264                 struct mtd_info *subdev = concat->subdev[i];
265                 size_t size, retsize;
266
267                 if (from >= subdev->size) {
268                         /* Not destined for this subdev */
269                         size = 0;
270                         from -= subdev->size;
271                         continue;
272                 }
273                 if (from + len > subdev->size)
274                         /* First part goes into this subdev */
275                         size = subdev->size - from;
276                 else
277                         /* Entire transaction goes into this subdev */
278                         size = len;
279
280                 if (subdev->read_oob)
281                         err = subdev->read_oob(subdev, from, size,
282                                                &retsize, buf);
283                 else
284                         err = -EINVAL;
285
286                 if (err)
287                         break;
288
289                 *retlen += retsize;
290                 len -= size;
291                 if (len == 0)
292                         break;
293
294                 err = -EINVAL;
295                 buf += size;
296                 from = 0;
297         }
298         return err;
299 }
300
301 static int
302 concat_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
303                  size_t * retlen, const u_char * buf)
304 {
305         struct mtd_concat *concat = CONCAT(mtd);
306         int err = -EINVAL;
307         int i;
308
309         if (!(mtd->flags & MTD_WRITEABLE))
310                 return -EROFS;
311
312         *retlen = 0;
313
314         for (i = 0; i < concat->num_subdev; i++) {
315                 struct mtd_info *subdev = concat->subdev[i];
316                 size_t size, retsize;
317
318                 if (to >= subdev->size) {
319                         size = 0;
320                         to -= subdev->size;
321                         continue;
322                 }
323                 if (to + len > subdev->size)
324                         size = subdev->size - to;
325                 else
326                         size = len;
327
328                 if (!(subdev->flags & MTD_WRITEABLE))
329                         err = -EROFS;
330                 else if (subdev->write_oob)
331                         err = subdev->write_oob(subdev, to, size, &retsize,
332                                                 buf);
333                 else
334                         err = -EINVAL;
335
336                 if (err)
337                         break;
338
339                 *retlen += retsize;
340                 len -= size;
341                 if (len == 0)
342                         break;
343
344                 err = -EINVAL;
345                 buf += size;
346                 to = 0;
347         }
348         return err;
349 }
350
351 static void concat_erase_callback(struct erase_info *instr)
352 {
353         wake_up((wait_queue_head_t *) instr->priv);
354 }
355
356 static int concat_dev_erase(struct mtd_info *mtd, struct erase_info *erase)
357 {
358         int err;
359         wait_queue_head_t waitq;
360         DECLARE_WAITQUEUE(wait, current);
361
362         /*
363          * This code was stol^H^H^H^Hinspired by mtdchar.c
364          */
365         init_waitqueue_head(&waitq);
366
367         erase->mtd = mtd;
368         erase->callback = concat_erase_callback;
369         erase->priv = (unsigned long) &waitq;
370
371         /*
372          * FIXME: Allow INTERRUPTIBLE. Which means
373          * not having the wait_queue head on the stack.
374          */
375         err = mtd->erase(mtd, erase);
376         if (!err) {
377                 set_current_state(TASK_UNINTERRUPTIBLE);
378                 add_wait_queue(&waitq, &wait);
379                 if (erase->state != MTD_ERASE_DONE
380                     && erase->state != MTD_ERASE_FAILED)
381                         schedule();
382                 remove_wait_queue(&waitq, &wait);
383                 set_current_state(TASK_RUNNING);
384
385                 err = (erase->state == MTD_ERASE_FAILED) ? -EIO : 0;
386         }
387         return err;
388 }
389
390 static int concat_erase(struct mtd_info *mtd, struct erase_info *instr)
391 {
392         struct mtd_concat *concat = CONCAT(mtd);
393         struct mtd_info *subdev;
394         int i, err;
395         u_int32_t length, offset = 0;
396         struct erase_info *erase;
397
398         if (!(mtd->flags & MTD_WRITEABLE))
399                 return -EROFS;
400
401         if (instr->addr > concat->mtd.size)
402                 return -EINVAL;
403
404         if (instr->len + instr->addr > concat->mtd.size)
405                 return -EINVAL;
406
407         /*
408          * Check for proper erase block alignment of the to-be-erased area.
409          * It is easier to do this based on the super device's erase
410          * region info rather than looking at each particular sub-device
411          * in turn.
412          */
413         if (!concat->mtd.numeraseregions) {
414                 /* the easy case: device has uniform erase block size */
415                 if (instr->addr & (concat->mtd.erasesize - 1))
416                         return -EINVAL;
417                 if (instr->len & (concat->mtd.erasesize - 1))
418                         return -EINVAL;
419         } else {
420                 /* device has variable erase size */
421                 struct mtd_erase_region_info *erase_regions =
422                     concat->mtd.eraseregions;
423
424                 /*
425                  * Find the erase region where the to-be-erased area begins:
426                  */
427                 for (i = 0; i < concat->mtd.numeraseregions &&
428                      instr->addr >= erase_regions[i].offset; i++) ;
429                 --i;
430
431                 /*
432                  * Now erase_regions[i] is the region in which the
433                  * to-be-erased area begins. Verify that the starting
434                  * offset is aligned to this region's erase size:
435                  */
436                 if (instr->addr & (erase_regions[i].erasesize - 1))
437                         return -EINVAL;
438
439                 /*
440                  * now find the erase region where the to-be-erased area ends:
441                  */
442                 for (; i < concat->mtd.numeraseregions &&
443                      (instr->addr + instr->len) >= erase_regions[i].offset;
444                      ++i) ;
445                 --i;
446                 /*
447                  * check if the ending offset is aligned to this region's erase size
448                  */
449                 if ((instr->addr + instr->len) & (erase_regions[i].erasesize -
450                                                   1))
451                         return -EINVAL;
452         }
453
454         instr->fail_addr = 0xffffffff;
455
456         /* make a local copy of instr to avoid modifying the caller's struct */
457         erase = kmalloc(sizeof (struct erase_info), GFP_KERNEL);
458
459         if (!erase)
460                 return -ENOMEM;
461
462         *erase = *instr;
463         length = instr->len;
464
465         /*
466          * find the subdevice where the to-be-erased area begins, adjust
467          * starting offset to be relative to the subdevice start
468          */
469         for (i = 0; i < concat->num_subdev; i++) {
470                 subdev = concat->subdev[i];
471                 if (subdev->size <= erase->addr) {
472                         erase->addr -= subdev->size;
473                         offset += subdev->size;
474                 } else {
475                         break;
476                 }
477         }
478
479         /* must never happen since size limit has been verified above */
480         if (i >= concat->num_subdev)
481                 BUG();
482
483         /* now do the erase: */
484         err = 0;
485         for (; length > 0; i++) {
486                 /* loop for all subdevices affected by this request */
487                 subdev = concat->subdev[i];     /* get current subdevice */
488
489                 /* limit length to subdevice's size: */
490                 if (erase->addr + length > subdev->size)
491                         erase->len = subdev->size - erase->addr;
492                 else
493                         erase->len = length;
494
495                 if (!(subdev->flags & MTD_WRITEABLE)) {
496                         err = -EROFS;
497                         break;
498                 }
499                 length -= erase->len;
500                 if ((err = concat_dev_erase(subdev, erase))) {
501                         /* sanity check: should never happen since
502                          * block alignment has been checked above */
503                         if (err == -EINVAL)
504                                 BUG();
505                         if (erase->fail_addr != 0xffffffff)
506                                 instr->fail_addr = erase->fail_addr + offset;
507                         break;
508                 }
509                 /*
510                  * erase->addr specifies the offset of the area to be
511                  * erased *within the current subdevice*. It can be
512                  * non-zero only the first time through this loop, i.e.
513                  * for the first subdevice where blocks need to be erased.
514                  * All the following erases must begin at the start of the
515                  * current subdevice, i.e. at offset zero.
516                  */
517                 erase->addr = 0;
518                 offset += subdev->size;
519         }
520         instr->state = erase->state;
521         kfree(erase);
522         if (err)
523                 return err;
524
525         if (instr->callback)
526                 instr->callback(instr);
527         return 0;
528 }
529
530 static int concat_lock(struct mtd_info *mtd, loff_t ofs, size_t len)
531 {
532         struct mtd_concat *concat = CONCAT(mtd);
533         int i, err = -EINVAL;
534
535         if ((len + ofs) > mtd->size)
536                 return -EINVAL;
537
538         for (i = 0; i < concat->num_subdev; i++) {
539                 struct mtd_info *subdev = concat->subdev[i];
540                 size_t size;
541
542                 if (ofs >= subdev->size) {
543                         size = 0;
544                         ofs -= subdev->size;
545                         continue;
546                 }
547                 if (ofs + len > subdev->size)
548                         size = subdev->size - ofs;
549                 else
550                         size = len;
551
552                 err = subdev->lock(subdev, ofs, size);
553
554                 if (err)
555                         break;
556
557                 len -= size;
558                 if (len == 0)
559                         break;
560
561                 err = -EINVAL;
562                 ofs = 0;
563         }
564
565         return err;
566 }
567
568 static int concat_unlock(struct mtd_info *mtd, loff_t ofs, size_t len)
569 {
570         struct mtd_concat *concat = CONCAT(mtd);
571         int i, err = 0;
572
573         if ((len + ofs) > mtd->size)
574                 return -EINVAL;
575
576         for (i = 0; i < concat->num_subdev; i++) {
577                 struct mtd_info *subdev = concat->subdev[i];
578                 size_t size;
579
580                 if (ofs >= subdev->size) {
581                         size = 0;
582                         ofs -= subdev->size;
583                         continue;
584                 }
585                 if (ofs + len > subdev->size)
586                         size = subdev->size - ofs;
587                 else
588                         size = len;
589
590                 err = subdev->unlock(subdev, ofs, size);
591
592                 if (err)
593                         break;
594
595                 len -= size;
596                 if (len == 0)
597                         break;
598
599                 err = -EINVAL;
600                 ofs = 0;
601         }
602
603         return err;
604 }
605
606 static void concat_sync(struct mtd_info *mtd)
607 {
608         struct mtd_concat *concat = CONCAT(mtd);
609         int i;
610
611         for (i = 0; i < concat->num_subdev; i++) {
612                 struct mtd_info *subdev = concat->subdev[i];
613                 subdev->sync(subdev);
614         }
615 }
616
617 static int concat_suspend(struct mtd_info *mtd)
618 {
619         struct mtd_concat *concat = CONCAT(mtd);
620         int i, rc = 0;
621
622         for (i = 0; i < concat->num_subdev; i++) {
623                 struct mtd_info *subdev = concat->subdev[i];
624                 if ((rc = subdev->suspend(subdev)) < 0)
625                         return rc;
626         }
627         return rc;
628 }
629
630 static void concat_resume(struct mtd_info *mtd)
631 {
632         struct mtd_concat *concat = CONCAT(mtd);
633         int i;
634
635         for (i = 0; i < concat->num_subdev; i++) {
636                 struct mtd_info *subdev = concat->subdev[i];
637                 subdev->resume(subdev);
638         }
639 }
640
641 /*
642  * This function constructs a virtual MTD device by concatenating
643  * num_devs MTD devices. A pointer to the new device object is
644  * stored to *new_dev upon success. This function does _not_
645  * register any devices: this is the caller's responsibility.
646  */
647 struct mtd_info *mtd_concat_create(struct mtd_info *subdev[],   /* subdevices to concatenate */
648                                    int num_devs,        /* number of subdevices      */
649                                    char *name)
650 {                               /* name for the new device   */
651         int i;
652         size_t size;
653         struct mtd_concat *concat;
654         u_int32_t max_erasesize, curr_erasesize;
655         int num_erase_region;
656
657         printk(KERN_NOTICE "Concatenating MTD devices:\n");
658         for (i = 0; i < num_devs; i++)
659                 printk(KERN_NOTICE "(%d): \"%s\"\n", i, subdev[i]->name);
660         printk(KERN_NOTICE "into device \"%s\"\n", name);
661
662         /* allocate the device structure */
663         size = SIZEOF_STRUCT_MTD_CONCAT(num_devs);
664         concat = kmalloc(size, GFP_KERNEL);
665         if (!concat) {
666                 printk
667                     ("memory allocation error while creating concatenated device \"%s\"\n",
668                      name);
669                 return NULL;
670         }
671         memset(concat, 0, size);
672         concat->subdev = (struct mtd_info **) (concat + 1);
673
674         /*
675          * Set up the new "super" device's MTD object structure, check for
676          * incompatibilites between the subdevices.
677          */
678         concat->mtd.type = subdev[0]->type;
679         concat->mtd.flags = subdev[0]->flags;
680         concat->mtd.size = subdev[0]->size;
681         concat->mtd.erasesize = subdev[0]->erasesize;
682         concat->mtd.oobblock = subdev[0]->oobblock;
683         concat->mtd.oobsize = subdev[0]->oobsize;
684         concat->mtd.ecctype = subdev[0]->ecctype;
685         concat->mtd.eccsize = subdev[0]->eccsize;
686         if (subdev[0]->read_ecc)
687                 concat->mtd.read_ecc = concat_read_ecc;
688         if (subdev[0]->write_ecc)
689                 concat->mtd.write_ecc = concat_write_ecc;
690         if (subdev[0]->read_oob)
691                 concat->mtd.read_oob = concat_read_oob;
692         if (subdev[0]->write_oob)
693                 concat->mtd.write_oob = concat_write_oob;
694
695         concat->subdev[0] = subdev[0];
696
697         for (i = 1; i < num_devs; i++) {
698                 if (concat->mtd.type != subdev[i]->type) {
699                         kfree(concat);
700                         printk("Incompatible device type on \"%s\"\n",
701                                subdev[i]->name);
702                         return NULL;
703                 }
704                 if (concat->mtd.flags != subdev[i]->flags) {
705                         /*
706                          * Expect all flags except MTD_WRITEABLE to be
707                          * equal on all subdevices.
708                          */
709                         if ((concat->mtd.flags ^ subdev[i]->
710                              flags) & ~MTD_WRITEABLE) {
711                                 kfree(concat);
712                                 printk("Incompatible device flags on \"%s\"\n",
713                                        subdev[i]->name);
714                                 return NULL;
715                         } else
716                                 /* if writeable attribute differs,
717                                    make super device writeable */
718                                 concat->mtd.flags |=
719                                     subdev[i]->flags & MTD_WRITEABLE;
720                 }
721                 concat->mtd.size += subdev[i]->size;
722                 if (concat->mtd.oobblock   !=  subdev[i]->oobblock ||
723                     concat->mtd.oobsize    !=  subdev[i]->oobsize ||
724                     concat->mtd.ecctype    !=  subdev[i]->ecctype ||
725                     concat->mtd.eccsize    !=  subdev[i]->eccsize ||
726                     !concat->mtd.read_ecc  != !subdev[i]->read_ecc ||
727                     !concat->mtd.write_ecc != !subdev[i]->write_ecc ||
728                     !concat->mtd.read_oob  != !subdev[i]->read_oob ||
729                     !concat->mtd.write_oob != !subdev[i]->write_oob) {
730                         kfree(concat);
731                         printk("Incompatible OOB or ECC data on \"%s\"\n",
732                                subdev[i]->name);
733                         return NULL;
734                 }
735                 concat->subdev[i] = subdev[i];
736
737         }
738
739         concat->num_subdev = num_devs;
740         concat->mtd.name = name;
741
742         /*
743          * NOTE: for now, we do not provide any readv()/writev() methods
744          *       because they are messy to implement and they are not
745          *       used to a great extent anyway.
746          */
747         concat->mtd.erase = concat_erase;
748         concat->mtd.read = concat_read;
749         concat->mtd.write = concat_write;
750         concat->mtd.sync = concat_sync;
751         concat->mtd.lock = concat_lock;
752         concat->mtd.unlock = concat_unlock;
753         concat->mtd.suspend = concat_suspend;
754         concat->mtd.resume = concat_resume;
755
756         /*
757          * Combine the erase block size info of the subdevices:
758          *
759          * first, walk the map of the new device and see how
760          * many changes in erase size we have
761          */
762         max_erasesize = curr_erasesize = subdev[0]->erasesize;
763         num_erase_region = 1;
764         for (i = 0; i < num_devs; i++) {
765                 if (subdev[i]->numeraseregions == 0) {
766                         /* current subdevice has uniform erase size */
767                         if (subdev[i]->erasesize != curr_erasesize) {
768                                 /* if it differs from the last subdevice's erase size, count it */
769                                 ++num_erase_region;
770                                 curr_erasesize = subdev[i]->erasesize;
771                                 if (curr_erasesize > max_erasesize)
772                                         max_erasesize = curr_erasesize;
773                         }
774                 } else {
775                         /* current subdevice has variable erase size */
776                         int j;
777                         for (j = 0; j < subdev[i]->numeraseregions; j++) {
778
779                                 /* walk the list of erase regions, count any changes */
780                                 if (subdev[i]->eraseregions[j].erasesize !=
781                                     curr_erasesize) {
782                                         ++num_erase_region;
783                                         curr_erasesize =
784                                             subdev[i]->eraseregions[j].
785                                             erasesize;
786                                         if (curr_erasesize > max_erasesize)
787                                                 max_erasesize = curr_erasesize;
788                                 }
789                         }
790                 }
791         }
792
793         if (num_erase_region == 1) {
794                 /*
795                  * All subdevices have the same uniform erase size.
796                  * This is easy:
797                  */
798                 concat->mtd.erasesize = curr_erasesize;
799                 concat->mtd.numeraseregions = 0;
800         } else {
801                 /*
802                  * erase block size varies across the subdevices: allocate
803                  * space to store the data describing the variable erase regions
804                  */
805                 struct mtd_erase_region_info *erase_region_p;
806                 u_int32_t begin, position;
807
808                 concat->mtd.erasesize = max_erasesize;
809                 concat->mtd.numeraseregions = num_erase_region;
810                 concat->mtd.eraseregions = erase_region_p =
811                     kmalloc(num_erase_region *
812                             sizeof (struct mtd_erase_region_info), GFP_KERNEL);
813                 if (!erase_region_p) {
814                         kfree(concat);
815                         printk
816                             ("memory allocation error while creating erase region list"
817                              " for device \"%s\"\n", name);
818                         return NULL;
819                 }
820
821                 /*
822                  * walk the map of the new device once more and fill in
823                  * in erase region info:
824                  */
825                 curr_erasesize = subdev[0]->erasesize;
826                 begin = position = 0;
827                 for (i = 0; i < num_devs; i++) {
828                         if (subdev[i]->numeraseregions == 0) {
829                                 /* current subdevice has uniform erase size */
830                                 if (subdev[i]->erasesize != curr_erasesize) {
831                                         /*
832                                          *  fill in an mtd_erase_region_info structure for the area
833                                          *  we have walked so far:
834                                          */
835                                         erase_region_p->offset = begin;
836                                         erase_region_p->erasesize =
837                                             curr_erasesize;
838                                         erase_region_p->numblocks =
839                                             (position - begin) / curr_erasesize;
840                                         begin = position;
841
842                                         curr_erasesize = subdev[i]->erasesize;
843                                         ++erase_region_p;
844                                 }
845                                 position += subdev[i]->size;
846                         } else {
847                                 /* current subdevice has variable erase size */
848                                 int j;
849                                 for (j = 0; j < subdev[i]->numeraseregions; j++) {
850                                         /* walk the list of erase regions, count any changes */
851                                         if (subdev[i]->eraseregions[j].
852                                             erasesize != curr_erasesize) {
853                                                 erase_region_p->offset = begin;
854                                                 erase_region_p->erasesize =
855                                                     curr_erasesize;
856                                                 erase_region_p->numblocks =
857                                                     (position -
858                                                      begin) / curr_erasesize;
859                                                 begin = position;
860
861                                                 curr_erasesize =
862                                                     subdev[i]->eraseregions[j].
863                                                     erasesize;
864                                                 ++erase_region_p;
865                                         }
866                                         position +=
867                                             subdev[i]->eraseregions[j].
868                                             numblocks * curr_erasesize;
869                                 }
870                         }
871                 }
872                 /* Now write the final entry */
873                 erase_region_p->offset = begin;
874                 erase_region_p->erasesize = curr_erasesize;
875                 erase_region_p->numblocks = (position - begin) / curr_erasesize;
876         }
877
878         return &concat->mtd;
879 }
880
881 /*
882  * This function destroys an MTD object obtained from concat_mtd_devs()
883  */
884
885 void mtd_concat_destroy(struct mtd_info *mtd)
886 {
887         struct mtd_concat *concat = CONCAT(mtd);
888         if (concat->mtd.numeraseregions)
889                 kfree(concat->mtd.eraseregions);
890         kfree(concat);
891 }
892
893 EXPORT_SYMBOL(mtd_concat_create);
894 EXPORT_SYMBOL(mtd_concat_destroy);
895
896 MODULE_LICENSE("GPL");
897 MODULE_AUTHOR("Robert Kaiser <rkaiser@sysgo.de>");
898 MODULE_DESCRIPTION("Generic support for concatenating of MTD devices");