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         BUG_ON(i >= concat->num_subdev);
 481
 482         /* now do the erase: */
 483         err = 0;
 484         for (; length > 0; i++) {
 485                 /* loop for all subdevices affected by this request */
 486                 subdev = concat->subdev[i];     /* get current subdevice */
 487
 488                 /* limit length to subdevice's size: */
 489                 if (erase->addr + length > subdev->size)
 490                         erase->len = subdev->size - erase->addr;
 491                 else
 492                         erase->len = length;
 493
 494                 if (!(subdev->flags & MTD_WRITEABLE)) {
 495                         err = -EROFS;
 496                         break;
 497                 }
 498                 length -= erase->len;
 499                 if ((err = concat_dev_erase(subdev, erase))) {
 500                         /* sanity check: should never happen since
 501                          * block alignment has been checked above */
 502                         BUG_ON(err == -EINVAL);
 503                         if (erase->fail_addr != 0xffffffff)
 504                                 instr->fail_addr = erase->fail_addr + offset;
 505                         break;
 506                 }
 507                 /*
 508                  * erase->addr specifies the offset of the area to be
 509                  * erased *within the current subdevice*. It can be
 510                  * non-zero only the first time through this loop, i.e.
 511                  * for the first subdevice where blocks need to be erased.
 512                  * All the following erases must begin at the start of the
 513                  * current subdevice, i.e. at offset zero.
 514                  */
 515                 erase->addr = 0;
 516                 offset += subdev->size;
 517         }
 518         instr->state = erase->state;
 519         kfree(erase);
 520         if (err)
 521                 return err;
 522
 523         if (instr->callback)
 524                 instr->callback(instr);
 525         return 0;
 526 }
 527
 528 static int concat_lock(struct mtd_info *mtd, loff_t ofs, size_t len)
 529 {
 530         struct mtd_concat *concat = CONCAT(mtd);
 531         int i, err = -EINVAL;
 532
 533         if ((len + ofs) > mtd->size)
 534                 return -EINVAL;
 535
 536         for (i = 0; i < concat->num_subdev; i++) {
 537                 struct mtd_info *subdev = concat->subdev[i];
 538                 size_t size;
 539
 540                 if (ofs >= subdev->size) {
 541                         size = 0;
 542                         ofs -= subdev->size;
 543                         continue;
 544                 }
 545                 if (ofs + len > subdev->size)
 546                         size = subdev->size - ofs;
 547                 else
 548                         size = len;
 549
 550                 err = subdev->lock(subdev, ofs, size);
 551
 552                 if (err)
 553                         break;
 554
 555                 len -= size;
 556                 if (len == 0)
 557                         break;
 558
 559                 err = -EINVAL;
 560                 ofs = 0;
 561         }
 562
 563         return err;
 564 }
 565
 566 static int concat_unlock(struct mtd_info *mtd, loff_t ofs, size_t len)
 567 {
 568         struct mtd_concat *concat = CONCAT(mtd);
 569         int i, err = 0;
 570
 571         if ((len + ofs) > mtd->size)
 572                 return -EINVAL;
 573
 574         for (i = 0; i < concat->num_subdev; i++) {
 575                 struct mtd_info *subdev = concat->subdev[i];
 576                 size_t size;
 577
 578                 if (ofs >= subdev->size) {
 579                         size = 0;
 580                         ofs -= subdev->size;
 581                         continue;
 582                 }
 583                 if (ofs + len > subdev->size)
 584                         size = subdev->size - ofs;
 585                 else
 586                         size = len;
 587
 588                 err = subdev->unlock(subdev, ofs, size);
 589
 590                 if (err)
 591                         break;
 592
 593                 len -= size;
 594                 if (len == 0)
 595                         break;
 596
 597                 err = -EINVAL;
 598                 ofs = 0;
 599         }
 600
 601         return err;
 602 }
 603
 604 static void concat_sync(struct mtd_info *mtd)
 605 {
 606         struct mtd_concat *concat = CONCAT(mtd);
 607         int i;
 608
 609         for (i = 0; i < concat->num_subdev; i++) {
 610                 struct mtd_info *subdev = concat->subdev[i];
 611                 subdev->sync(subdev);
 612         }
 613 }
 614
 615 static int concat_suspend(struct mtd_info *mtd)
 616 {
 617         struct mtd_concat *concat = CONCAT(mtd);
 618         int i, rc = 0;
 619
 620         for (i = 0; i < concat->num_subdev; i++) {
 621                 struct mtd_info *subdev = concat->subdev[i];
 622                 if ((rc = subdev->suspend(subdev)) < 0)
 623                         return rc;
 624         }
 625         return rc;
 626 }
 627
 628 static void concat_resume(struct mtd_info *mtd)
 629 {
 630         struct mtd_concat *concat = CONCAT(mtd);
 631         int i;
 632
 633         for (i = 0; i < concat->num_subdev; i++) {
 634                 struct mtd_info *subdev = concat->subdev[i];
 635                 subdev->resume(subdev);
 636         }
 637 }
 638
 639 /*
 640  * This function constructs a virtual MTD device by concatenating
 641  * num_devs MTD devices. A pointer to the new device object is
 642  * stored to *new_dev upon success. This function does _not_
 643  * register any devices: this is the caller's responsibility.
 644  */
 645 struct mtd_info *mtd_concat_create(struct mtd_info *subdev[],   /* subdevices to concatenate */
 646                                    int num_devs,        /* number of subdevices      */
 647                                    char *name)
 648 {                               /* name for the new device   */
 649         int i;
 650         size_t size;
 651         struct mtd_concat *concat;
 652         u_int32_t max_erasesize, curr_erasesize;
 653         int num_erase_region;
 654
 655         printk(KERN_NOTICE "Concatenating MTD devices:\n");
 656         for (i = 0; i < num_devs; i++)
 657                 printk(KERN_NOTICE "(%d): \"%s\"\n", i, subdev[i]->name);
 658         printk(KERN_NOTICE "into device \"%s\"\n", name);
 659
 660         /* allocate the device structure */
 661         size = SIZEOF_STRUCT_MTD_CONCAT(num_devs);
 662         concat = kmalloc(size, GFP_KERNEL);
 663         if (!concat) {
 664                 printk
 665                     ("memory allocation error while creating concatenated device \"%s\"\n",
 666                      name);
 667                 return NULL;
 668         }
 669         memset(concat, 0, size);
 670         concat->subdev = (struct mtd_info **) (concat + 1);
 671
 672         /*
 673          * Set up the new "super" device's MTD object structure, check for
 674          * incompatibilites between the subdevices.
 675          */
 676         concat->mtd.type = subdev[0]->type;
 677         concat->mtd.flags = subdev[0]->flags;
 678         concat->mtd.size = subdev[0]->size;
 679         concat->mtd.erasesize = subdev[0]->erasesize;
 680         concat->mtd.oobblock = subdev[0]->oobblock;
 681         concat->mtd.oobsize = subdev[0]->oobsize;
 682         concat->mtd.ecctype = subdev[0]->ecctype;
 683         concat->mtd.eccsize = subdev[0]->eccsize;
 684         if (subdev[0]->read_ecc)
 685                 concat->mtd.read_ecc = concat_read_ecc;
 686         if (subdev[0]->write_ecc)
 687                 concat->mtd.write_ecc = concat_write_ecc;
 688         if (subdev[0]->read_oob)
 689                 concat->mtd.read_oob = concat_read_oob;
 690         if (subdev[0]->write_oob)
 691                 concat->mtd.write_oob = concat_write_oob;
 692
 693         concat->subdev[0] = subdev[0];
 694
 695         for (i = 1; i < num_devs; i++) {
 696                 if (concat->mtd.type != subdev[i]->type) {
 697                         kfree(concat);
 698                         printk("Incompatible device type on \"%s\"\n",
 699                                subdev[i]->name);
 700                         return NULL;
 701                 }
 702                 if (concat->mtd.flags != subdev[i]->flags) {
 703                         /*
 704                          * Expect all flags except MTD_WRITEABLE to be
 705                          * equal on all subdevices.
 706                          */
 707                         if ((concat->mtd.flags ^ subdev[i]->
 708                              flags) & ~MTD_WRITEABLE) {
 709                                 kfree(concat);
 710                                 printk("Incompatible device flags on \"%s\"\n",
 711                                        subdev[i]->name);
 712                                 return NULL;
 713                         } else
 714                                 /* if writeable attribute differs,
 715                                    make super device writeable */
 716                                 concat->mtd.flags |=
 717                                     subdev[i]->flags & MTD_WRITEABLE;
 718                 }
 719                 concat->mtd.size += subdev[i]->size;
 720                 if (concat->mtd.oobblock   !=  subdev[i]->oobblock ||
 721                     concat->mtd.oobsize    !=  subdev[i]->oobsize ||
 722                     concat->mtd.ecctype    !=  subdev[i]->ecctype ||
 723                     concat->mtd.eccsize    !=  subdev[i]->eccsize ||
 724                     !concat->mtd.read_ecc  != !subdev[i]->read_ecc ||
 725                     !concat->mtd.write_ecc != !subdev[i]->write_ecc ||
 726                     !concat->mtd.read_oob  != !subdev[i]->read_oob ||
 727                     !concat->mtd.write_oob != !subdev[i]->write_oob) {
 728                         kfree(concat);
 729                         printk("Incompatible OOB or ECC data on \"%s\"\n",
 730                                subdev[i]->name);
 731                         return NULL;
 732                 }
 733                 concat->subdev[i] = subdev[i];
 734
 735         }
 736
 737         concat->num_subdev = num_devs;
 738         concat->mtd.name = name;
 739
 740         /*
 741          * NOTE: for now, we do not provide any readv()/writev() methods
 742          *       because they are messy to implement and they are not
 743          *       used to a great extent anyway.
 744          */
 745         concat->mtd.erase = concat_erase;
 746         concat->mtd.read = concat_read;
 747         concat->mtd.write = concat_write;
 748         concat->mtd.sync = concat_sync;
 749         concat->mtd.lock = concat_lock;
 750         concat->mtd.unlock = concat_unlock;
 751         concat->mtd.suspend = concat_suspend;
 752         concat->mtd.resume = concat_resume;
 753
 754         /*
 755          * Combine the erase block size info of the subdevices:
 756          *
 757          * first, walk the map of the new device and see how
 758          * many changes in erase size we have
 759          */
 760         max_erasesize = curr_erasesize = subdev[0]->erasesize;
 761         num_erase_region = 1;
 762         for (i = 0; i < num_devs; i++) {
 763                 if (subdev[i]->numeraseregions == 0) {
 764                         /* current subdevice has uniform erase size */
 765                         if (subdev[i]->erasesize != curr_erasesize) {
 766                                 /* if it differs from the last subdevice's erase size, count it */
 767                                 ++num_erase_region;
 768                                 curr_erasesize = subdev[i]->erasesize;
 769                                 if (curr_erasesize > max_erasesize)
 770                                         max_erasesize = curr_erasesize;
 771                         }
 772                 } else {
 773                         /* current subdevice has variable erase size */
 774                         int j;
 775                         for (j = 0; j < subdev[i]->numeraseregions; j++) {
 776
 777                                 /* walk the list of erase regions, count any changes */
 778                                 if (subdev[i]->eraseregions[j].erasesize !=
 779                                     curr_erasesize) {
 780                                         ++num_erase_region;
 781                                         curr_erasesize =
 782                                             subdev[i]->eraseregions[j].
 783                                             erasesize;
 784                                         if (curr_erasesize > max_erasesize)
 785                                                 max_erasesize = curr_erasesize;
 786                                 }
 787                         }
 788                 }
 789         }
 790
 791         if (num_erase_region == 1) {
 792                 /*
 793                  * All subdevices have the same uniform erase size.
 794                  * This is easy:
 795                  */
 796                 concat->mtd.erasesize = curr_erasesize;
 797                 concat->mtd.numeraseregions = 0;
 798         } else {
 799                 /*
 800                  * erase block size varies across the subdevices: allocate
 801                  * space to store the data describing the variable erase regions
 802                  */
 803                 struct mtd_erase_region_info *erase_region_p;
 804                 u_int32_t begin, position;
 805
 806                 concat->mtd.erasesize = max_erasesize;
 807                 concat->mtd.numeraseregions = num_erase_region;
 808                 concat->mtd.eraseregions = erase_region_p =
 809                     kmalloc(num_erase_region *
 810                             sizeof (struct mtd_erase_region_info), GFP_KERNEL);
 811                 if (!erase_region_p) {
 812                         kfree(concat);
 813                         printk
 814                             ("memory allocation error while creating erase region list"
 815                              " for device \"%s\"\n", name);
 816                         return NULL;
 817                 }
 818
 819                 /*
 820                  * walk the map of the new device once more and fill in
 821                  * in erase region info:
 822                  */
 823                 curr_erasesize = subdev[0]->erasesize;
 824                 begin = position = 0;
 825                 for (i = 0; i < num_devs; i++) {
 826                         if (subdev[i]->numeraseregions == 0) {
 827                                 /* current subdevice has uniform erase size */
 828                                 if (subdev[i]->erasesize != curr_erasesize) {
 829                                         /*
 830                                          *  fill in an mtd_erase_region_info structure for the area
 831                                          *  we have walked so far:
 832                                          */
 833                                         erase_region_p->offset = begin;
 834                                         erase_region_p->erasesize =
 835                                             curr_erasesize;
 836                                         erase_region_p->numblocks =
 837                                             (position - begin) / curr_erasesize;
 838                                         begin = position;
 839
 840                                         curr_erasesize = subdev[i]->erasesize;
 841                                         ++erase_region_p;
 842                                 }
 843                                 position += subdev[i]->size;
 844                         } else {
 845                                 /* current subdevice has variable erase size */
 846                                 int j;
 847                                 for (j = 0; j < subdev[i]->numeraseregions; j++) {
 848                                         /* walk the list of erase regions, count any changes */
 849                                         if (subdev[i]->eraseregions[j].
 850                                             erasesize != curr_erasesize) {
 851                                                 erase_region_p->offset = begin;
 852                                                 erase_region_p->erasesize =
 853                                                     curr_erasesize;
 854                                                 erase_region_p->numblocks =
 855                                                     (position -
 856                                                      begin) / curr_erasesize;
 857                                                 begin = position;
 858
 859                                                 curr_erasesize =
 860                                                     subdev[i]->eraseregions[j].
 861                                                     erasesize;
 862                                                 ++erase_region_p;
 863                                         }
 864                                         position +=
 865                                             subdev[i]->eraseregions[j].
 866                                             numblocks * curr_erasesize;
 867                                 }
 868                         }
 869                 }
 870                 /* Now write the final entry */
 871                 erase_region_p->offset = begin;
 872                 erase_region_p->erasesize = curr_erasesize;
 873                 erase_region_p->numblocks = (position - begin) / curr_erasesize;
 874         }
 875
 876         return &concat->mtd;
 877 }
 878
 879 /*
 880  * This function destroys an MTD object obtained from concat_mtd_devs()
 881  */
 882
 883 void mtd_concat_destroy(struct mtd_info *mtd)
 884 {
 885         struct mtd_concat *concat = CONCAT(mtd);
 886         if (concat->mtd.numeraseregions)
 887                 kfree(concat->mtd.eraseregions);
 888         kfree(concat);
 889 }
 890
 891 EXPORT_SYMBOL(mtd_concat_create);
 892 EXPORT_SYMBOL(mtd_concat_destroy);
 893
 894 MODULE_LICENSE("GPL");
 895 MODULE_AUTHOR("Robert Kaiser <rkaiser@sysgo.de>");
 896 MODULE_DESCRIPTION("Generic support for concatenating of MTD devices");