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