target/linux/oxnas/patches-4.4/0072-mtd-backport-v4.7-0day-patches-from-Boris.patch

   1 From a369af5149e6eb442b22ce89b564dd7a76e03638 Mon Sep 17 00:00:00 2001
   2 From: John Crispin <blogic@openwrt.org>
   3 Date: Tue, 26 Apr 2016 19:05:01 +0200
   4 Subject: [PATCH 072/102] mtd: backport v4.7-0day patches from Boris
   5
   6 Signed-off-by: John Crispin <blogic@openwrt.org>
   7 ---
   8  drivers/mtd/Kconfig                 |    4 +-
   9  drivers/mtd/cmdlinepart.c           |    3 +-
  10  drivers/mtd/devices/m25p80.c        |   44 +--
  11  drivers/mtd/maps/physmap_of.c       |    6 +-
  12  drivers/mtd/mtdchar.c               |  123 ++++++--
  13  drivers/mtd/mtdconcat.c             |    2 +-
  14  drivers/mtd/mtdcore.c               |  428 ++++++++++++++++++++++++--
  15  drivers/mtd/mtdcore.h               |    7 +-
  16  drivers/mtd/mtdpart.c               |  161 ++++++----
  17  drivers/mtd/mtdswap.c               |   24 +-
  18  drivers/mtd/nand/Kconfig            |   21 +-
  19  drivers/mtd/nand/Makefile           |    2 +
  20  drivers/mtd/nand/nand_base.c        |  571 +++++++++++++++++++----------------
  21  drivers/mtd/nand/nand_bbt.c         |   34 +--
  22  drivers/mtd/nand/nand_bch.c         |   52 ++--
  23  drivers/mtd/nand/nand_ecc.c         |    6 +-
  24  drivers/mtd/nand/nand_ids.c         |    4 +-
  25  drivers/mtd/nand/nandsim.c          |   43 +--
  26  drivers/mtd/ofpart.c                |   53 ++--
  27  drivers/mtd/spi-nor/Kconfig         |   10 +-
  28  drivers/mtd/spi-nor/Makefile        |    1 +
  29  drivers/mtd/spi-nor/mtk-quadspi.c   |  485 +++++++++++++++++++++++++++++
  30  drivers/mtd/spi-nor/spi-nor.c       |  321 +++++++++++++-------
  31  drivers/mtd/tests/mtd_nandecctest.c |    2 +-
  32  drivers/mtd/tests/oobtest.c         |   49 ++-
  33  drivers/mtd/tests/pagetest.c        |    3 +-
  34  include/linux/mtd/bbm.h             |    1 -
  35  include/linux/mtd/fsmc.h            |   18 --
  36  include/linux/mtd/inftl.h           |    1 -
  37  include/linux/mtd/map.h             |    9 +-
  38  include/linux/mtd/mtd.h             |   80 ++++-
  39  include/linux/mtd/nand.h            |   94 ++++--
  40  include/linux/mtd/nand_bch.h        |   10 +-
  41  include/linux/mtd/nftl.h            |    1 -
  42  include/linux/mtd/onenand.h         |    2 -
  43  include/linux/mtd/partitions.h      |   27 +-
  44  include/linux/mtd/sh_flctl.h        |    4 +-
  45  include/linux/mtd/sharpsl.h         |    2 +-
  46  include/linux/mtd/spi-nor.h         |   23 +-
  47  include/uapi/mtd/mtd-abi.h          |    2 +-
  48  45 files changed, 2077 insertions(+), 748 deletions(-)
  49  create mode 100644 drivers/mtd/spi-nor/mtk-quadspi.c
  50
  51 --- a/drivers/mtd/Kconfig
  52 +++ b/drivers/mtd/Kconfig
  53 @@ -131,7 +131,7 @@ config MTD_CMDLINE_PARTS
  54
  55  config MTD_AFS_PARTS
  56         tristate "ARM Firmware Suite partition parsing"
  57 -       depends on ARM
  58 +       depends on (ARM || ARM64)
  59         ---help---
  60           The ARM Firmware Suite allows the user to divide flash devices into
  61           multiple 'images'. Each such image has a header containing its name
  62 @@ -161,7 +161,7 @@ config MTD_AR7_PARTS
  63
  64  config MTD_BCM63XX_PARTS
  65         tristate "BCM63XX CFE partitioning support"
  66 -       depends on BCM63XX
  67 +       depends on BCM63XX || BMIPS_GENERIC || COMPILE_TEST
  68         select CRC32
  69         help
  70           This provides partions parsing for BCM63xx devices with CFE
  71 --- a/drivers/mtd/cmdlinepart.c
  72 +++ b/drivers/mtd/cmdlinepart.c
  73 @@ -304,7 +304,7 @@ static int mtdpart_setup_real(char *s)
  74   * the first one in the chain if a NULL mtd_id is passed in.
  75   */
  76  static int parse_cmdline_partitions(struct mtd_info *master,
  77 -                                   struct mtd_partition **pparts,
  78 +                                   const struct mtd_partition **pparts,
  79                                     struct mtd_part_parser_data *data)
  80  {
  81         unsigned long long offset;
  82 @@ -382,7 +382,6 @@ static int __init mtdpart_setup(char *s)
  83  __setup("mtdparts=", mtdpart_setup);
  84
  85  static struct mtd_part_parser cmdline_parser = {
  86 -       .owner = THIS_MODULE,
  87         .parse_fn = parse_cmdline_partitions,
  88         .name = "cmdlinepart",
  89  };
  90 --- a/drivers/mtd/devices/m25p80.c
  91 +++ b/drivers/mtd/devices/m25p80.c
  92 @@ -174,22 +174,6 @@ static int m25p80_read(struct spi_nor *n
  93         return 0;
  94  }
  95
  96 -static int m25p80_erase(struct spi_nor *nor, loff_t offset)
  97 -{
  98 -       struct m25p *flash = nor->priv;
  99 -
 100 -       dev_dbg(nor->dev, "%dKiB at 0x%08x\n",
 101 -               flash->spi_nor.mtd.erasesize / 1024, (u32)offset);
 102 -
 103 -       /* Set up command buffer. */
 104 -       flash->command[0] = nor->erase_opcode;
 105 -       m25p_addr2cmd(nor, offset, flash->command);
 106 -
 107 -       spi_write(flash->spi, flash->command, m25p_cmdsz(nor));
 108 -
 109 -       return 0;
 110 -}
 111 -
 112  /*
 113   * board specific setup should have ensured the SPI clock used here
 114   * matches what the READ command supports, at least until this driver
 115 @@ -197,12 +181,11 @@ static int m25p80_erase(struct spi_nor *
 116   */
 117  static int m25p_probe(struct spi_device *spi)
 118  {
 119 -       struct mtd_part_parser_data     ppdata;
 120         struct flash_platform_data      *data;
 121         struct m25p *flash;
 122         struct spi_nor *nor;
 123         enum read_mode mode = SPI_NOR_NORMAL;
 124 -       char *flash_name = NULL;
 125 +       char *flash_name;
 126         int ret;
 127
 128         data = dev_get_platdata(&spi->dev);
 129 @@ -216,12 +199,11 @@ static int m25p_probe(struct spi_device
 130         /* install the hooks */
 131         nor->read = m25p80_read;
 132         nor->write = m25p80_write;
 133 -       nor->erase = m25p80_erase;
 134         nor->write_reg = m25p80_write_reg;
 135         nor->read_reg = m25p80_read_reg;
 136
 137         nor->dev = &spi->dev;
 138 -       nor->flash_node = spi->dev.of_node;
 139 +       spi_nor_set_flash_node(nor, spi->dev.of_node);
 140         nor->priv = flash;
 141
 142         spi_set_drvdata(spi, flash);
 143 @@ -242,6 +224,8 @@ static int m25p_probe(struct spi_device
 144          */
 145         if (data && data->type)
 146                 flash_name = data->type;
 147 +       else if (!strcmp(spi->modalias, "spi-nor"))
 148 +               flash_name = NULL; /* auto-detect */
 149         else
 150                 flash_name = spi->modalias;
 151
 152 @@ -249,11 +233,8 @@ static int m25p_probe(struct spi_device
 153         if (ret)
 154                 return ret;
 155
 156 -       ppdata.of_node = spi->dev.of_node;
 157 -
 158 -       return mtd_device_parse_register(&nor->mtd, NULL, &ppdata,
 159 -                       data ? data->parts : NULL,
 160 -                       data ? data->nr_parts : 0);
 161 +       return mtd_device_register(&nor->mtd, data ? data->parts : NULL,
 162 +                                  data ? data->nr_parts : 0);
 163  }
 164
 165
 166 @@ -279,14 +260,21 @@ static int m25p_remove(struct spi_device
 167   */
 168  static const struct spi_device_id m25p_ids[] = {
 169         /*
 170 +        * Allow non-DT platform devices to bind to the "spi-nor" modalias, and
 171 +        * hack around the fact that the SPI core does not provide uevent
 172 +        * matching for .of_match_table
 173 +        */
 174 +       {"spi-nor"},
 175 +
 176 +       /*
 177          * Entries not used in DTs that should be safe to drop after replacing
 178 -        * them with "nor-jedec" in platform data.
 179 +        * them with "spi-nor" in platform data.
 180          */
 181         {"s25sl064a"},  {"w25x16"},     {"m25p10"},     {"m25px64"},
 182
 183         /*
 184 -        * Entries that were used in DTs without "nor-jedec" fallback and should
 185 -        * be kept for backward compatibility.
 186 +        * Entries that were used in DTs without "jedec,spi-nor" fallback and
 187 +        * should be kept for backward compatibility.
 188          */
 189         {"at25df321a"}, {"at25df641"},  {"at26df081a"},
 190         {"mr25h256"},
 191 --- a/drivers/mtd/maps/physmap_of.c
 192 +++ b/drivers/mtd/maps/physmap_of.c
 193 @@ -128,7 +128,6 @@ static int of_flash_probe(struct platfor
 194         int reg_tuple_size;
 195         struct mtd_info **mtd_list = NULL;
 196         resource_size_t res_size;
 197 -       struct mtd_part_parser_data ppdata;
 198         bool map_indirect;
 199         const char *mtd_name = NULL;
 200
 201 @@ -272,8 +271,9 @@ static int of_flash_probe(struct platfor
 202         if (err)
 203                 goto err_out;
 204
 205 -       ppdata.of_node = dp;
 206 -       mtd_device_parse_register(info->cmtd, part_probe_types_def, &ppdata,
 207 +       info->cmtd->dev.parent = &dev->dev;
 208 +       mtd_set_of_node(info->cmtd, dp);
 209 +       mtd_device_parse_register(info->cmtd, part_probe_types_def, NULL,
 210                         NULL, 0);
 211
 212         kfree(mtd_list);
 213 --- a/drivers/mtd/mtdchar.c
 214 +++ b/drivers/mtd/mtdchar.c
 215 @@ -465,38 +465,111 @@ static int mtdchar_readoob(struct file *
 216  }
 217
 218  /*
 219 - * Copies (and truncates, if necessary) data from the larger struct,
 220 - * nand_ecclayout, to the smaller, deprecated layout struct,
 221 - * nand_ecclayout_user. This is necessary only to support the deprecated
 222 - * API ioctl ECCGETLAYOUT while allowing all new functionality to use
 223 - * nand_ecclayout flexibly (i.e. the struct may change size in new
 224 - * releases without requiring major rewrites).
 225 + * Copies (and truncates, if necessary) OOB layout information to the
 226 + * deprecated layout struct, nand_ecclayout_user. This is necessary only to
 227 + * support the deprecated API ioctl ECCGETLAYOUT while allowing all new
 228 + * functionality to use mtd_ooblayout_ops flexibly (i.e. mtd_ooblayout_ops
 229 + * can describe any kind of OOB layout with almost zero overhead from a
 230 + * memory usage point of view).
 231   */
 232 -static int shrink_ecclayout(const struct nand_ecclayout *from,
 233 -               struct nand_ecclayout_user *to)
 234 +static int shrink_ecclayout(struct mtd_info *mtd,
 235 +                           struct nand_ecclayout_user *to)
 236  {
 237 -       int i;
 238 +       struct mtd_oob_region oobregion;
 239 +       int i, section = 0, ret;
 240
 241 -       if (!from || !to)
 242 +       if (!mtd || !to)
 243                 return -EINVAL;
 244
 245         memset(to, 0, sizeof(*to));
 246
 247 -       to->eccbytes = min((int)from->eccbytes, MTD_MAX_ECCPOS_ENTRIES);
 248 -       for (i = 0; i < to->eccbytes; i++)
 249 -               to->eccpos[i] = from->eccpos[i];
 250 +       to->eccbytes = 0;
 251 +       for (i = 0; i < MTD_MAX_ECCPOS_ENTRIES;) {
 252 +               u32 eccpos;
 253 +
 254 +               ret = mtd_ooblayout_ecc(mtd, section, &oobregion);
 255 +               if (ret < 0) {
 256 +                       if (ret != -ERANGE)
 257 +                               return ret;
 258 +
 259 +                       break;
 260 +               }
 261 +
 262 +               eccpos = oobregion.offset;
 263 +               for (; i < MTD_MAX_ECCPOS_ENTRIES &&
 264 +                      eccpos < oobregion.offset + oobregion.length; i++) {
 265 +                       to->eccpos[i] = eccpos++;
 266 +                       to->eccbytes++;
 267 +               }
 268 +       }
 269
 270         for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES; i++) {
 271 -               if (from->oobfree[i].length == 0 &&
 272 -                               from->oobfree[i].offset == 0)
 273 +               ret = mtd_ooblayout_free(mtd, i, &oobregion);
 274 +               if (ret < 0) {
 275 +                       if (ret != -ERANGE)
 276 +                               return ret;
 277 +
 278                         break;
 279 -               to->oobavail += from->oobfree[i].length;
 280 -               to->oobfree[i] = from->oobfree[i];
 281 +               }
 282 +
 283 +               to->oobfree[i].offset = oobregion.offset;
 284 +               to->oobfree[i].length = oobregion.length;
 285 +               to->oobavail += to->oobfree[i].length;
 286         }
 287
 288         return 0;
 289  }
 290
 291 +static int get_oobinfo(struct mtd_info *mtd, struct nand_oobinfo *to)
 292 +{
 293 +       struct mtd_oob_region oobregion;
 294 +       int i, section = 0, ret;
 295 +
 296 +       if (!mtd || !to)
 297 +               return -EINVAL;
 298 +
 299 +       memset(to, 0, sizeof(*to));
 300 +
 301 +       to->eccbytes = 0;
 302 +       for (i = 0; i < ARRAY_SIZE(to->eccpos);) {
 303 +               u32 eccpos;
 304 +
 305 +               ret = mtd_ooblayout_ecc(mtd, section, &oobregion);
 306 +               if (ret < 0) {
 307 +                       if (ret != -ERANGE)
 308 +                               return ret;
 309 +
 310 +                       break;
 311 +               }
 312 +
 313 +               if (oobregion.length + i > ARRAY_SIZE(to->eccpos))
 314 +                       return -EINVAL;
 315 +
 316 +               eccpos = oobregion.offset;
 317 +               for (; eccpos < oobregion.offset + oobregion.length; i++) {
 318 +                       to->eccpos[i] = eccpos++;
 319 +                       to->eccbytes++;
 320 +               }
 321 +       }
 322 +
 323 +       for (i = 0; i < 8; i++) {
 324 +               ret = mtd_ooblayout_free(mtd, i, &oobregion);
 325 +               if (ret < 0) {
 326 +                       if (ret != -ERANGE)
 327 +                               return ret;
 328 +
 329 +                       break;
 330 +               }
 331 +
 332 +               to->oobfree[i][0] = oobregion.offset;
 333 +               to->oobfree[i][1] = oobregion.length;
 334 +       }
 335 +
 336 +       to->useecc = MTD_NANDECC_AUTOPLACE;
 337 +
 338 +       return 0;
 339 +}
 340 +
 341  static int mtdchar_blkpg_ioctl(struct mtd_info *mtd,
 342                                struct blkpg_ioctl_arg *arg)
 343  {
 344 @@ -815,16 +888,12 @@ static int mtdchar_ioctl(struct file *fi
 345         {
 346                 struct nand_oobinfo oi;
 347
 348 -               if (!mtd->ecclayout)
 349 +               if (!mtd->ooblayout)
 350                         return -EOPNOTSUPP;
 351 -               if (mtd->ecclayout->eccbytes > ARRAY_SIZE(oi.eccpos))
 352 -                       return -EINVAL;
 353
 354 -               oi.useecc = MTD_NANDECC_AUTOPLACE;
 355 -               memcpy(&oi.eccpos, mtd->ecclayout->eccpos, sizeof(oi.eccpos));
 356 -               memcpy(&oi.oobfree, mtd->ecclayout->oobfree,
 357 -                      sizeof(oi.oobfree));
 358 -               oi.eccbytes = mtd->ecclayout->eccbytes;
 359 +               ret = get_oobinfo(mtd, &oi);
 360 +               if (ret)
 361 +                       return ret;
 362
 363                 if (copy_to_user(argp, &oi, sizeof(struct nand_oobinfo)))
 364                         return -EFAULT;
 365 @@ -913,14 +982,14 @@ static int mtdchar_ioctl(struct file *fi
 366         {
 367                 struct nand_ecclayout_user *usrlay;
 368
 369 -               if (!mtd->ecclayout)
 370 +               if (!mtd->ooblayout)
 371                         return -EOPNOTSUPP;
 372
 373                 usrlay = kmalloc(sizeof(*usrlay), GFP_KERNEL);
 374                 if (!usrlay)
 375                         return -ENOMEM;
 376
 377 -               shrink_ecclayout(mtd->ecclayout, usrlay);
 378 +               shrink_ecclayout(mtd, usrlay);
 379
 380                 if (copy_to_user(argp, usrlay, sizeof(*usrlay)))
 381                         ret = -EFAULT;
 382 --- a/drivers/mtd/mtdconcat.c
 383 +++ b/drivers/mtd/mtdconcat.c
 384 @@ -777,7 +777,7 @@ struct mtd_info *mtd_concat_create(struc
 385
 386         }
 387
 388 -       concat->mtd.ecclayout = subdev[0]->ecclayout;
 389 +       mtd_set_ooblayout(&concat->mtd, subdev[0]->ooblayout);
 390
 391         concat->num_subdev = num_devs;
 392         concat->mtd.name = name;
 393 --- a/drivers/mtd/mtdcore.c
 394 +++ b/drivers/mtd/mtdcore.c
 395 @@ -32,6 +32,7 @@
 396  #include <linux/err.h>
 397  #include <linux/ioctl.h>
 398  #include <linux/init.h>
 399 +#include <linux/of.h>
 400  #include <linux/proc_fs.h>
 401  #include <linux/idr.h>
 402  #include <linux/backing-dev.h>
 403 @@ -446,6 +447,7 @@ int add_mtd_device(struct mtd_info *mtd)
 404         mtd->dev.devt = MTD_DEVT(i);
 405         dev_set_name(&mtd->dev, "mtd%d", i);
 406         dev_set_drvdata(&mtd->dev, mtd);
 407 +       of_node_get(mtd_get_of_node(mtd));
 408         error = device_register(&mtd->dev);
 409         if (error)
 410                 goto fail_added;
 411 @@ -477,6 +479,7 @@ int add_mtd_device(struct mtd_info *mtd)
 412         return 0;
 413
 414  fail_added:
 415 +       of_node_put(mtd_get_of_node(mtd));
 416         idr_remove(&mtd_idr, i);
 417  fail_locked:
 418         mutex_unlock(&mtd_table_mutex);
 419 @@ -518,6 +521,7 @@ int del_mtd_device(struct mtd_info *mtd)
 420                 device_unregister(&mtd->dev);
 421
 422                 idr_remove(&mtd_idr, mtd->index);
 423 +               of_node_put(mtd_get_of_node(mtd));
 424
 425                 module_put(THIS_MODULE);
 426                 ret = 0;
 427 @@ -529,9 +533,10 @@ out_error:
 428  }
 429
 430  static int mtd_add_device_partitions(struct mtd_info *mtd,
 431 -                                    struct mtd_partition *real_parts,
 432 -                                    int nbparts)
 433 +                                    struct mtd_partitions *parts)
 434  {
 435 +       const struct mtd_partition *real_parts = parts->parts;
 436 +       int nbparts = parts->nr_parts;
 437         int ret;
 438
 439         if (nbparts == 0 || IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER)) {
 440 @@ -600,29 +605,29 @@ int mtd_device_parse_register(struct mtd
 441                               const struct mtd_partition *parts,
 442                               int nr_parts)
 443  {
 444 +       struct mtd_partitions parsed;
 445         int ret;
 446 -       struct mtd_partition *real_parts = NULL;
 447
 448         mtd_set_dev_defaults(mtd);
 449
 450 -       ret = parse_mtd_partitions(mtd, types, &real_parts, parser_data);
 451 -       if (ret <= 0 && nr_parts && parts) {
 452 -               real_parts = kmemdup(parts, sizeof(*parts) * nr_parts,
 453 -                                    GFP_KERNEL);
 454 -               if (!real_parts)
 455 -                       ret = -ENOMEM;
 456 -               else
 457 -                       ret = nr_parts;
 458 -       }
 459 -       /* Didn't come up with either parsed OR fallback partitions */
 460 -       if (ret < 0) {
 461 -               pr_info("mtd: failed to find partitions; one or more parsers reports errors (%d)\n",
 462 +       memset(&parsed, 0, sizeof(parsed));
 463 +
 464 +       ret = parse_mtd_partitions(mtd, types, &parsed, parser_data);
 465 +       if ((ret < 0 || parsed.nr_parts == 0) && parts && nr_parts) {
 466 +               /* Fall back to driver-provided partitions */
 467 +               parsed = (struct mtd_partitions){
 468 +                       .parts          = parts,
 469 +                       .nr_parts       = nr_parts,
 470 +               };
 471 +       } else if (ret < 0) {
 472 +               /* Didn't come up with parsed OR fallback partitions */
 473 +                       pr_info("mtd: failed to find partitions; one or more parsers reports errors (%d)\n",
 474                         ret);
 475                 /* Don't abort on errors; we can still use unpartitioned MTD */
 476 -               ret = 0;
 477 +               memset(&parsed, 0, sizeof(parsed));
 478         }
 479
 480 -       ret = mtd_add_device_partitions(mtd, real_parts, ret);
 481 +       ret = mtd_add_device_partitions(mtd, &parsed);
 482         if (ret)
 483                 goto out;
 484
 485 @@ -642,7 +647,8 @@ int mtd_device_parse_register(struct mtd
 486         }
 487
 488  out:
 489 -       kfree(real_parts);
 490 +       /* Cleanup any parsed partitions */
 491 +       mtd_part_parser_cleanup(&parsed);
 492         return ret;
 493  }
 494  EXPORT_SYMBOL_GPL(mtd_device_parse_register);
 495 @@ -767,7 +773,6 @@ out:
 496  }
 497  EXPORT_SYMBOL_GPL(get_mtd_device);
 498
 499 -
 500  int __get_mtd_device(struct mtd_info *mtd)
 501  {
 502         int err;
 503 @@ -1001,6 +1006,366 @@ int mtd_read_oob(struct mtd_info *mtd, l
 504  }
 505  EXPORT_SYMBOL_GPL(mtd_read_oob);
 506
 507 +/**
 508 + * mtd_ooblayout_ecc - Get the OOB region definition of a specific ECC section
 509 + * @mtd: MTD device structure
 510 + * @section: ECC section. Depending on the layout you may have all the ECC
 511 + *          bytes stored in a single contiguous section, or one section
 512 + *          per ECC chunk (and sometime several sections for a single ECC
 513 + *          ECC chunk)
 514 + * @oobecc: OOB region struct filled with the appropriate ECC position
 515 + *         information
 516 + *
 517 + * This functions return ECC section information in the OOB area. I you want
 518 + * to get all the ECC bytes information, then you should call
 519 + * mtd_ooblayout_ecc(mtd, section++, oobecc) until it returns -ERANGE.
 520 + *
 521 + * Returns zero on success, a negative error code otherwise.
 522 + */
 523 +int mtd_ooblayout_ecc(struct mtd_info *mtd, int section,
 524 +                     struct mtd_oob_region *oobecc)
 525 +{
 526 +       memset(oobecc, 0, sizeof(*oobecc));
 527 +
 528 +       if (!mtd || section < 0)
 529 +               return -EINVAL;
 530 +
 531 +       if (!mtd->ooblayout || !mtd->ooblayout->ecc)
 532 +               return -ENOTSUPP;
 533 +
 534 +       return mtd->ooblayout->ecc(mtd, section, oobecc);
 535 +}
 536 +EXPORT_SYMBOL_GPL(mtd_ooblayout_ecc);
 537 +
 538 +/**
 539 + * mtd_ooblayout_free - Get the OOB region definition of a specific free
 540 + *                     section
 541 + * @mtd: MTD device structure
 542 + * @section: Free section you are interested in. Depending on the layout
 543 + *          you may have all the free bytes stored in a single contiguous
 544 + *          section, or one section per ECC chunk plus an extra section
 545 + *          for the remaining bytes (or other funky layout).
 546 + * @oobfree: OOB region struct filled with the appropriate free position
 547 + *          information
 548 + *
 549 + * This functions return free bytes position in the OOB area. I you want
 550 + * to get all the free bytes information, then you should call
 551 + * mtd_ooblayout_free(mtd, section++, oobfree) until it returns -ERANGE.
 552 + *
 553 + * Returns zero on success, a negative error code otherwise.
 554 + */
 555 +int mtd_ooblayout_free(struct mtd_info *mtd, int section,
 556 +                      struct mtd_oob_region *oobfree)
 557 +{
 558 +       memset(oobfree, 0, sizeof(*oobfree));
 559 +
 560 +       if (!mtd || section < 0)
 561 +               return -EINVAL;
 562 +
 563 +       if (!mtd->ooblayout || !mtd->ooblayout->free)
 564 +               return -ENOTSUPP;
 565 +
 566 +       return mtd->ooblayout->free(mtd, section, oobfree);
 567 +}
 568 +EXPORT_SYMBOL_GPL(mtd_ooblayout_free);
 569 +
 570 +/**
 571 + * mtd_ooblayout_find_region - Find the region attached to a specific byte
 572 + * @mtd: mtd info structure
 573 + * @byte: the byte we are searching for
 574 + * @sectionp: pointer where the section id will be stored
 575 + * @oobregion: used to retrieve the ECC position
 576 + * @iter: iterator function. Should be either mtd_ooblayout_free or
 577 + *       mtd_ooblayout_ecc depending on the region type you're searching for
 578 + *
 579 + * This functions returns the section id and oobregion information of a
 580 + * specific byte. For example, say you want to know where the 4th ECC byte is
 581 + * stored, you'll use:
 582 + *
 583 + * mtd_ooblayout_find_region(mtd, 3, &section, &oobregion, mtd_ooblayout_ecc);
 584 + *
 585 + * Returns zero on success, a negative error code otherwise.
 586 + */
 587 +static int mtd_ooblayout_find_region(struct mtd_info *mtd, int byte,
 588 +                               int *sectionp, struct mtd_oob_region *oobregion,
 589 +                               int (*iter)(struct mtd_info *,
 590 +                                           int section,
 591 +                                           struct mtd_oob_region *oobregion))
 592 +{
 593 +       int pos = 0, ret, section = 0;
 594 +
 595 +       memset(oobregion, 0, sizeof(*oobregion));
 596 +
 597 +       while (1) {
 598 +               ret = iter(mtd, section, oobregion);
 599 +               if (ret)
 600 +                       return ret;
 601 +
 602 +               if (pos + oobregion->length > byte)
 603 +                       break;
 604 +
 605 +               pos += oobregion->length;
 606 +               section++;
 607 +       }
 608 +
 609 +       /*
 610 +        * Adjust region info to make it start at the beginning at the
 611 +        * 'start' ECC byte.
 612 +        */
 613 +       oobregion->offset += byte - pos;
 614 +       oobregion->length -= byte - pos;
 615 +       *sectionp = section;
 616 +
 617 +       return 0;
 618 +}
 619 +
 620 +/**
 621 + * mtd_ooblayout_find_eccregion - Find the ECC region attached to a specific
 622 + *                               ECC byte
 623 + * @mtd: mtd info structure
 624 + * @eccbyte: the byte we are searching for
 625 + * @sectionp: pointer where the section id will be stored
 626 + * @oobregion: OOB region information
 627 + *
 628 + * Works like mtd_ooblayout_find_region() except it searches for a specific ECC
 629 + * byte.
 630 + *
 631 + * Returns zero on success, a negative error code otherwise.
 632 + */
 633 +int mtd_ooblayout_find_eccregion(struct mtd_info *mtd, int eccbyte,
 634 +                                int *section,
 635 +                                struct mtd_oob_region *oobregion)
 636 +{
 637 +       return mtd_ooblayout_find_region(mtd, eccbyte, section, oobregion,
 638 +                                        mtd_ooblayout_ecc);
 639 +}
 640 +EXPORT_SYMBOL_GPL(mtd_ooblayout_find_eccregion);
 641 +
 642 +/**
 643 + * mtd_ooblayout_get_bytes - Extract OOB bytes from the oob buffer
 644 + * @mtd: mtd info structure
 645 + * @buf: destination buffer to store OOB bytes
 646 + * @oobbuf: OOB buffer
 647 + * @start: first byte to retrieve
 648 + * @nbytes: number of bytes to retrieve
 649 + * @iter: section iterator
 650 + *
 651 + * Extract bytes attached to a specific category (ECC or free)
 652 + * from the OOB buffer and copy them into buf.
 653 + *
 654 + * Returns zero on success, a negative error code otherwise.
 655 + */
 656 +static int mtd_ooblayout_get_bytes(struct mtd_info *mtd, u8 *buf,
 657 +                               const u8 *oobbuf, int start, int nbytes,
 658 +                               int (*iter)(struct mtd_info *,
 659 +                                           int section,
 660 +                                           struct mtd_oob_region *oobregion))
 661 +{
 662 +       struct mtd_oob_region oobregion = { };
 663 +       int section = 0, ret;
 664 +
 665 +       ret = mtd_ooblayout_find_region(mtd, start, &section,
 666 +                                       &oobregion, iter);
 667 +
 668 +       while (!ret) {
 669 +               int cnt;
 670 +
 671 +               cnt = oobregion.length > nbytes ? nbytes : oobregion.length;
 672 +               memcpy(buf, oobbuf + oobregion.offset, cnt);
 673 +               buf += cnt;
 674 +               nbytes -= cnt;
 675 +
 676 +               if (!nbytes)
 677 +                       break;
 678 +
 679 +               ret = iter(mtd, ++section, &oobregion);
 680 +       }
 681 +
 682 +       return ret;
 683 +}
 684 +
 685 +/**
 686 + * mtd_ooblayout_set_bytes - put OOB bytes into the oob buffer
 687 + * @mtd: mtd info structure
 688 + * @buf: source buffer to get OOB bytes from
 689 + * @oobbuf: OOB buffer
 690 + * @start: first OOB byte to set
 691 + * @nbytes: number of OOB bytes to set
 692 + * @iter: section iterator
 693 + *
 694 + * Fill the OOB buffer with data provided in buf. The category (ECC or free)
 695 + * is selected by passing the appropriate iterator.
 696 + *
 697 + * Returns zero on success, a negative error code otherwise.
 698 + */
 699 +static int mtd_ooblayout_set_bytes(struct mtd_info *mtd, const u8 *buf,
 700 +                               u8 *oobbuf, int start, int nbytes,
 701 +                               int (*iter)(struct mtd_info *,
 702 +                                           int section,
 703 +                                           struct mtd_oob_region *oobregion))
 704 +{
 705 +       struct mtd_oob_region oobregion = { };
 706 +       int section = 0, ret;
 707 +
 708 +       ret = mtd_ooblayout_find_region(mtd, start, &section,
 709 +                                       &oobregion, iter);
 710 +
 711 +       while (!ret) {
 712 +               int cnt;
 713 +
 714 +               cnt = oobregion.length > nbytes ? nbytes : oobregion.length;
 715 +               memcpy(oobbuf + oobregion.offset, buf, cnt);
 716 +               buf += cnt;
 717 +               nbytes -= cnt;
 718 +
 719 +               if (!nbytes)
 720 +                       break;
 721 +
 722 +               ret = iter(mtd, ++section, &oobregion);
 723 +       }
 724 +
 725 +       return ret;
 726 +}
 727 +
 728 +/**
 729 + * mtd_ooblayout_count_bytes - count the number of bytes in a OOB category
 730 + * @mtd: mtd info structure
 731 + * @iter: category iterator
 732 + *
 733 + * Count the number of bytes in a given category.
 734 + *
 735 + * Returns a positive value on success, a negative error code otherwise.
 736 + */
 737 +static int mtd_ooblayout_count_bytes(struct mtd_info *mtd,
 738 +                               int (*iter)(struct mtd_info *,
 739 +                                           int section,
 740 +                                           struct mtd_oob_region *oobregion))
 741 +{
 742 +       struct mtd_oob_region oobregion = { };
 743 +       int section = 0, ret, nbytes = 0;
 744 +
 745 +       while (1) {
 746 +               ret = iter(mtd, section++, &oobregion);
 747 +               if (ret) {
 748 +                       if (ret == -ERANGE)
 749 +                               ret = nbytes;
 750 +                       break;
 751 +               }
 752 +
 753 +               nbytes += oobregion.length;
 754 +       }
 755 +
 756 +       return ret;
 757 +}
 758 +
 759 +/**
 760 + * mtd_ooblayout_get_eccbytes - extract ECC bytes from the oob buffer
 761 + * @mtd: mtd info structure
 762 + * @eccbuf: destination buffer to store ECC bytes
 763 + * @oobbuf: OOB buffer
 764 + * @start: first ECC byte to retrieve
 765 + * @nbytes: number of ECC bytes to retrieve
 766 + *
 767 + * Works like mtd_ooblayout_get_bytes(), except it acts on ECC bytes.
 768 + *
 769 + * Returns zero on success, a negative error code otherwise.
 770 + */
 771 +int mtd_ooblayout_get_eccbytes(struct mtd_info *mtd, u8 *eccbuf,
 772 +                              const u8 *oobbuf, int start, int nbytes)
 773 +{
 774 +       return mtd_ooblayout_get_bytes(mtd, eccbuf, oobbuf, start, nbytes,
 775 +                                      mtd_ooblayout_ecc);
 776 +}
 777 +EXPORT_SYMBOL_GPL(mtd_ooblayout_get_eccbytes);
 778 +
 779 +/**
 780 + * mtd_ooblayout_set_eccbytes - set ECC bytes into the oob buffer
 781 + * @mtd: mtd info structure
 782 + * @eccbuf: source buffer to get ECC bytes from
 783 + * @oobbuf: OOB buffer
 784 + * @start: first ECC byte to set
 785 + * @nbytes: number of ECC bytes to set
 786 + *
 787 + * Works like mtd_ooblayout_set_bytes(), except it acts on ECC bytes.
 788 + *
 789 + * Returns zero on success, a negative error code otherwise.
 790 + */
 791 +int mtd_ooblayout_set_eccbytes(struct mtd_info *mtd, const u8 *eccbuf,
 792 +                              u8 *oobbuf, int start, int nbytes)
 793 +{
 794 +       return mtd_ooblayout_set_bytes(mtd, eccbuf, oobbuf, start, nbytes,
 795 +                                      mtd_ooblayout_ecc);
 796 +}
 797 +EXPORT_SYMBOL_GPL(mtd_ooblayout_set_eccbytes);
 798 +
 799 +/**
 800 + * mtd_ooblayout_get_databytes - extract data bytes from the oob buffer
 801 + * @mtd: mtd info structure
 802 + * @databuf: destination buffer to store ECC bytes
 803 + * @oobbuf: OOB buffer
 804 + * @start: first ECC byte to retrieve
 805 + * @nbytes: number of ECC bytes to retrieve
 806 + *
 807 + * Works like mtd_ooblayout_get_bytes(), except it acts on free bytes.
 808 + *
 809 + * Returns zero on success, a negative error code otherwise.
 810 + */
 811 +int mtd_ooblayout_get_databytes(struct mtd_info *mtd, u8 *databuf,
 812 +                               const u8 *oobbuf, int start, int nbytes)
 813 +{
 814 +       return mtd_ooblayout_get_bytes(mtd, databuf, oobbuf, start, nbytes,
 815 +                                      mtd_ooblayout_free);
 816 +}
 817 +EXPORT_SYMBOL_GPL(mtd_ooblayout_get_databytes);
 818 +
 819 +/**
 820 + * mtd_ooblayout_get_eccbytes - set data bytes into the oob buffer
 821 + * @mtd: mtd info structure
 822 + * @eccbuf: source buffer to get data bytes from
 823 + * @oobbuf: OOB buffer
 824 + * @start: first ECC byte to set
 825 + * @nbytes: number of ECC bytes to set
 826 + *
 827 + * Works like mtd_ooblayout_get_bytes(), except it acts on free bytes.
 828 + *
 829 + * Returns zero on success, a negative error code otherwise.
 830 + */
 831 +int mtd_ooblayout_set_databytes(struct mtd_info *mtd, const u8 *databuf,
 832 +                               u8 *oobbuf, int start, int nbytes)
 833 +{
 834 +       return mtd_ooblayout_set_bytes(mtd, databuf, oobbuf, start, nbytes,
 835 +                                      mtd_ooblayout_free);
 836 +}
 837 +EXPORT_SYMBOL_GPL(mtd_ooblayout_set_databytes);
 838 +
 839 +/**
 840 + * mtd_ooblayout_count_freebytes - count the number of free bytes in OOB
 841 + * @mtd: mtd info structure
 842 + *
 843 + * Works like mtd_ooblayout_count_bytes(), except it count free bytes.
 844 + *
 845 + * Returns zero on success, a negative error code otherwise.
 846 + */
 847 +int mtd_ooblayout_count_freebytes(struct mtd_info *mtd)
 848 +{
 849 +       return mtd_ooblayout_count_bytes(mtd, mtd_ooblayout_free);
 850 +}
 851 +EXPORT_SYMBOL_GPL(mtd_ooblayout_count_freebytes);
 852 +
 853 +/**
 854 + * mtd_ooblayout_count_freebytes - count the number of ECC bytes in OOB
 855 + * @mtd: mtd info structure
 856 + *
 857 + * Works like mtd_ooblayout_count_bytes(), except it count ECC bytes.
 858 + *
 859 + * Returns zero on success, a negative error code otherwise.
 860 + */
 861 +int mtd_ooblayout_count_eccbytes(struct mtd_info *mtd)
 862 +{
 863 +       return mtd_ooblayout_count_bytes(mtd, mtd_ooblayout_ecc);
 864 +}
 865 +EXPORT_SYMBOL_GPL(mtd_ooblayout_count_eccbytes);
 866 +
 867  /*
 868   * Method to access the protection register area, present in some flash
 869   * devices. The user data is one time programmable but the factory data is read
 870 --- a/drivers/mtd/mtdcore.h
 871 +++ b/drivers/mtd/mtdcore.h
 872 @@ -10,10 +10,15 @@ int add_mtd_device(struct mtd_info *mtd)
 873  int del_mtd_device(struct mtd_info *mtd);
 874  int add_mtd_partitions(struct mtd_info *, const struct mtd_partition *, int);
 875  int del_mtd_partitions(struct mtd_info *);
 876 +
 877 +struct mtd_partitions;
 878 +
 879  int parse_mtd_partitions(struct mtd_info *master, const char * const *types,
 880 -                        struct mtd_partition **pparts,
 881 +                        struct mtd_partitions *pparts,
 882                          struct mtd_part_parser_data *data);
 883
 884 +void mtd_part_parser_cleanup(struct mtd_partitions *parts);
 885 +
 886  int __init init_mtdchar(void);
 887  void __exit cleanup_mtdchar(void);
 888
 889 --- a/drivers/mtd/mtdpart.c
 890 +++ b/drivers/mtd/mtdpart.c
 891 @@ -55,9 +55,12 @@ static void mtd_partition_split(struct m
 892
 893  /*
 894   * Given a pointer to the MTD object in the mtd_part structure, we can retrieve
 895 - * the pointer to that structure with this macro.
 896 + * the pointer to that structure.
 897   */
 898 -#define PART(x)  ((struct mtd_part *)(x))
 899 +static inline struct mtd_part *mtd_to_part(const struct mtd_info *mtd)
 900 +{
 901 +       return container_of(mtd, struct mtd_part, mtd);
 902 +}
 903
 904
 905  /*
 906 @@ -68,7 +71,7 @@ static void mtd_partition_split(struct m
 907  static int part_read(struct mtd_info *mtd, loff_t from, size_t len,
 908                 size_t *retlen, u_char *buf)
 909  {
 910 -       struct mtd_part *part = PART(mtd);
 911 +       struct mtd_part *part = mtd_to_part(mtd);
 912         struct mtd_ecc_stats stats;
 913         int res;
 914
 915 @@ -87,7 +90,7 @@ static int part_read(struct mtd_info *mt
 916  static int part_point(struct mtd_info *mtd, loff_t from, size_t len,
 917                 size_t *retlen, void **virt, resource_size_t *phys)
 918  {
 919 -       struct mtd_part *part = PART(mtd);
 920 +       struct mtd_part *part = mtd_to_part(mtd);
 921
 922         return part->master->_point(part->master, from + part->offset, len,
 923                                     retlen, virt, phys);
 924 @@ -95,7 +98,7 @@ static int part_point(struct mtd_info *m
 925
 926  static int part_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
 927  {
 928 -       struct mtd_part *part = PART(mtd);
 929 +       struct mtd_part *part = mtd_to_part(mtd);
 930
 931         return part->master->_unpoint(part->master, from + part->offset, len);
 932  }
 933 @@ -105,7 +108,7 @@ static unsigned long part_get_unmapped_a
 934                                             unsigned long offset,
 935                                             unsigned long flags)
 936  {
 937 -       struct mtd_part *part = PART(mtd);
 938 +       struct mtd_part *part = mtd_to_part(mtd);
 939
 940         offset += part->offset;
 941         return part->master->_get_unmapped_area(part->master, len, offset,
 942 @@ -115,7 +118,7 @@ static unsigned long part_get_unmapped_a
 943  static int part_read_oob(struct mtd_info *mtd, loff_t from,
 944                 struct mtd_oob_ops *ops)
 945  {
 946 -       struct mtd_part *part = PART(mtd);
 947 +       struct mtd_part *part = mtd_to_part(mtd);
 948         int res;
 949
 950         if (from >= mtd->size)
 951 @@ -130,10 +133,7 @@ static int part_read_oob(struct mtd_info
 952         if (ops->oobbuf) {
 953                 size_t len, pages;
 954
 955 -               if (ops->mode == MTD_OPS_AUTO_OOB)
 956 -                       len = mtd->oobavail;
 957 -               else
 958 -                       len = mtd->oobsize;
 959 +               len = mtd_oobavail(mtd, ops);
 960                 pages = mtd_div_by_ws(mtd->size, mtd);
 961                 pages -= mtd_div_by_ws(from, mtd);
 962                 if (ops->ooboffs + ops->ooblen > pages * len)
 963 @@ -153,7 +153,7 @@ static int part_read_oob(struct mtd_info
 964  static int part_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
 965                 size_t len, size_t *retlen, u_char *buf)
 966  {
 967 -       struct mtd_part *part = PART(mtd);
 968 +       struct mtd_part *part = mtd_to_part(mtd);
 969         return part->master->_read_user_prot_reg(part->master, from, len,
 970                                                  retlen, buf);
 971  }
 972 @@ -161,7 +161,7 @@ static int part_read_user_prot_reg(struc
 973  static int part_get_user_prot_info(struct mtd_info *mtd, size_t len,
 974                                    size_t *retlen, struct otp_info *buf)
 975  {
 976 -       struct mtd_part *part = PART(mtd);
 977 +       struct mtd_part *part = mtd_to_part(mtd);
 978         return part->master->_get_user_prot_info(part->master, len, retlen,
 979                                                  buf);
 980  }
 981 @@ -169,7 +169,7 @@ static int part_get_user_prot_info(struc
 982  static int part_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
 983                 size_t len, size_t *retlen, u_char *buf)
 984  {
 985 -       struct mtd_part *part = PART(mtd);
 986 +       struct mtd_part *part = mtd_to_part(mtd);
 987         return part->master->_read_fact_prot_reg(part->master, from, len,
 988                                                  retlen, buf);
 989  }
 990 @@ -177,7 +177,7 @@ static int part_read_fact_prot_reg(struc
 991  static int part_get_fact_prot_info(struct mtd_info *mtd, size_t len,
 992                                    size_t *retlen, struct otp_info *buf)
 993  {
 994 -       struct mtd_part *part = PART(mtd);
 995 +       struct mtd_part *part = mtd_to_part(mtd);
 996         return part->master->_get_fact_prot_info(part->master, len, retlen,
 997                                                  buf);
 998  }
 999 @@ -185,7 +185,7 @@ static int part_get_fact_prot_info(struc
1000  static int part_write(struct mtd_info *mtd, loff_t to, size_t len,
1001                 size_t *retlen, const u_char *buf)
1002  {
1003 -       struct mtd_part *part = PART(mtd);
1004 +       struct mtd_part *part = mtd_to_part(mtd);
1005         return part->master->_write(part->master, to + part->offset, len,
1006                                     retlen, buf);
1007  }
1008 @@ -193,7 +193,7 @@ static int part_write(struct mtd_info *m
1009  static int part_panic_write(struct mtd_info *mtd, loff_t to, size_t len,
1010                 size_t *retlen, const u_char *buf)
1011  {
1012 -       struct mtd_part *part = PART(mtd);
1013 +       struct mtd_part *part = mtd_to_part(mtd);
1014         return part->master->_panic_write(part->master, to + part->offset, len,
1015                                           retlen, buf);
1016  }
1017 @@ -201,7 +201,7 @@ static int part_panic_write(struct mtd_i
1018  static int part_write_oob(struct mtd_info *mtd, loff_t to,
1019                 struct mtd_oob_ops *ops)
1020  {
1021 -       struct mtd_part *part = PART(mtd);
1022 +       struct mtd_part *part = mtd_to_part(mtd);
1023
1024         if (to >= mtd->size)
1025                 return -EINVAL;
1026 @@ -213,7 +213,7 @@ static int part_write_oob(struct mtd_inf
1027  static int part_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
1028                 size_t len, size_t *retlen, u_char *buf)
1029  {
1030 -       struct mtd_part *part = PART(mtd);
1031 +       struct mtd_part *part = mtd_to_part(mtd);
1032         return part->master->_write_user_prot_reg(part->master, from, len,
1033                                                   retlen, buf);
1034  }
1035 @@ -221,21 +221,21 @@ static int part_write_user_prot_reg(stru
1036  static int part_lock_user_prot_reg(struct mtd_info *mtd, loff_t from,
1037                 size_t len)
1038  {
1039 -       struct mtd_part *part = PART(mtd);
1040 +       struct mtd_part *part = mtd_to_part(mtd);
1041         return part->master->_lock_user_prot_reg(part->master, from, len);
1042  }
1043
1044  static int part_writev(struct mtd_info *mtd, const struct kvec *vecs,
1045                 unsigned long count, loff_t to, size_t *retlen)
1046  {
1047 -       struct mtd_part *part = PART(mtd);
1048 +       struct mtd_part *part = mtd_to_part(mtd);
1049         return part->master->_writev(part->master, vecs, count,
1050                                      to + part->offset, retlen);
1051  }
1052
1053  static int part_erase(struct mtd_info *mtd, struct erase_info *instr)
1054  {
1055 -       struct mtd_part *part = PART(mtd);
1056 +       struct mtd_part *part = mtd_to_part(mtd);
1057         int ret;
1058
1059
1060 @@ -299,7 +299,7 @@ static int part_erase(struct mtd_info *m
1061  void mtd_erase_callback(struct erase_info *instr)
1062  {
1063         if (instr->mtd->_erase == part_erase) {
1064 -               struct mtd_part *part = PART(instr->mtd);
1065 +               struct mtd_part *part = mtd_to_part(instr->mtd);
1066                 size_t wrlen = 0;
1067
1068                 if (instr->mtd->flags & MTD_ERASE_PARTIAL) {
1069 @@ -330,13 +330,13 @@ EXPORT_SYMBOL_GPL(mtd_erase_callback);
1070
1071  static int part_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1072  {
1073 -       struct mtd_part *part = PART(mtd);
1074 +       struct mtd_part *part = mtd_to_part(mtd);
1075         return part->master->_lock(part->master, ofs + part->offset, len);
1076  }
1077
1078  static int part_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1079  {
1080 -       struct mtd_part *part = PART(mtd);
1081 +       struct mtd_part *part = mtd_to_part(mtd);
1082
1083         ofs += part->offset;
1084         if (mtd->flags & MTD_ERASE_PARTIAL) {
1085 @@ -349,45 +349,45 @@ static int part_unlock(struct mtd_info *
1086
1087  static int part_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1088  {
1089 -       struct mtd_part *part = PART(mtd);
1090 +       struct mtd_part *part = mtd_to_part(mtd);
1091         return part->master->_is_locked(part->master, ofs + part->offset, len);
1092  }
1093
1094  static void part_sync(struct mtd_info *mtd)
1095  {
1096 -       struct mtd_part *part = PART(mtd);
1097 +       struct mtd_part *part = mtd_to_part(mtd);
1098         part->master->_sync(part->master);
1099  }
1100
1101  static int part_suspend(struct mtd_info *mtd)
1102  {
1103 -       struct mtd_part *part = PART(mtd);
1104 +       struct mtd_part *part = mtd_to_part(mtd);
1105         return part->master->_suspend(part->master);
1106  }
1107
1108  static void part_resume(struct mtd_info *mtd)
1109  {
1110 -       struct mtd_part *part = PART(mtd);
1111 +       struct mtd_part *part = mtd_to_part(mtd);
1112         part->master->_resume(part->master);
1113  }
1114
1115  static int part_block_isreserved(struct mtd_info *mtd, loff_t ofs)
1116  {
1117 -       struct mtd_part *part = PART(mtd);
1118 +       struct mtd_part *part = mtd_to_part(mtd);
1119         ofs += part->offset;
1120         return part->master->_block_isreserved(part->master, ofs);
1121  }
1122
1123  static int part_block_isbad(struct mtd_info *mtd, loff_t ofs)
1124  {
1125 -       struct mtd_part *part = PART(mtd);
1126 +       struct mtd_part *part = mtd_to_part(mtd);
1127         ofs += part->offset;
1128         return part->master->_block_isbad(part->master, ofs);
1129  }
1130
1131  static int part_block_markbad(struct mtd_info *mtd, loff_t ofs)
1132  {
1133 -       struct mtd_part *part = PART(mtd);
1134 +       struct mtd_part *part = mtd_to_part(mtd);
1135         int res;
1136
1137         ofs += part->offset;
1138 @@ -397,6 +397,27 @@ static int part_block_markbad(struct mtd
1139         return res;
1140  }
1141
1142 +static int part_ooblayout_ecc(struct mtd_info *mtd, int section,
1143 +                             struct mtd_oob_region *oobregion)
1144 +{
1145 +       struct mtd_part *part = mtd_to_part(mtd);
1146 +
1147 +       return mtd_ooblayout_ecc(part->master, section, oobregion);
1148 +}
1149 +
1150 +static int part_ooblayout_free(struct mtd_info *mtd, int section,
1151 +                              struct mtd_oob_region *oobregion)
1152 +{
1153 +       struct mtd_part *part = mtd_to_part(mtd);
1154 +
1155 +       return mtd_ooblayout_free(part->master, section, oobregion);
1156 +}
1157 +
1158 +static const struct mtd_ooblayout_ops part_ooblayout_ops = {
1159 +       .ecc = part_ooblayout_ecc,
1160 +       .free = part_ooblayout_free,
1161 +};
1162 +
1163  static inline void free_partition(struct mtd_part *p)
1164  {
1165         kfree(p->mtd.name);
1166 @@ -614,7 +635,7 @@ static struct mtd_part *allocate_partiti
1167                         slave->mtd.erasesize = slave->mtd.size;
1168         }
1169
1170 -       slave->mtd.ecclayout = master->ecclayout;
1171 +       mtd_set_ooblayout(&slave->mtd, &part_ooblayout_ops);
1172         slave->mtd.ecc_step_size = master->ecc_step_size;
1173         slave->mtd.ecc_strength = master->ecc_strength;
1174         slave->mtd.bitflip_threshold = master->bitflip_threshold;
1175 @@ -639,7 +660,7 @@ static ssize_t mtd_partition_offset_show
1176                 struct device_attribute *attr, char *buf)
1177  {
1178         struct mtd_info *mtd = dev_get_drvdata(dev);
1179 -       struct mtd_part *part = PART(mtd);
1180 +       struct mtd_part *part = mtd_to_part(mtd);
1181         return snprintf(buf, PAGE_SIZE, "%lld\n", part->offset);
1182  }
1183
1184 @@ -677,11 +698,10 @@ int mtd_add_partition(struct mtd_info *m
1185         if (length <= 0)
1186                 return -EINVAL;
1187
1188 +       memset(&part, 0, sizeof(part));
1189         part.name = name;
1190         part.size = length;
1191         part.offset = offset;
1192 -       part.mask_flags = 0;
1193 -       part.ecclayout = NULL;
1194
1195         new = allocate_partition(master, &part, -1, offset);
1196         if (IS_ERR(new))
1197 @@ -845,7 +865,7 @@ int add_mtd_partitions(struct mtd_info *
1198  static DEFINE_SPINLOCK(part_parser_lock);
1199  static LIST_HEAD(part_parsers);
1200
1201 -static struct mtd_part_parser *get_partition_parser(const char *name)
1202 +static struct mtd_part_parser *mtd_part_parser_get(const char *name)
1203  {
1204         struct mtd_part_parser *p, *ret = NULL;
1205
1206 @@ -862,7 +882,20 @@ static struct mtd_part_parser *get_parti
1207         return ret;
1208  }
1209
1210 -#define put_partition_parser(p) do { module_put((p)->owner); } while (0)
1211 +static inline void mtd_part_parser_put(const struct mtd_part_parser *p)
1212 +{
1213 +       module_put(p->owner);
1214 +}
1215 +
1216 +/*
1217 + * Many partition parsers just expected the core to kfree() all their data in
1218 + * one chunk. Do that by default.
1219 + */
1220 +static void mtd_part_parser_cleanup_default(const struct mtd_partition *pparts,
1221 +                                           int nr_parts)
1222 +{
1223 +       kfree(pparts);
1224 +}
1225
1226  static struct mtd_part_parser *
1227  get_partition_parser_by_type(enum mtd_parser_type type,
1228 @@ -874,7 +907,7 @@ get_partition_parser_by_type(enum mtd_pa
1229
1230         p = list_prepare_entry(start, &part_parsers, list);
1231         if (start)
1232 -               put_partition_parser(start);
1233 +               mtd_part_parser_put(start);
1234
1235         list_for_each_entry_continue(p, &part_parsers, list) {
1236                 if (p->type == type && try_module_get(p->owner)) {
1237 @@ -888,13 +921,19 @@ get_partition_parser_by_type(enum mtd_pa
1238         return ret;
1239  }
1240
1241 -void register_mtd_parser(struct mtd_part_parser *p)
1242 -{
1243 +int __register_mtd_parser(struct mtd_part_parser *p, struct module *owner)
1244 + {
1245 +       p->owner = owner;
1246 +
1247 +       if (!p->cleanup)
1248 +               p->cleanup = &mtd_part_parser_cleanup_default;
1249 +
1250         spin_lock(&part_parser_lock);
1251         list_add(&p->list, &part_parsers);
1252         spin_unlock(&part_parser_lock);
1253 +       return 0;
1254  }
1255 -EXPORT_SYMBOL_GPL(register_mtd_parser);
1256 +EXPORT_SYMBOL_GPL(__register_mtd_parser);
1257
1258  void deregister_mtd_parser(struct mtd_part_parser *p)
1259  {
1260 @@ -954,7 +993,7 @@ static const char * const default_mtd_pa
1261   * parse_mtd_partitions - parse MTD partitions
1262   * @master: the master partition (describes whole MTD device)
1263   * @types: names of partition parsers to try or %NULL
1264 - * @pparts: array of partitions found is returned here
1265 + * @pparts: info about partitions found is returned here
1266   * @data: MTD partition parser-specific data
1267   *
1268   * This function tries to find partition on MTD device @master. It uses MTD
1269 @@ -966,45 +1005,42 @@ static const char * const default_mtd_pa
1270   *
1271   * This function may return:
1272   * o a negative error code in case of failure
1273 - * o zero if no partitions were found
1274 - * o a positive number of found partitions, in which case on exit @pparts will
1275 - *   point to an array containing this number of &struct mtd_info objects.
1276 + * o zero otherwise, and @pparts will describe the partitions, number of
1277 + *   partitions, and the parser which parsed them. Caller must release
1278 + *   resources with mtd_part_parser_cleanup() when finished with the returned
1279 + *   data.
1280   */
1281  int parse_mtd_partitions(struct mtd_info *master, const char *const *types,
1282 -                        struct mtd_partition **pparts,
1283 +                        struct mtd_partitions *pparts,
1284                          struct mtd_part_parser_data *data)
1285  {
1286         struct mtd_part_parser *parser;
1287         int ret, err = 0;
1288         const char *const *types_of = NULL;
1289
1290 -       if (data && data->of_node) {
1291 -               types_of = of_get_probes(data->of_node);
1292 -               if (types_of != NULL)
1293 -                       types = types_of;
1294 -       }
1295 -
1296         if (!types)
1297                 types = default_mtd_part_types;
1298
1299         for ( ; *types; types++) {
1300                 pr_debug("%s: parsing partitions %s\n", master->name, *types);
1301 -               parser = get_partition_parser(*types);
1302 +               parser = mtd_part_parser_get(*types);
1303                 if (!parser && !request_module("%s", *types))
1304 -                       parser = get_partition_parser(*types);
1305 +                       parser = mtd_part_parser_get(*types);
1306                 pr_debug("%s: got parser %s\n", master->name,
1307                          parser ? parser->name : NULL);
1308                 if (!parser)
1309                         continue;
1310 -               ret = (*parser->parse_fn)(master, pparts, data);
1311 +               ret = (*parser->parse_fn)(master, &pparts->parts, data);
1312                 pr_debug("%s: parser %s: %i\n",
1313                          master->name, parser->name, ret);
1314 -               put_partition_parser(parser);
1315                 if (ret > 0) {
1316                         printk(KERN_NOTICE "%d %s partitions found on MTD device %s\n",
1317                                ret, parser->name, master->name);
1318 -                       return ret;
1319 +                       pparts->nr_parts = ret;
1320 +                       pparts->parser = parser;
1321 +                       return 0;
1322                 }
1323 +               mtd_part_parser_put(parser);
1324                 /*
1325                  * Stash the first error we see; only report it if no parser
1326                  * succeeds
1327 @@ -1034,7 +1070,7 @@ int parse_mtd_partitions_by_type(struct
1328                 ret = (*parser->parse_fn)(master, pparts, data);
1329
1330                 if (ret > 0) {
1331 -                       put_partition_parser(parser);
1332 +                       mtd_part_parser_put(parser);
1333                         printk(KERN_NOTICE
1334                                "%d %s partitions found on MTD device %s\n",
1335                                ret, parser->name, master->name);
1336 @@ -1048,6 +1084,22 @@ int parse_mtd_partitions_by_type(struct
1337  }
1338  EXPORT_SYMBOL_GPL(parse_mtd_partitions_by_type);
1339
1340 +void mtd_part_parser_cleanup(struct mtd_partitions *parts)
1341 +{
1342 +       const struct mtd_part_parser *parser;
1343 +
1344 +       if (!parts)
1345 +               return;
1346 +
1347 +       parser = parts->parser;
1348 +       if (parser) {
1349 +               if (parser->cleanup)
1350 +                       parser->cleanup(parts->parts, parts->nr_parts);
1351 +
1352 +               mtd_part_parser_put(parser);
1353 +       }
1354 +}
1355 +
1356  int mtd_is_partition(const struct mtd_info *mtd)
1357  {
1358         struct mtd_part *part;
1359 @@ -1070,7 +1122,7 @@ struct mtd_info *mtdpart_get_master(cons
1360         if (!mtd_is_partition(mtd))
1361                 return (struct mtd_info *)mtd;
1362
1363 -       return PART(mtd)->master;
1364 +       return mtd_to_part(mtd)->master;
1365  }
1366  EXPORT_SYMBOL_GPL(mtdpart_get_master);
1367
1368 @@ -1079,7 +1131,7 @@ uint64_t mtdpart_get_offset(const struct
1369         if (!mtd_is_partition(mtd))
1370                 return 0;
1371
1372 -       return PART(mtd)->offset;
1373 +       return mtd_to_part(mtd)->offset;
1374  }
1375  EXPORT_SYMBOL_GPL(mtdpart_get_offset);
1376
1377 @@ -1089,6 +1141,6 @@ uint64_t mtd_get_device_size(const struc
1378         if (!mtd_is_partition(mtd))
1379                 return mtd->size;
1380
1381 -       return PART(mtd)->master->size;
1382 +       return mtd_to_part(mtd)->master->size;
1383  }
1384  EXPORT_SYMBOL_GPL(mtd_get_device_size);
1385 --- a/drivers/mtd/mtdswap.c
1386 +++ b/drivers/mtd/mtdswap.c
1387 @@ -346,7 +346,7 @@ static int mtdswap_read_markers(struct m
1388         if (mtd_can_have_bb(d->mtd) && mtd_block_isbad(d->mtd, offset))
1389                 return MTDSWAP_SCANNED_BAD;
1390
1391 -       ops.ooblen = 2 * d->mtd->ecclayout->oobavail;
1392 +       ops.ooblen = 2 * d->mtd->oobavail;
1393         ops.oobbuf = d->oob_buf;
1394         ops.ooboffs = 0;
1395         ops.datbuf = NULL;
1396 @@ -359,7 +359,7 @@ static int mtdswap_read_markers(struct m
1397
1398         data = (struct mtdswap_oobdata *)d->oob_buf;
1399         data2 = (struct mtdswap_oobdata *)
1400 -               (d->oob_buf + d->mtd->ecclayout->oobavail);
1401 +               (d->oob_buf + d->mtd->oobavail);
1402
1403         if (le16_to_cpu(data->magic) == MTDSWAP_MAGIC_CLEAN) {
1404                 eb->erase_count = le32_to_cpu(data->count);
1405 @@ -933,7 +933,7 @@ static unsigned int mtdswap_eblk_passes(
1406
1407         ops.mode = MTD_OPS_AUTO_OOB;
1408         ops.len = mtd->writesize;
1409 -       ops.ooblen = mtd->ecclayout->oobavail;
1410 +       ops.ooblen = mtd->oobavail;
1411         ops.ooboffs = 0;
1412         ops.datbuf = d->page_buf;
1413         ops.oobbuf = d->oob_buf;
1414 @@ -945,7 +945,7 @@ static unsigned int mtdswap_eblk_passes(
1415                 for (i = 0; i < mtd_pages; i++) {
1416                         patt = mtdswap_test_patt(test + i);
1417                         memset(d->page_buf, patt, mtd->writesize);
1418 -                       memset(d->oob_buf, patt, mtd->ecclayout->oobavail);
1419 +                       memset(d->oob_buf, patt, mtd->oobavail);
1420                         ret = mtd_write_oob(mtd, pos, &ops);
1421                         if (ret)
1422                                 goto error;
1423 @@ -964,7 +964,7 @@ static unsigned int mtdswap_eblk_passes(
1424                                 if (p1[j] != patt)
1425                                         goto error;
1426
1427 -                       for (j = 0; j < mtd->ecclayout->oobavail; j++)
1428 +                       for (j = 0; j < mtd->oobavail; j++)
1429                                 if (p2[j] != (unsigned char)patt)
1430                                         goto error;
1431
1432 @@ -1387,7 +1387,7 @@ static int mtdswap_init(struct mtdswap_d
1433         if (!d->page_buf)
1434                 goto page_buf_fail;
1435
1436 -       d->oob_buf = kmalloc(2 * mtd->ecclayout->oobavail, GFP_KERNEL);
1437 +       d->oob_buf = kmalloc(2 * mtd->oobavail, GFP_KERNEL);
1438         if (!d->oob_buf)
1439                 goto oob_buf_fail;
1440
1441 @@ -1417,7 +1417,6 @@ static void mtdswap_add_mtd(struct mtd_b
1442         unsigned long part;
1443         unsigned int eblocks, eavailable, bad_blocks, spare_cnt;
1444         uint64_t swap_size, use_size, size_limit;
1445 -       struct nand_ecclayout *oinfo;
1446         int ret;
1447
1448         parts = &partitions[0];
1449 @@ -1447,17 +1446,10 @@ static void mtdswap_add_mtd(struct mtd_b
1450                 return;
1451         }
1452
1453 -       oinfo = mtd->ecclayout;
1454 -       if (!oinfo) {
1455 -               printk(KERN_ERR "%s: mtd%d does not have OOB\n",
1456 -                       MTDSWAP_PREFIX, mtd->index);
1457 -               return;
1458 -       }
1459 -
1460 -       if (!mtd->oobsize || oinfo->oobavail < MTDSWAP_OOBSIZE) {
1461 +       if (!mtd->oobsize || mtd->oobavail < MTDSWAP_OOBSIZE) {
1462                 printk(KERN_ERR "%s: Not enough free bytes in OOB, "
1463                         "%d available, %zu needed.\n",
1464 -                       MTDSWAP_PREFIX, oinfo->oobavail, MTDSWAP_OOBSIZE);
1465 +                       MTDSWAP_PREFIX, mtd->oobavail, MTDSWAP_OOBSIZE);
1466                 return;
1467         }
1468
1469 --- a/drivers/mtd/nand/Kconfig
1470 +++ b/drivers/mtd/nand/Kconfig
1471 @@ -55,7 +55,7 @@ config MTD_NAND_DENALI_PCI
1472  config MTD_NAND_DENALI_DT
1473         tristate "Support Denali NAND controller as a DT device"
1474         select MTD_NAND_DENALI
1475 -       depends on HAS_DMA && HAVE_CLK
1476 +       depends on HAS_DMA && HAVE_CLK && OF
1477         help
1478           Enable the driver for NAND flash on platforms using a Denali NAND
1479           controller as a DT device.
1480 @@ -74,6 +74,7 @@ config MTD_NAND_DENALI_SCRATCH_REG_ADDR
1481  config MTD_NAND_GPIO
1482         tristate "GPIO assisted NAND Flash driver"
1483         depends on GPIOLIB || COMPILE_TEST
1484 +       depends on HAS_IOMEM
1485         help
1486           This enables a NAND flash driver where control signals are
1487           connected to GPIO pins, and commands and data are communicated
1488 @@ -310,6 +311,7 @@ config MTD_NAND_CAFE
1489  config MTD_NAND_CS553X
1490         tristate "NAND support for CS5535/CS5536 (AMD Geode companion chip)"
1491         depends on X86_32
1492 +       depends on !UML && HAS_IOMEM
1493         help
1494           The CS553x companion chips for the AMD Geode processor
1495           include NAND flash controllers with built-in hardware ECC
1496 @@ -463,6 +465,7 @@ config MTD_NAND_MPC5121_NFC
1497  config MTD_NAND_VF610_NFC
1498         tristate "Support for Freescale NFC for VF610/MPC5125"
1499         depends on (SOC_VF610 || COMPILE_TEST)
1500 +       depends on HAS_IOMEM
1501         help
1502           Enables support for NAND Flash Controller on some Freescale
1503           processors like the VF610, MPC5125, MCF54418 or Kinetis K70.
1504 @@ -480,7 +483,7 @@ config MTD_NAND_MXC
1505
1506  config MTD_NAND_SH_FLCTL
1507         tristate "Support for NAND on Renesas SuperH FLCTL"
1508 -       depends on SUPERH || ARCH_SHMOBILE || COMPILE_TEST
1509 +       depends on SUPERH || COMPILE_TEST
1510         depends on HAS_IOMEM
1511         depends on HAS_DMA
1512         help
1513 @@ -519,6 +522,13 @@ config MTD_NAND_JZ4740
1514         help
1515                 Enables support for NAND Flash on JZ4740 SoC based boards.
1516
1517 +config MTD_NAND_JZ4780
1518 +       tristate "Support for NAND on JZ4780 SoC"
1519 +       depends on MACH_JZ4780 && JZ4780_NEMC
1520 +       help
1521 +         Enables support for NAND Flash connected to the NEMC on JZ4780 SoC
1522 +         based boards, using the BCH controller for hardware error correction.
1523 +
1524  config MTD_NAND_FSMC
1525         tristate "Support for NAND on ST Micros FSMC"
1526         depends on PLAT_SPEAR || ARCH_NOMADIK || ARCH_U8500 || MACH_U300
1527 @@ -546,4 +556,11 @@ config MTD_NAND_HISI504
1528         help
1529           Enables support for NAND controller on Hisilicon SoC Hip04.
1530
1531 +config MTD_NAND_QCOM
1532 +       tristate "Support for NAND on QCOM SoCs"
1533 +       depends on ARCH_QCOM
1534 +       help
1535 +         Enables support for NAND flash chips on SoCs containing the EBI2 NAND
1536 +         controller. This controller is found on IPQ806x SoC.
1537 +
1538  endif # MTD_NAND
1539 --- a/drivers/mtd/nand/Makefile
1540 +++ b/drivers/mtd/nand/Makefile
1541 @@ -49,11 +49,13 @@ obj-$(CONFIG_MTD_NAND_MPC5121_NFC)  += mp
1542  obj-$(CONFIG_MTD_NAND_VF610_NFC)       += vf610_nfc.o
1543  obj-$(CONFIG_MTD_NAND_RICOH)           += r852.o
1544  obj-$(CONFIG_MTD_NAND_JZ4740)          += jz4740_nand.o
1545 +obj-$(CONFIG_MTD_NAND_JZ4780)          += jz4780_nand.o jz4780_bch.o
1546  obj-$(CONFIG_MTD_NAND_GPMI_NAND)       += gpmi-nand/
1547  obj-$(CONFIG_MTD_NAND_XWAY)            += xway_nand.o
1548  obj-$(CONFIG_MTD_NAND_BCM47XXNFLASH)   += bcm47xxnflash/
1549  obj-$(CONFIG_MTD_NAND_SUNXI)           += sunxi_nand.o
1550  obj-$(CONFIG_MTD_NAND_HISI504)         += hisi504_nand.o
1551  obj-$(CONFIG_MTD_NAND_BRCMNAND)                += brcmnand/
1552 +obj-$(CONFIG_MTD_NAND_QCOM)            += qcom_nandc.o
1553
1554  nand-objs := nand_base.o nand_bbt.o nand_timings.o
1555 --- a/drivers/mtd/nand/nand_base.c
1556 +++ b/drivers/mtd/nand/nand_base.c
1557 @@ -48,50 +48,6 @@
1558  #include <linux/mtd/partitions.h>
1559  #include <linux/of_mtd.h>
1560
1561 -/* Define default oob placement schemes for large and small page devices */
1562 -static struct nand_ecclayout nand_oob_8 = {
1563 -       .eccbytes = 3,
1564 -       .eccpos = {0, 1, 2},
1565 -       .oobfree = {
1566 -               {.offset = 3,
1567 -                .length = 2},
1568 -               {.offset = 6,
1569 -                .length = 2} }
1570 -};
1571 -
1572 -static struct nand_ecclayout nand_oob_16 = {
1573 -       .eccbytes = 6,
1574 -       .eccpos = {0, 1, 2, 3, 6, 7},
1575 -       .oobfree = {
1576 -               {.offset = 8,
1577 -                . length = 8} }
1578 -};
1579 -
1580 -static struct nand_ecclayout nand_oob_64 = {
1581 -       .eccbytes = 24,
1582 -       .eccpos = {
1583 -                  40, 41, 42, 43, 44, 45, 46, 47,
1584 -                  48, 49, 50, 51, 52, 53, 54, 55,
1585 -                  56, 57, 58, 59, 60, 61, 62, 63},
1586 -       .oobfree = {
1587 -               {.offset = 2,
1588 -                .length = 38} }
1589 -};
1590 -
1591 -static struct nand_ecclayout nand_oob_128 = {
1592 -       .eccbytes = 48,
1593 -       .eccpos = {
1594 -                  80, 81, 82, 83, 84, 85, 86, 87,
1595 -                  88, 89, 90, 91, 92, 93, 94, 95,
1596 -                  96, 97, 98, 99, 100, 101, 102, 103,
1597 -                  104, 105, 106, 107, 108, 109, 110, 111,
1598 -                  112, 113, 114, 115, 116, 117, 118, 119,
1599 -                  120, 121, 122, 123, 124, 125, 126, 127},
1600 -       .oobfree = {
1601 -               {.offset = 2,
1602 -                .length = 78} }
1603 -};
1604 -
1605  static int nand_get_device(struct mtd_info *mtd, int new_state);
1606
1607  static int nand_do_write_oob(struct mtd_info *mtd, loff_t to,
1608 @@ -103,10 +59,96 @@ static int nand_do_write_oob(struct mtd_
1609   */
1610  DEFINE_LED_TRIGGER(nand_led_trigger);
1611
1612 +/* Define default oob placement schemes for large and small page devices */
1613 +static int nand_ooblayout_ecc_sp(struct mtd_info *mtd, int section,
1614 +                                struct mtd_oob_region *oobregion)
1615 +{
1616 +       struct nand_chip *chip = mtd_to_nand(mtd);
1617 +       struct nand_ecc_ctrl *ecc = &chip->ecc;
1618 +
1619 +       if (section > 1)
1620 +               return -ERANGE;
1621 +
1622 +       if (!section) {
1623 +               oobregion->offset = 0;
1624 +               oobregion->length = 4;
1625 +       } else {
1626 +               oobregion->offset = 6;
1627 +               oobregion->length = ecc->total - 4;
1628 +       }
1629 +
1630 +       return 0;
1631 +}
1632 +
1633 +static int nand_ooblayout_free_sp(struct mtd_info *mtd, int section,
1634 +                                 struct mtd_oob_region *oobregion)
1635 +{
1636 +       if (section > 1)
1637 +               return -ERANGE;
1638 +
1639 +       if (mtd->oobsize == 16) {
1640 +               if (section)
1641 +                       return -ERANGE;
1642 +
1643 +               oobregion->length = 8;
1644 +               oobregion->offset = 8;
1645 +       } else {
1646 +               oobregion->length = 2;
1647 +               if (!section)
1648 +                       oobregion->offset = 3;
1649 +               else
1650 +                       oobregion->offset = 6;
1651 +       }
1652 +
1653 +       return 0;
1654 +}
1655 +
1656 +const struct mtd_ooblayout_ops nand_ooblayout_sp_ops = {
1657 +       .ecc = nand_ooblayout_ecc_sp,
1658 +       .free = nand_ooblayout_free_sp,
1659 +};
1660 +EXPORT_SYMBOL_GPL(nand_ooblayout_sp_ops);
1661 +
1662 +static int nand_ooblayout_ecc_lp(struct mtd_info *mtd, int section,
1663 +                                struct mtd_oob_region *oobregion)
1664 +{
1665 +       struct nand_chip *chip = mtd_to_nand(mtd);
1666 +       struct nand_ecc_ctrl *ecc = &chip->ecc;
1667 +
1668 +       if (section)
1669 +               return -ERANGE;
1670 +
1671 +       oobregion->length = ecc->total;
1672 +       oobregion->offset = mtd->oobsize - oobregion->length;
1673 +
1674 +       return 0;
1675 +}
1676 +
1677 +static int nand_ooblayout_free_lp(struct mtd_info *mtd, int section,
1678 +                                 struct mtd_oob_region *oobregion)
1679 +{
1680 +       struct nand_chip *chip = mtd_to_nand(mtd);
1681 +       struct nand_ecc_ctrl *ecc = &chip->ecc;
1682 +
1683 +       if (section)
1684 +               return -ERANGE;
1685 +
1686 +       oobregion->length = mtd->oobsize - ecc->total - 2;
1687 +       oobregion->offset = 2;
1688 +
1689 +       return 0;
1690 +}
1691 +
1692 +const struct mtd_ooblayout_ops nand_ooblayout_lp_ops = {
1693 +       .ecc = nand_ooblayout_ecc_lp,
1694 +       .free = nand_ooblayout_free_lp,
1695 +};
1696 +EXPORT_SYMBOL_GPL(nand_ooblayout_lp_ops);
1697 +
1698  static int check_offs_len(struct mtd_info *mtd,
1699                                         loff_t ofs, uint64_t len)
1700  {
1701 -       struct nand_chip *chip = mtd->priv;
1702 +       struct nand_chip *chip = mtd_to_nand(mtd);
1703         int ret = 0;
1704
1705         /* Start address must align on block boundary */
1706 @@ -132,7 +174,7 @@ static int check_offs_len(struct mtd_inf
1707   */
1708  static void nand_release_device(struct mtd_info *mtd)
1709  {
1710 -       struct nand_chip *chip = mtd->priv;
1711 +       struct nand_chip *chip = mtd_to_nand(mtd);
1712
1713         /* Release the controller and the chip */
1714         spin_lock(&chip->controller->lock);
1715 @@ -150,7 +192,7 @@ static void nand_release_device(struct m
1716   */
1717  static uint8_t nand_read_byte(struct mtd_info *mtd)
1718  {
1719 -       struct nand_chip *chip = mtd->priv;
1720 +       struct nand_chip *chip = mtd_to_nand(mtd);
1721         return readb(chip->IO_ADDR_R);
1722  }
1723
1724 @@ -163,7 +205,7 @@ static uint8_t nand_read_byte(struct mtd
1725   */
1726  static uint8_t nand_read_byte16(struct mtd_info *mtd)
1727  {
1728 -       struct nand_chip *chip = mtd->priv;
1729 +       struct nand_chip *chip = mtd_to_nand(mtd);
1730         return (uint8_t) cpu_to_le16(readw(chip->IO_ADDR_R));
1731  }
1732
1733 @@ -175,7 +217,7 @@ static uint8_t nand_read_byte16(struct m
1734   */
1735  static u16 nand_read_word(struct mtd_info *mtd)
1736  {
1737 -       struct nand_chip *chip = mtd->priv;
1738 +       struct nand_chip *chip = mtd_to_nand(mtd);
1739         return readw(chip->IO_ADDR_R);
1740  }
1741
1742 @@ -188,7 +230,7 @@ static u16 nand_read_word(struct mtd_inf
1743   */
1744  static void nand_select_chip(struct mtd_info *mtd, int chipnr)
1745  {
1746 -       struct nand_chip *chip = mtd->priv;
1747 +       struct nand_chip *chip = mtd_to_nand(mtd);
1748
1749         switch (chipnr) {
1750         case -1:
1751 @@ -211,7 +253,7 @@ static void nand_select_chip(struct mtd_
1752   */
1753  static void nand_write_byte(struct mtd_info *mtd, uint8_t byte)
1754  {
1755 -       struct nand_chip *chip = mtd->priv;
1756 +       struct nand_chip *chip = mtd_to_nand(mtd);
1757
1758         chip->write_buf(mtd, &byte, 1);
1759  }
1760 @@ -225,7 +267,7 @@ static void nand_write_byte(struct mtd_i
1761   */
1762  static void nand_write_byte16(struct mtd_info *mtd, uint8_t byte)
1763  {
1764 -       struct nand_chip *chip = mtd->priv;
1765 +       struct nand_chip *chip = mtd_to_nand(mtd);
1766         uint16_t word = byte;
1767
1768         /*
1769 @@ -257,7 +299,7 @@ static void nand_write_byte16(struct mtd
1770   */
1771  static void nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
1772  {
1773 -       struct nand_chip *chip = mtd->priv;
1774 +       struct nand_chip *chip = mtd_to_nand(mtd);
1775
1776         iowrite8_rep(chip->IO_ADDR_W, buf, len);
1777  }
1778 @@ -272,7 +314,7 @@ static void nand_write_buf(struct mtd_in
1779   */
1780  static void nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
1781  {
1782 -       struct nand_chip *chip = mtd->priv;
1783 +       struct nand_chip *chip = mtd_to_nand(mtd);
1784
1785         ioread8_rep(chip->IO_ADDR_R, buf, len);
1786  }
1787 @@ -287,7 +329,7 @@ static void nand_read_buf(struct mtd_inf
1788   */
1789  static void nand_write_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
1790  {
1791 -       struct nand_chip *chip = mtd->priv;
1792 +       struct nand_chip *chip = mtd_to_nand(mtd);
1793         u16 *p = (u16 *) buf;
1794
1795         iowrite16_rep(chip->IO_ADDR_W, p, len >> 1);
1796 @@ -303,7 +345,7 @@ static void nand_write_buf16(struct mtd_
1797   */
1798  static void nand_read_buf16(struct mtd_info *mtd, uint8_t *buf, int len)
1799  {
1800 -       struct nand_chip *chip = mtd->priv;
1801 +       struct nand_chip *chip = mtd_to_nand(mtd);
1802         u16 *p = (u16 *) buf;
1803
1804         ioread16_rep(chip->IO_ADDR_R, p, len >> 1);
1805 @@ -313,14 +355,13 @@ static void nand_read_buf16(struct mtd_i
1806   * nand_block_bad - [DEFAULT] Read bad block marker from the chip
1807   * @mtd: MTD device structure
1808   * @ofs: offset from device start
1809 - * @getchip: 0, if the chip is already selected
1810   *
1811   * Check, if the block is bad.
1812   */
1813 -static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
1814 +static int nand_block_bad(struct mtd_info *mtd, loff_t ofs)
1815  {
1816 -       int page, chipnr, res = 0, i = 0;
1817 -       struct nand_chip *chip = mtd->priv;
1818 +       int page, res = 0, i = 0;
1819 +       struct nand_chip *chip = mtd_to_nand(mtd);
1820         u16 bad;
1821
1822         if (chip->bbt_options & NAND_BBT_SCANLASTPAGE)
1823 @@ -328,15 +369,6 @@ static int nand_block_bad(struct mtd_inf
1824
1825         page = (int)(ofs >> chip->page_shift) & chip->pagemask;
1826
1827 -       if (getchip) {
1828 -               chipnr = (int)(ofs >> chip->chip_shift);
1829 -
1830 -               nand_get_device(mtd, FL_READING);
1831 -
1832 -               /* Select the NAND device */
1833 -               chip->select_chip(mtd, chipnr);
1834 -       }
1835 -
1836         do {
1837                 if (chip->options & NAND_BUSWIDTH_16) {
1838                         chip->cmdfunc(mtd, NAND_CMD_READOOB,
1839 @@ -361,11 +393,6 @@ static int nand_block_bad(struct mtd_inf
1840                 i++;
1841         } while (!res && i < 2 && (chip->bbt_options & NAND_BBT_SCAN2NDPAGE));
1842
1843 -       if (getchip) {
1844 -               chip->select_chip(mtd, -1);
1845 -               nand_release_device(mtd);
1846 -       }
1847 -
1848         return res;
1849  }
1850
1851 @@ -380,7 +407,7 @@ static int nand_block_bad(struct mtd_inf
1852   */
1853  static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
1854  {
1855 -       struct nand_chip *chip = mtd->priv;
1856 +       struct nand_chip *chip = mtd_to_nand(mtd);
1857         struct mtd_oob_ops ops;
1858         uint8_t buf[2] = { 0, 0 };
1859         int ret = 0, res, i = 0;
1860 @@ -430,7 +457,7 @@ static int nand_default_block_markbad(st
1861  */
1862  static int nand_block_markbad_lowlevel(struct mtd_info *mtd, loff_t ofs)
1863  {
1864 -       struct nand_chip *chip = mtd->priv;
1865 +       struct nand_chip *chip = mtd_to_nand(mtd);
1866         int res, ret = 0;
1867
1868         if (!(chip->bbt_options & NAND_BBT_NO_OOB_BBM)) {
1869 @@ -471,7 +498,7 @@ static int nand_block_markbad_lowlevel(s
1870   */
1871  static int nand_check_wp(struct mtd_info *mtd)
1872  {
1873 -       struct nand_chip *chip = mtd->priv;
1874 +       struct nand_chip *chip = mtd_to_nand(mtd);
1875
1876         /* Broken xD cards report WP despite being writable */
1877         if (chip->options & NAND_BROKEN_XD)
1878 @@ -491,7 +518,7 @@ static int nand_check_wp(struct mtd_info
1879   */
1880  static int nand_block_isreserved(struct mtd_info *mtd, loff_t ofs)
1881  {
1882 -       struct nand_chip *chip = mtd->priv;
1883 +       struct nand_chip *chip = mtd_to_nand(mtd);
1884
1885         if (!chip->bbt)
1886                 return 0;
1887 @@ -503,19 +530,17 @@ static int nand_block_isreserved(struct
1888   * nand_block_checkbad - [GENERIC] Check if a block is marked bad
1889   * @mtd: MTD device structure
1890   * @ofs: offset from device start
1891 - * @getchip: 0, if the chip is already selected
1892   * @allowbbt: 1, if its allowed to access the bbt area
1893   *
1894   * Check, if the block is bad. Either by reading the bad block table or
1895   * calling of the scan function.
1896   */
1897 -static int nand_block_checkbad(struct mtd_info *mtd, loff_t ofs, int getchip,
1898 -                              int allowbbt)
1899 +static int nand_block_checkbad(struct mtd_info *mtd, loff_t ofs, int allowbbt)
1900  {
1901 -       struct nand_chip *chip = mtd->priv;
1902 +       struct nand_chip *chip = mtd_to_nand(mtd);
1903
1904         if (!chip->bbt)
1905 -               return chip->block_bad(mtd, ofs, getchip);
1906 +               return chip->block_bad(mtd, ofs);
1907
1908         /* Return info from the table */
1909         return nand_isbad_bbt(mtd, ofs, allowbbt);
1910 @@ -531,7 +556,7 @@ static int nand_block_checkbad(struct mt
1911   */
1912  static void panic_nand_wait_ready(struct mtd_info *mtd, unsigned long timeo)
1913  {
1914 -       struct nand_chip *chip = mtd->priv;
1915 +       struct nand_chip *chip = mtd_to_nand(mtd);
1916         int i;
1917
1918         /* Wait for the device to get ready */
1919 @@ -551,7 +576,7 @@ static void panic_nand_wait_ready(struct
1920   */
1921  void nand_wait_ready(struct mtd_info *mtd)
1922  {
1923 -       struct nand_chip *chip = mtd->priv;
1924 +       struct nand_chip *chip = mtd_to_nand(mtd);
1925         unsigned long timeo = 400;
1926
1927         if (in_interrupt() || oops_in_progress)
1928 @@ -566,8 +591,8 @@ void nand_wait_ready(struct mtd_info *mt
1929                 cond_resched();
1930         } while (time_before(jiffies, timeo));
1931
1932 -       pr_warn_ratelimited(
1933 -               "timeout while waiting for chip to become ready\n");
1934 +       if (!chip->dev_ready(mtd))
1935 +               pr_warn_ratelimited("timeout while waiting for chip to become ready\n");
1936  out:
1937         led_trigger_event(nand_led_trigger, LED_OFF);
1938  }
1939 @@ -582,7 +607,7 @@ EXPORT_SYMBOL_GPL(nand_wait_ready);
1940   */
1941  static void nand_wait_status_ready(struct mtd_info *mtd, unsigned long timeo)
1942  {
1943 -       register struct nand_chip *chip = mtd->priv;
1944 +       register struct nand_chip *chip = mtd_to_nand(mtd);
1945
1946         timeo = jiffies + msecs_to_jiffies(timeo);
1947         do {
1948 @@ -605,7 +630,7 @@ static void nand_wait_status_ready(struc
1949  static void nand_command(struct mtd_info *mtd, unsigned int command,
1950                          int column, int page_addr)
1951  {
1952 -       register struct nand_chip *chip = mtd->priv;
1953 +       register struct nand_chip *chip = mtd_to_nand(mtd);
1954         int ctrl = NAND_CTRL_CLE | NAND_CTRL_CHANGE;
1955
1956         /* Write out the command to the device */
1957 @@ -708,7 +733,7 @@ static void nand_command(struct mtd_info
1958  static void nand_command_lp(struct mtd_info *mtd, unsigned int command,
1959                             int column, int page_addr)
1960  {
1961 -       register struct nand_chip *chip = mtd->priv;
1962 +       register struct nand_chip *chip = mtd_to_nand(mtd);
1963
1964         /* Emulate NAND_CMD_READOOB */
1965         if (command == NAND_CMD_READOOB) {
1966 @@ -832,7 +857,7 @@ static void panic_nand_get_device(struct
1967  static int
1968  nand_get_device(struct mtd_info *mtd, int new_state)
1969  {
1970 -       struct nand_chip *chip = mtd->priv;
1971 +       struct nand_chip *chip = mtd_to_nand(mtd);
1972         spinlock_t *lock = &chip->controller->lock;
1973         wait_queue_head_t *wq = &chip->controller->wq;
1974         DECLARE_WAITQUEUE(wait, current);
1975 @@ -952,7 +977,7 @@ static int __nand_unlock(struct mtd_info
1976  {
1977         int ret = 0;
1978         int status, page;
1979 -       struct nand_chip *chip = mtd->priv;
1980 +       struct nand_chip *chip = mtd_to_nand(mtd);
1981
1982         /* Submit address of first page to unlock */
1983         page = ofs >> chip->page_shift;
1984 @@ -987,7 +1012,7 @@ int nand_unlock(struct mtd_info *mtd, lo
1985  {
1986         int ret = 0;
1987         int chipnr;
1988 -       struct nand_chip *chip = mtd->priv;
1989 +       struct nand_chip *chip = mtd_to_nand(mtd);
1990
1991         pr_debug("%s: start = 0x%012llx, len = %llu\n",
1992                         __func__, (unsigned long long)ofs, len);
1993 @@ -1050,7 +1075,7 @@ int nand_lock(struct mtd_info *mtd, loff
1994  {
1995         int ret = 0;
1996         int chipnr, status, page;
1997 -       struct nand_chip *chip = mtd->priv;
1998 +       struct nand_chip *chip = mtd_to_nand(mtd);
1999
2000         pr_debug("%s: start = 0x%012llx, len = %llu\n",
2001                         __func__, (unsigned long long)ofs, len);
2002 @@ -1309,13 +1334,12 @@ static int nand_read_page_raw_syndrome(s
2003  static int nand_read_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
2004                                 uint8_t *buf, int oob_required, int page)
2005  {
2006 -       int i, eccsize = chip->ecc.size;
2007 +       int i, eccsize = chip->ecc.size, ret;
2008         int eccbytes = chip->ecc.bytes;
2009         int eccsteps = chip->ecc.steps;
2010         uint8_t *p = buf;
2011         uint8_t *ecc_calc = chip->buffers->ecccalc;
2012         uint8_t *ecc_code = chip->buffers->ecccode;
2013 -       uint32_t *eccpos = chip->ecc.layout->eccpos;
2014         unsigned int max_bitflips = 0;
2015
2016         chip->ecc.read_page_raw(mtd, chip, buf, 1, page);
2017 @@ -1323,8 +1347,10 @@ static int nand_read_page_swecc(struct m
2018         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
2019                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
2020
2021 -       for (i = 0; i < chip->ecc.total; i++)
2022 -               ecc_code[i] = chip->oob_poi[eccpos[i]];
2023 +       ret = mtd_ooblayout_get_eccbytes(mtd, ecc_code, chip->oob_poi, 0,
2024 +                                        chip->ecc.total);
2025 +       if (ret)
2026 +               return ret;
2027
2028         eccsteps = chip->ecc.steps;
2029         p = buf;
2030 @@ -1356,14 +1382,14 @@ static int nand_read_subpage(struct mtd_
2031                         uint32_t data_offs, uint32_t readlen, uint8_t *bufpoi,
2032                         int page)
2033  {
2034 -       int start_step, end_step, num_steps;
2035 -       uint32_t *eccpos = chip->ecc.layout->eccpos;
2036 +       int start_step, end_step, num_steps, ret;
2037         uint8_t *p;
2038         int data_col_addr, i, gaps = 0;
2039         int datafrag_len, eccfrag_len, aligned_len, aligned_pos;
2040         int busw = (chip->options & NAND_BUSWIDTH_16) ? 2 : 1;
2041 -       int index;
2042 +       int index, section = 0;
2043         unsigned int max_bitflips = 0;
2044 +       struct mtd_oob_region oobregion = { };
2045
2046         /* Column address within the page aligned to ECC size (256bytes) */
2047         start_step = data_offs / chip->ecc.size;
2048 @@ -1391,12 +1417,13 @@ static int nand_read_subpage(struct mtd_
2049          * The performance is faster if we position offsets according to
2050          * ecc.pos. Let's make sure that there are no gaps in ECC positions.
2051          */
2052 -       for (i = 0; i < eccfrag_len - 1; i++) {
2053 -               if (eccpos[i + index] + 1 != eccpos[i + index + 1]) {
2054 -                       gaps = 1;
2055 -                       break;
2056 -               }
2057 -       }
2058 +       ret = mtd_ooblayout_find_eccregion(mtd, index, &section, &oobregion);
2059 +       if (ret)
2060 +               return ret;
2061 +
2062 +       if (oobregion.length < eccfrag_len)
2063 +               gaps = 1;
2064 +
2065         if (gaps) {
2066                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, mtd->writesize, -1);
2067                 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
2068 @@ -1405,20 +1432,23 @@ static int nand_read_subpage(struct mtd_
2069                  * Send the command to read the particular ECC bytes take care
2070                  * about buswidth alignment in read_buf.
2071                  */
2072 -               aligned_pos = eccpos[index] & ~(busw - 1);
2073 +               aligned_pos = oobregion.offset & ~(busw - 1);
2074                 aligned_len = eccfrag_len;
2075 -               if (eccpos[index] & (busw - 1))
2076 +               if (oobregion.offset & (busw - 1))
2077                         aligned_len++;
2078 -               if (eccpos[index + (num_steps * chip->ecc.bytes)] & (busw - 1))
2079 +               if ((oobregion.offset + (num_steps * chip->ecc.bytes)) &
2080 +                   (busw - 1))
2081                         aligned_len++;
2082
2083                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT,
2084 -                                       mtd->writesize + aligned_pos, -1);
2085 +                             mtd->writesize + aligned_pos, -1);
2086                 chip->read_buf(mtd, &chip->oob_poi[aligned_pos], aligned_len);
2087         }
2088
2089 -       for (i = 0; i < eccfrag_len; i++)
2090 -               chip->buffers->ecccode[i] = chip->oob_poi[eccpos[i + index]];
2091 +       ret = mtd_ooblayout_get_eccbytes(mtd, chip->buffers->ecccode,
2092 +                                        chip->oob_poi, index, eccfrag_len);
2093 +       if (ret)
2094 +               return ret;
2095
2096         p = bufpoi + data_col_addr;
2097         for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) {
2098 @@ -1426,6 +1456,16 @@ static int nand_read_subpage(struct mtd_
2099
2100                 stat = chip->ecc.correct(mtd, p,
2101                         &chip->buffers->ecccode[i], &chip->buffers->ecccalc[i]);
2102 +               if (stat == -EBADMSG &&
2103 +                   (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
2104 +                       /* check for empty pages with bitflips */
2105 +                       stat = nand_check_erased_ecc_chunk(p, chip->ecc.size,
2106 +                                               &chip->buffers->ecccode[i],
2107 +                                               chip->ecc.bytes,
2108 +                                               NULL, 0,
2109 +                                               chip->ecc.strength);
2110 +               }
2111 +
2112                 if (stat < 0) {
2113                         mtd->ecc_stats.failed++;
2114                 } else {
2115 @@ -1449,13 +1489,12 @@ static int nand_read_subpage(struct mtd_
2116  static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
2117                                 uint8_t *buf, int oob_required, int page)
2118  {
2119 -       int i, eccsize = chip->ecc.size;
2120 +       int i, eccsize = chip->ecc.size, ret;
2121         int eccbytes = chip->ecc.bytes;
2122         int eccsteps = chip->ecc.steps;
2123         uint8_t *p = buf;
2124         uint8_t *ecc_calc = chip->buffers->ecccalc;
2125         uint8_t *ecc_code = chip->buffers->ecccode;
2126 -       uint32_t *eccpos = chip->ecc.layout->eccpos;
2127         unsigned int max_bitflips = 0;
2128
2129         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
2130 @@ -1465,8 +1504,10 @@ static int nand_read_page_hwecc(struct m
2131         }
2132         chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
2133
2134 -       for (i = 0; i < chip->ecc.total; i++)
2135 -               ecc_code[i] = chip->oob_poi[eccpos[i]];
2136 +       ret = mtd_ooblayout_get_eccbytes(mtd, ecc_code, chip->oob_poi, 0,
2137 +                                        chip->ecc.total);
2138 +       if (ret)
2139 +               return ret;
2140
2141         eccsteps = chip->ecc.steps;
2142         p = buf;
2143 @@ -1475,6 +1516,15 @@ static int nand_read_page_hwecc(struct m
2144                 int stat;
2145
2146                 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);
2147 +               if (stat == -EBADMSG &&
2148 +                   (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
2149 +                       /* check for empty pages with bitflips */
2150 +                       stat = nand_check_erased_ecc_chunk(p, eccsize,
2151 +                                               &ecc_code[i], eccbytes,
2152 +                                               NULL, 0,
2153 +                                               chip->ecc.strength);
2154 +               }
2155 +
2156                 if (stat < 0) {
2157                         mtd->ecc_stats.failed++;
2158                 } else {
2159 @@ -1502,12 +1552,11 @@ static int nand_read_page_hwecc(struct m
2160  static int nand_read_page_hwecc_oob_first(struct mtd_info *mtd,
2161         struct nand_chip *chip, uint8_t *buf, int oob_required, int page)
2162  {
2163 -       int i, eccsize = chip->ecc.size;
2164 +       int i, eccsize = chip->ecc.size, ret;
2165         int eccbytes = chip->ecc.bytes;
2166         int eccsteps = chip->ecc.steps;
2167         uint8_t *p = buf;
2168         uint8_t *ecc_code = chip->buffers->ecccode;
2169 -       uint32_t *eccpos = chip->ecc.layout->eccpos;
2170         uint8_t *ecc_calc = chip->buffers->ecccalc;
2171         unsigned int max_bitflips = 0;
2172
2173 @@ -1516,8 +1565,10 @@ static int nand_read_page_hwecc_oob_firs
2174         chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
2175         chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
2176
2177 -       for (i = 0; i < chip->ecc.total; i++)
2178 -               ecc_code[i] = chip->oob_poi[eccpos[i]];
2179 +       ret = mtd_ooblayout_get_eccbytes(mtd, ecc_code, chip->oob_poi, 0,
2180 +                                        chip->ecc.total);
2181 +       if (ret)
2182 +               return ret;
2183
2184         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
2185                 int stat;
2186 @@ -1527,6 +1578,15 @@ static int nand_read_page_hwecc_oob_firs
2187                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
2188
2189                 stat = chip->ecc.correct(mtd, p, &ecc_code[i], NULL);
2190 +               if (stat == -EBADMSG &&
2191 +                   (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
2192 +                       /* check for empty pages with bitflips */
2193 +                       stat = nand_check_erased_ecc_chunk(p, eccsize,
2194 +                                               &ecc_code[i], eccbytes,
2195 +                                               NULL, 0,
2196 +                                               chip->ecc.strength);
2197 +               }
2198 +
2199                 if (stat < 0) {
2200                         mtd->ecc_stats.failed++;
2201                 } else {
2202 @@ -1554,6 +1614,7 @@ static int nand_read_page_syndrome(struc
2203         int i, eccsize = chip->ecc.size;
2204         int eccbytes = chip->ecc.bytes;
2205         int eccsteps = chip->ecc.steps;
2206 +       int eccpadbytes = eccbytes + chip->ecc.prepad + chip->ecc.postpad;
2207         uint8_t *p = buf;
2208         uint8_t *oob = chip->oob_poi;
2209         unsigned int max_bitflips = 0;
2210 @@ -1573,19 +1634,29 @@ static int nand_read_page_syndrome(struc
2211                 chip->read_buf(mtd, oob, eccbytes);
2212                 stat = chip->ecc.correct(mtd, p, oob, NULL);
2213
2214 -               if (stat < 0) {
2215 -                       mtd->ecc_stats.failed++;
2216 -               } else {
2217 -                       mtd->ecc_stats.corrected += stat;
2218 -                       max_bitflips = max_t(unsigned int, max_bitflips, stat);
2219 -               }
2220 -
2221                 oob += eccbytes;
2222
2223                 if (chip->ecc.postpad) {
2224                         chip->read_buf(mtd, oob, chip->ecc.postpad);
2225                         oob += chip->ecc.postpad;
2226                 }
2227 +
2228 +               if (stat == -EBADMSG &&
2229 +                   (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
2230 +                       /* check for empty pages with bitflips */
2231 +                       stat = nand_check_erased_ecc_chunk(p, chip->ecc.size,
2232 +                                                          oob - eccpadbytes,
2233 +                                                          eccpadbytes,
2234 +                                                          NULL, 0,
2235 +                                                          chip->ecc.strength);
2236 +               }
2237 +
2238 +               if (stat < 0) {
2239 +                       mtd->ecc_stats.failed++;
2240 +               } else {
2241 +                       mtd->ecc_stats.corrected += stat;
2242 +                       max_bitflips = max_t(unsigned int, max_bitflips, stat);
2243 +               }
2244         }
2245
2246         /* Calculate remaining oob bytes */
2247 @@ -1598,14 +1669,17 @@ static int nand_read_page_syndrome(struc
2248
2249  /**
2250   * nand_transfer_oob - [INTERN] Transfer oob to client buffer
2251 - * @chip: nand chip structure
2252 + * @mtd: mtd info structure
2253   * @oob: oob destination address
2254   * @ops: oob ops structure
2255   * @len: size of oob to transfer
2256   */
2257 -static uint8_t *nand_transfer_oob(struct nand_chip *chip, uint8_t *oob,
2258 +static uint8_t *nand_transfer_oob(struct mtd_info *mtd, uint8_t *oob,
2259                                   struct mtd_oob_ops *ops, size_t len)
2260  {
2261 +       struct nand_chip *chip = mtd_to_nand(mtd);
2262 +       int ret;
2263 +
2264         switch (ops->mode) {
2265
2266         case MTD_OPS_PLACE_OOB:
2267 @@ -1613,31 +1687,12 @@ static uint8_t *nand_transfer_oob(struct
2268                 memcpy(oob, chip->oob_poi + ops->ooboffs, len);
2269                 return oob + len;
2270
2271 -       case MTD_OPS_AUTO_OOB: {
2272 -               struct nand_oobfree *free = chip->ecc.layout->oobfree;
2273 -               uint32_t boffs = 0, roffs = ops->ooboffs;
2274 -               size_t bytes = 0;
2275 -
2276 -               for (; free->length && len; free++, len -= bytes) {
2277 -                       /* Read request not from offset 0? */
2278 -                       if (unlikely(roffs)) {
2279 -                               if (roffs >= free->length) {
2280 -                                       roffs -= free->length;
2281 -                                       continue;
2282 -                               }
2283 -                               boffs = free->offset + roffs;
2284 -                               bytes = min_t(size_t, len,
2285 -                                             (free->length - roffs));
2286 -                               roffs = 0;
2287 -                       } else {
2288 -                               bytes = min_t(size_t, len, free->length);
2289 -                               boffs = free->offset;
2290 -                       }
2291 -                       memcpy(oob, chip->oob_poi + boffs, bytes);
2292 -                       oob += bytes;
2293 -               }
2294 -               return oob;
2295 -       }
2296 +       case MTD_OPS_AUTO_OOB:
2297 +               ret = mtd_ooblayout_get_databytes(mtd, oob, chip->oob_poi,
2298 +                                                 ops->ooboffs, len);
2299 +               BUG_ON(ret);
2300 +               return oob + len;
2301 +
2302         default:
2303                 BUG();
2304         }
2305 @@ -1655,7 +1710,7 @@ static uint8_t *nand_transfer_oob(struct
2306   */
2307  static int nand_setup_read_retry(struct mtd_info *mtd, int retry_mode)
2308  {
2309 -       struct nand_chip *chip = mtd->priv;
2310 +       struct nand_chip *chip = mtd_to_nand(mtd);
2311
2312         pr_debug("setting READ RETRY mode %d\n", retry_mode);
2313
2314 @@ -1680,12 +1735,11 @@ static int nand_do_read_ops(struct mtd_i
2315                             struct mtd_oob_ops *ops)
2316  {
2317         int chipnr, page, realpage, col, bytes, aligned, oob_required;
2318 -       struct nand_chip *chip = mtd->priv;
2319 +       struct nand_chip *chip = mtd_to_nand(mtd);
2320         int ret = 0;
2321         uint32_t readlen = ops->len;
2322         uint32_t oobreadlen = ops->ooblen;
2323 -       uint32_t max_oobsize = ops->mode == MTD_OPS_AUTO_OOB ?
2324 -               mtd->oobavail : mtd->oobsize;
2325 +       uint32_t max_oobsize = mtd_oobavail(mtd, ops);
2326
2327         uint8_t *bufpoi, *oob, *buf;
2328         int use_bufpoi;
2329 @@ -1772,7 +1826,7 @@ read_retry:
2330                                 int toread = min(oobreadlen, max_oobsize);
2331
2332                                 if (toread) {
2333 -                                       oob = nand_transfer_oob(chip,
2334 +                                       oob = nand_transfer_oob(mtd,
2335                                                 oob, ops, toread);
2336                                         oobreadlen -= toread;
2337                                 }
2338 @@ -2024,7 +2078,7 @@ static int nand_do_read_oob(struct mtd_i
2339                             struct mtd_oob_ops *ops)
2340  {
2341         int page, realpage, chipnr;
2342 -       struct nand_chip *chip = mtd->priv;
2343 +       struct nand_chip *chip = mtd_to_nand(mtd);
2344         struct mtd_ecc_stats stats;
2345         int readlen = ops->ooblen;
2346         int len;
2347 @@ -2036,10 +2090,7 @@ static int nand_do_read_oob(struct mtd_i
2348
2349         stats = mtd->ecc_stats;
2350
2351 -       if (ops->mode == MTD_OPS_AUTO_OOB)
2352 -               len = chip->ecc.layout->oobavail;
2353 -       else
2354 -               len = mtd->oobsize;
2355 +       len = mtd_oobavail(mtd, ops);
2356
2357         if (unlikely(ops->ooboffs >= len)) {
2358                 pr_debug("%s: attempt to start read outside oob\n",
2359 @@ -2073,7 +2124,7 @@ static int nand_do_read_oob(struct mtd_i
2360                         break;
2361
2362                 len = min(len, readlen);
2363 -               buf = nand_transfer_oob(chip, buf, ops, len);
2364 +               buf = nand_transfer_oob(mtd, buf, ops, len);
2365
2366                 if (chip->options & NAND_NEED_READRDY) {
2367                         /* Apply delay or wait for ready/busy pin */
2368 @@ -2232,19 +2283,20 @@ static int nand_write_page_swecc(struct
2369                                  const uint8_t *buf, int oob_required,
2370                                  int page)
2371  {
2372 -       int i, eccsize = chip->ecc.size;
2373 +       int i, eccsize = chip->ecc.size, ret;
2374         int eccbytes = chip->ecc.bytes;
2375         int eccsteps = chip->ecc.steps;
2376         uint8_t *ecc_calc = chip->buffers->ecccalc;
2377         const uint8_t *p = buf;
2378 -       uint32_t *eccpos = chip->ecc.layout->eccpos;
2379
2380         /* Software ECC calculation */
2381         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
2382                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
2383
2384 -       for (i = 0; i < chip->ecc.total; i++)
2385 -               chip->oob_poi[eccpos[i]] = ecc_calc[i];
2386 +       ret = mtd_ooblayout_set_eccbytes(mtd, ecc_calc, chip->oob_poi, 0,
2387 +                                        chip->ecc.total);
2388 +       if (ret)
2389 +               return ret;
2390
2391         return chip->ecc.write_page_raw(mtd, chip, buf, 1, page);
2392  }
2393 @@ -2261,12 +2313,11 @@ static int nand_write_page_hwecc(struct
2394                                   const uint8_t *buf, int oob_required,
2395                                   int page)
2396  {
2397 -       int i, eccsize = chip->ecc.size;
2398 +       int i, eccsize = chip->ecc.size, ret;
2399         int eccbytes = chip->ecc.bytes;
2400         int eccsteps = chip->ecc.steps;
2401         uint8_t *ecc_calc = chip->buffers->ecccalc;
2402         const uint8_t *p = buf;
2403 -       uint32_t *eccpos = chip->ecc.layout->eccpos;
2404
2405         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
2406                 chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
2407 @@ -2274,8 +2325,10 @@ static int nand_write_page_hwecc(struct
2408                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
2409         }
2410
2411 -       for (i = 0; i < chip->ecc.total; i++)
2412 -               chip->oob_poi[eccpos[i]] = ecc_calc[i];
2413 +       ret = mtd_ooblayout_set_eccbytes(mtd, ecc_calc, chip->oob_poi, 0,
2414 +                                        chip->ecc.total);
2415 +       if (ret)
2416 +               return ret;
2417
2418         chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
2419
2420 @@ -2303,11 +2356,10 @@ static int nand_write_subpage_hwecc(stru
2421         int ecc_size      = chip->ecc.size;
2422         int ecc_bytes     = chip->ecc.bytes;
2423         int ecc_steps     = chip->ecc.steps;
2424 -       uint32_t *eccpos  = chip->ecc.layout->eccpos;
2425         uint32_t start_step = offset / ecc_size;
2426         uint32_t end_step   = (offset + data_len - 1) / ecc_size;
2427         int oob_bytes       = mtd->oobsize / ecc_steps;
2428 -       int step, i;
2429 +       int step, ret;
2430
2431         for (step = 0; step < ecc_steps; step++) {
2432                 /* configure controller for WRITE access */
2433 @@ -2335,8 +2387,10 @@ static int nand_write_subpage_hwecc(stru
2434         /* copy calculated ECC for whole page to chip->buffer->oob */
2435         /* this include masked-value(0xFF) for unwritten subpages */
2436         ecc_calc = chip->buffers->ecccalc;
2437 -       for (i = 0; i < chip->ecc.total; i++)
2438 -               chip->oob_poi[eccpos[i]] = ecc_calc[i];
2439 +       ret = mtd_ooblayout_set_eccbytes(mtd, ecc_calc, chip->oob_poi, 0,
2440 +                                        chip->ecc.total);
2441 +       if (ret)
2442 +               return ret;
2443
2444         /* write OOB buffer to NAND device */
2445         chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
2446 @@ -2472,7 +2526,8 @@ static int nand_write_page(struct mtd_in
2447  static uint8_t *nand_fill_oob(struct mtd_info *mtd, uint8_t *oob, size_t len,
2448                               struct mtd_oob_ops *ops)
2449  {
2450 -       struct nand_chip *chip = mtd->priv;
2451 +       struct nand_chip *chip = mtd_to_nand(mtd);
2452 +       int ret;
2453
2454         /*
2455          * Initialise to all 0xFF, to avoid the possibility of left over OOB
2456 @@ -2487,31 +2542,12 @@ static uint8_t *nand_fill_oob(struct mtd
2457                 memcpy(chip->oob_poi + ops->ooboffs, oob, len);
2458                 return oob + len;
2459
2460 -       case MTD_OPS_AUTO_OOB: {
2461 -               struct nand_oobfree *free = chip->ecc.layout->oobfree;
2462 -               uint32_t boffs = 0, woffs = ops->ooboffs;
2463 -               size_t bytes = 0;
2464 -
2465 -               for (; free->length && len; free++, len -= bytes) {
2466 -                       /* Write request not from offset 0? */
2467 -                       if (unlikely(woffs)) {
2468 -                               if (woffs >= free->length) {
2469 -                                       woffs -= free->length;
2470 -                                       continue;
2471 -                               }
2472 -                               boffs = free->offset + woffs;
2473 -                               bytes = min_t(size_t, len,
2474 -                                             (free->length - woffs));
2475 -                               woffs = 0;
2476 -                       } else {
2477 -                               bytes = min_t(size_t, len, free->length);
2478 -                               boffs = free->offset;
2479 -                       }
2480 -                       memcpy(chip->oob_poi + boffs, oob, bytes);
2481 -                       oob += bytes;
2482 -               }
2483 -               return oob;
2484 -       }
2485 +       case MTD_OPS_AUTO_OOB:
2486 +               ret = mtd_ooblayout_set_databytes(mtd, oob, chip->oob_poi,
2487 +                                                 ops->ooboffs, len);
2488 +               BUG_ON(ret);
2489 +               return oob + len;
2490 +
2491         default:
2492                 BUG();
2493         }
2494 @@ -2532,12 +2568,11 @@ static int nand_do_write_ops(struct mtd_
2495                              struct mtd_oob_ops *ops)
2496  {
2497         int chipnr, realpage, page, blockmask, column;
2498 -       struct nand_chip *chip = mtd->priv;
2499 +       struct nand_chip *chip = mtd_to_nand(mtd);
2500         uint32_t writelen = ops->len;
2501
2502         uint32_t oobwritelen = ops->ooblen;
2503 -       uint32_t oobmaxlen = ops->mode == MTD_OPS_AUTO_OOB ?
2504 -                               mtd->oobavail : mtd->oobsize;
2505 +       uint32_t oobmaxlen = mtd_oobavail(mtd, ops);
2506
2507         uint8_t *oob = ops->oobbuf;
2508         uint8_t *buf = ops->datbuf;
2509 @@ -2662,7 +2697,7 @@ err_out:
2510  static int panic_nand_write(struct mtd_info *mtd, loff_t to, size_t len,
2511                             size_t *retlen, const uint8_t *buf)
2512  {
2513 -       struct nand_chip *chip = mtd->priv;
2514 +       struct nand_chip *chip = mtd_to_nand(mtd);
2515         struct mtd_oob_ops ops;
2516         int ret;
2517
2518 @@ -2722,15 +2757,12 @@ static int nand_do_write_oob(struct mtd_
2519                              struct mtd_oob_ops *ops)
2520  {
2521         int chipnr, page, status, len;
2522 -       struct nand_chip *chip = mtd->priv;
2523 +       struct nand_chip *chip = mtd_to_nand(mtd);
2524
2525         pr_debug("%s: to = 0x%08x, len = %i\n",
2526                          __func__, (unsigned int)to, (int)ops->ooblen);
2527
2528 -       if (ops->mode == MTD_OPS_AUTO_OOB)
2529 -               len = chip->ecc.layout->oobavail;
2530 -       else
2531 -               len = mtd->oobsize;
2532 +       len = mtd_oobavail(mtd, ops);
2533
2534         /* Do not allow write past end of page */
2535         if ((ops->ooboffs + ops->ooblen) > len) {
2536 @@ -2847,7 +2879,7 @@ out:
2537   */
2538  static int single_erase(struct mtd_info *mtd, int page)
2539  {
2540 -       struct nand_chip *chip = mtd->priv;
2541 +       struct nand_chip *chip = mtd_to_nand(mtd);
2542         /* Send commands to erase a block */
2543         chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
2544         chip->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
2545 @@ -2879,7 +2911,7 @@ int nand_erase_nand(struct mtd_info *mtd
2546                     int allowbbt)
2547  {
2548         int page, status, pages_per_block, ret, chipnr;
2549 -       struct nand_chip *chip = mtd->priv;
2550 +       struct nand_chip *chip = mtd_to_nand(mtd);
2551         loff_t len;
2552
2553         pr_debug("%s: start = 0x%012llx, len = %llu\n",
2554 @@ -2918,7 +2950,7 @@ int nand_erase_nand(struct mtd_info *mtd
2555         while (len) {
2556                 /* Check if we have a bad block, we do not erase bad blocks! */
2557                 if (nand_block_checkbad(mtd, ((loff_t) page) <<
2558 -                                       chip->page_shift, 0, allowbbt)) {
2559 +                                       chip->page_shift, allowbbt)) {
2560                         pr_warn("%s: attempt to erase a bad block at page 0x%08x\n",
2561                                     __func__, page);
2562                         instr->state = MTD_ERASE_FAILED;
2563 @@ -3005,7 +3037,20 @@ static void nand_sync(struct mtd_info *m
2564   */
2565  static int nand_block_isbad(struct mtd_info *mtd, loff_t offs)
2566  {
2567 -       return nand_block_checkbad(mtd, offs, 1, 0);
2568 +       struct nand_chip *chip = mtd_to_nand(mtd);
2569 +       int chipnr = (int)(offs >> chip->chip_shift);
2570 +       int ret;
2571 +
2572 +       /* Select the NAND device */
2573 +       nand_get_device(mtd, FL_READING);
2574 +       chip->select_chip(mtd, chipnr);
2575 +
2576 +       ret = nand_block_checkbad(mtd, offs, 0);
2577 +
2578 +       chip->select_chip(mtd, -1);
2579 +       nand_release_device(mtd);
2580 +
2581 +       return ret;
2582  }
2583
2584  /**
2585 @@ -3094,7 +3139,7 @@ static int nand_suspend(struct mtd_info
2586   */
2587  static void nand_resume(struct mtd_info *mtd)
2588  {
2589 -       struct nand_chip *chip = mtd->priv;
2590 +       struct nand_chip *chip = mtd_to_nand(mtd);
2591
2592         if (chip->state == FL_PM_SUSPENDED)
2593                 nand_release_device(mtd);
2594 @@ -3266,7 +3311,7 @@ ext_out:
2595
2596  static int nand_setup_read_retry_micron(struct mtd_info *mtd, int retry_mode)
2597  {
2598 -       struct nand_chip *chip = mtd->priv;
2599 +       struct nand_chip *chip = mtd_to_nand(mtd);
2600         uint8_t feature[ONFI_SUBFEATURE_PARAM_LEN] = {retry_mode};
2601
2602         return chip->onfi_set_features(mtd, chip, ONFI_FEATURE_ADDR_READ_RETRY,
2603 @@ -3937,10 +3982,13 @@ ident_done:
2604         return type;
2605  }
2606
2607 -static int nand_dt_init(struct mtd_info *mtd, struct nand_chip *chip,
2608 -                       struct device_node *dn)
2609 +static int nand_dt_init(struct nand_chip *chip)
2610  {
2611 -       int ecc_mode, ecc_strength, ecc_step;
2612 +       struct device_node *dn = nand_get_flash_node(chip);
2613 +       int ecc_mode, ecc_algo, ecc_strength, ecc_step;
2614 +
2615 +       if (!dn)
2616 +               return 0;
2617
2618         if (of_get_nand_bus_width(dn) == 16)
2619                 chip->options |= NAND_BUSWIDTH_16;
2620 @@ -3949,6 +3997,7 @@ static int nand_dt_init(struct mtd_info
2621                 chip->bbt_options |= NAND_BBT_USE_FLASH;
2622
2623         ecc_mode = of_get_nand_ecc_mode(dn);
2624 +       ecc_algo = of_get_nand_ecc_algo(dn);
2625         ecc_strength = of_get_nand_ecc_strength(dn);
2626         ecc_step = of_get_nand_ecc_step_size(dn);
2627
2628 @@ -3961,6 +4010,9 @@ static int nand_dt_init(struct mtd_info
2629         if (ecc_mode >= 0)
2630                 chip->ecc.mode = ecc_mode;
2631
2632 +       if (ecc_algo >= 0)
2633 +               chip->ecc.algo = ecc_algo;
2634 +
2635         if (ecc_strength >= 0)
2636                 chip->ecc.strength = ecc_strength;
2637
2638 @@ -3984,15 +4036,16 @@ int nand_scan_ident(struct mtd_info *mtd
2639                     struct nand_flash_dev *table)
2640  {
2641         int i, nand_maf_id, nand_dev_id;
2642 -       struct nand_chip *chip = mtd->priv;
2643 +       struct nand_chip *chip = mtd_to_nand(mtd);
2644         struct nand_flash_dev *type;
2645         int ret;
2646
2647 -       if (chip->flash_node) {
2648 -               ret = nand_dt_init(mtd, chip, chip->flash_node);
2649 -               if (ret)
2650 -                       return ret;
2651 -       }
2652 +       ret = nand_dt_init(chip);
2653 +       if (ret)
2654 +               return ret;
2655 +
2656 +       if (!mtd->name && mtd->dev.parent)
2657 +               mtd->name = dev_name(mtd->dev.parent);
2658
2659         if (!mtd->name && mtd->dev.parent)
2660                 mtd->name = dev_name(mtd->dev.parent);
2661 @@ -4055,7 +4108,7 @@ EXPORT_SYMBOL(nand_scan_ident);
2662   */
2663  static bool nand_ecc_strength_good(struct mtd_info *mtd)
2664  {
2665 -       struct nand_chip *chip = mtd->priv;
2666 +       struct nand_chip *chip = mtd_to_nand(mtd);
2667         struct nand_ecc_ctrl *ecc = &chip->ecc;
2668         int corr, ds_corr;
2669
2670 @@ -4083,10 +4136,10 @@ static bool nand_ecc_strength_good(struc
2671   */
2672  int nand_scan_tail(struct mtd_info *mtd)
2673  {
2674 -       int i;
2675 -       struct nand_chip *chip = mtd->priv;
2676 +       struct nand_chip *chip = mtd_to_nand(mtd);
2677         struct nand_ecc_ctrl *ecc = &chip->ecc;
2678         struct nand_buffers *nbuf;
2679 +       int ret;
2680
2681         /* New bad blocks should be marked in OOB, flash-based BBT, or both */
2682         BUG_ON((chip->bbt_options & NAND_BBT_NO_OOB_BBM) &&
2683 @@ -4113,19 +4166,15 @@ int nand_scan_tail(struct mtd_info *mtd)
2684         /*
2685          * If no default placement scheme is given, select an appropriate one.
2686          */
2687 -       if (!ecc->layout && (ecc->mode != NAND_ECC_SOFT_BCH)) {
2688 +       if (!mtd->ooblayout && (ecc->mode != NAND_ECC_SOFT_BCH)) {
2689                 switch (mtd->oobsize) {
2690                 case 8:
2691 -                       ecc->layout = &nand_oob_8;
2692 -                       break;
2693                 case 16:
2694 -                       ecc->layout = &nand_oob_16;
2695 +                       mtd_set_ooblayout(mtd, &nand_ooblayout_sp_ops);
2696                         break;
2697                 case 64:
2698 -                       ecc->layout = &nand_oob_64;
2699 -                       break;
2700                 case 128:
2701 -                       ecc->layout = &nand_oob_128;
2702 +                       mtd_set_ooblayout(mtd, &nand_ooblayout_lp_ops);
2703                         break;
2704                 default:
2705                         pr_warn("No oob scheme defined for oobsize %d\n",
2706 @@ -4168,7 +4217,7 @@ int nand_scan_tail(struct mtd_info *mtd)
2707                         ecc->write_oob = nand_write_oob_std;
2708                 if (!ecc->read_subpage)
2709                         ecc->read_subpage = nand_read_subpage;
2710 -               if (!ecc->write_subpage)
2711 +               if (!ecc->write_subpage && ecc->hwctl && ecc->calculate)
2712                         ecc->write_subpage = nand_write_subpage_hwecc;
2713
2714         case NAND_ECC_HW_SYNDROME:
2715 @@ -4246,10 +4295,8 @@ int nand_scan_tail(struct mtd_info *mtd)
2716                 }
2717
2718                 /* See nand_bch_init() for details. */
2719 -               ecc->bytes = DIV_ROUND_UP(
2720 -                               ecc->strength * fls(8 * ecc->size), 8);
2721 -               ecc->priv = nand_bch_init(mtd, ecc->size, ecc->bytes,
2722 -                                              &ecc->layout);
2723 +               ecc->bytes = 0;
2724 +               ecc->priv = nand_bch_init(mtd);
2725                 if (!ecc->priv) {
2726                         pr_warn("BCH ECC initialization failed!\n");
2727                         BUG();
2728 @@ -4280,20 +4327,9 @@ int nand_scan_tail(struct mtd_info *mtd)
2729         if (!ecc->write_oob_raw)
2730                 ecc->write_oob_raw = ecc->write_oob;
2731
2732 -       /*
2733 -        * The number of bytes available for a client to place data into
2734 -        * the out of band area.
2735 -        */
2736 -       ecc->layout->oobavail = 0;
2737 -       for (i = 0; ecc->layout->oobfree[i].length
2738 -                       && i < ARRAY_SIZE(ecc->layout->oobfree); i++)
2739 -               ecc->layout->oobavail += ecc->layout->oobfree[i].length;
2740 -       mtd->oobavail = ecc->layout->oobavail;
2741 -
2742 -       /* ECC sanity check: warn if it's too weak */
2743 -       if (!nand_ecc_strength_good(mtd))
2744 -               pr_warn("WARNING: %s: the ECC used on your system is too weak compared to the one required by the NAND chip\n",
2745 -                       mtd->name);
2746 +       /* propagate ecc info to mtd_info */
2747 +       mtd->ecc_strength = ecc->strength;
2748 +       mtd->ecc_step_size = ecc->size;
2749
2750         /*
2751          * Set the number of read / write steps for one page depending on ECC
2752 @@ -4306,6 +4342,21 @@ int nand_scan_tail(struct mtd_info *mtd)
2753         }
2754         ecc->total = ecc->steps * ecc->bytes;
2755
2756 +       /*
2757 +        * The number of bytes available for a client to place data into
2758 +        * the out of band area.
2759 +        */
2760 +       ret = mtd_ooblayout_count_freebytes(mtd);
2761 +       if (ret < 0)
2762 +               ret = 0;
2763 +
2764 +       mtd->oobavail = ret;
2765 +
2766 +       /* ECC sanity check: warn if it's too weak */
2767 +       if (!nand_ecc_strength_good(mtd))
2768 +               pr_warn("WARNING: %s: the ECC used on your system is too weak compared to the one required by the NAND chip\n",
2769 +                       mtd->name);
2770 +
2771         /* Allow subpage writes up to ecc.steps. Not possible for MLC flash */
2772         if (!(chip->options & NAND_NO_SUBPAGE_WRITE) && nand_is_slc(chip)) {
2773                 switch (ecc->steps) {
2774 @@ -4362,10 +4413,6 @@ int nand_scan_tail(struct mtd_info *mtd)
2775         mtd->_block_markbad = nand_block_markbad;
2776         mtd->writebufsize = mtd->writesize;
2777
2778 -       /* propagate ecc info to mtd_info */
2779 -       mtd->ecclayout = ecc->layout;
2780 -       mtd->ecc_strength = ecc->strength;
2781 -       mtd->ecc_step_size = ecc->size;
2782         /*
2783          * Initialize bitflip_threshold to its default prior scan_bbt() call.
2784          * scan_bbt() might invoke mtd_read(), thus bitflip_threshold must be
2785 @@ -4421,7 +4468,7 @@ EXPORT_SYMBOL(nand_scan);
2786   */
2787  void nand_release(struct mtd_info *mtd)
2788  {
2789 -       struct nand_chip *chip = mtd->priv;
2790 +       struct nand_chip *chip = mtd_to_nand(mtd);
2791
2792         if (chip->ecc.mode == NAND_ECC_SOFT_BCH)
2793                 nand_bch_free((struct nand_bch_control *)chip->ecc.priv);
2794 --- a/drivers/mtd/nand/nand_bbt.c
2795 +++ b/drivers/mtd/nand/nand_bbt.c
2796 @@ -172,7 +172,7 @@ static int read_bbt(struct mtd_info *mtd
2797                 struct nand_bbt_descr *td, int offs)
2798  {
2799         int res, ret = 0, i, j, act = 0;
2800 -       struct nand_chip *this = mtd->priv;
2801 +       struct nand_chip *this = mtd_to_nand(mtd);
2802         size_t retlen, len, totlen;
2803         loff_t from;
2804         int bits = td->options & NAND_BBT_NRBITS_MSK;
2805 @@ -263,7 +263,7 @@ static int read_bbt(struct mtd_info *mtd
2806   */
2807  static int read_abs_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td, int chip)
2808  {
2809 -       struct nand_chip *this = mtd->priv;
2810 +       struct nand_chip *this = mtd_to_nand(mtd);
2811         int res = 0, i;
2812
2813         if (td->options & NAND_BBT_PERCHIP) {
2814 @@ -388,7 +388,7 @@ static u32 bbt_get_ver_offs(struct mtd_i
2815  static void read_abs_bbts(struct mtd_info *mtd, uint8_t *buf,
2816                           struct nand_bbt_descr *td, struct nand_bbt_descr *md)
2817  {
2818 -       struct nand_chip *this = mtd->priv;
2819 +       struct nand_chip *this = mtd_to_nand(mtd);
2820
2821         /* Read the primary version, if available */
2822         if (td->options & NAND_BBT_VERSION) {
2823 @@ -454,7 +454,7 @@ static int scan_block_fast(struct mtd_in
2824  static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
2825         struct nand_bbt_descr *bd, int chip)
2826  {
2827 -       struct nand_chip *this = mtd->priv;
2828 +       struct nand_chip *this = mtd_to_nand(mtd);
2829         int i, numblocks, numpages;
2830         int startblock;
2831         loff_t from;
2832 @@ -523,7 +523,7 @@ static int create_bbt(struct mtd_info *m
2833   */
2834  static int search_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td)
2835  {
2836 -       struct nand_chip *this = mtd->priv;
2837 +       struct nand_chip *this = mtd_to_nand(mtd);
2838         int i, chips;
2839         int startblock, block, dir;
2840         int scanlen = mtd->writesize + mtd->oobsize;
2841 @@ -618,7 +618,7 @@ static int write_bbt(struct mtd_info *mt
2842                      struct nand_bbt_descr *td, struct nand_bbt_descr *md,
2843                      int chipsel)
2844  {
2845 -       struct nand_chip *this = mtd->priv;
2846 +       struct nand_chip *this = mtd_to_nand(mtd);
2847         struct erase_info einfo;
2848         int i, res, chip = 0;
2849         int bits, startblock, dir, page, offs, numblocks, sft, sftmsk;
2850 @@ -819,7 +819,7 @@ static int write_bbt(struct mtd_info *mt
2851   */
2852  static inline int nand_memory_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
2853  {
2854 -       struct nand_chip *this = mtd->priv;
2855 +       struct nand_chip *this = mtd_to_nand(mtd);
2856
2857         return create_bbt(mtd, this->buffers->databuf, bd, -1);
2858  }
2859 @@ -838,7 +838,7 @@ static inline int nand_memory_bbt(struct
2860  static int check_create(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd)
2861  {
2862         int i, chips, writeops, create, chipsel, res, res2;
2863 -       struct nand_chip *this = mtd->priv;
2864 +       struct nand_chip *this = mtd_to_nand(mtd);
2865         struct nand_bbt_descr *td = this->bbt_td;
2866         struct nand_bbt_descr *md = this->bbt_md;
2867         struct nand_bbt_descr *rd, *rd2;
2868 @@ -962,7 +962,7 @@ static int check_create(struct mtd_info
2869   */
2870  static void mark_bbt_region(struct mtd_info *mtd, struct nand_bbt_descr *td)
2871  {
2872 -       struct nand_chip *this = mtd->priv;
2873 +       struct nand_chip *this = mtd_to_nand(mtd);
2874         int i, j, chips, block, nrblocks, update;
2875         uint8_t oldval;
2876
2877 @@ -1022,7 +1022,7 @@ static void mark_bbt_region(struct mtd_i
2878   */
2879  static void verify_bbt_descr(struct mtd_info *mtd, struct nand_bbt_descr *bd)
2880  {
2881 -       struct nand_chip *this = mtd->priv;
2882 +       struct nand_chip *this = mtd_to_nand(mtd);
2883         u32 pattern_len;
2884         u32 bits;
2885         u32 table_size;
2886 @@ -1074,7 +1074,7 @@ static void verify_bbt_descr(struct mtd_
2887   */
2888  static int nand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
2889  {
2890 -       struct nand_chip *this = mtd->priv;
2891 +       struct nand_chip *this = mtd_to_nand(mtd);
2892         int len, res;
2893         uint8_t *buf;
2894         struct nand_bbt_descr *td = this->bbt_td;
2895 @@ -1147,7 +1147,7 @@ err:
2896   */
2897  static int nand_update_bbt(struct mtd_info *mtd, loff_t offs)
2898  {
2899 -       struct nand_chip *this = mtd->priv;
2900 +       struct nand_chip *this = mtd_to_nand(mtd);
2901         int len, res = 0;
2902         int chip, chipsel;
2903         uint8_t *buf;
2904 @@ -1281,7 +1281,7 @@ static int nand_create_badblock_pattern(
2905   */
2906  int nand_default_bbt(struct mtd_info *mtd)
2907  {
2908 -       struct nand_chip *this = mtd->priv;
2909 +       struct nand_chip *this = mtd_to_nand(mtd);
2910         int ret;
2911
2912         /* Is a flash based bad block table requested? */
2913 @@ -1317,7 +1317,7 @@ int nand_default_bbt(struct mtd_info *mt
2914   */
2915  int nand_isreserved_bbt(struct mtd_info *mtd, loff_t offs)
2916  {
2917 -       struct nand_chip *this = mtd->priv;
2918 +       struct nand_chip *this = mtd_to_nand(mtd);
2919         int block;
2920
2921         block = (int)(offs >> this->bbt_erase_shift);
2922 @@ -1332,7 +1332,7 @@ int nand_isreserved_bbt(struct mtd_info
2923   */
2924  int nand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt)
2925  {
2926 -       struct nand_chip *this = mtd->priv;
2927 +       struct nand_chip *this = mtd_to_nand(mtd);
2928         int block, res;
2929
2930         block = (int)(offs >> this->bbt_erase_shift);
2931 @@ -1359,7 +1359,7 @@ int nand_isbad_bbt(struct mtd_info *mtd,
2932   */
2933  int nand_markbad_bbt(struct mtd_info *mtd, loff_t offs)
2934  {
2935 -       struct nand_chip *this = mtd->priv;
2936 +       struct nand_chip *this = mtd_to_nand(mtd);
2937         int block, ret = 0;
2938
2939         block = (int)(offs >> this->bbt_erase_shift);
2940 @@ -1373,5 +1373,3 @@ int nand_markbad_bbt(struct mtd_info *mt
2941
2942         return ret;
2943  }
2944 -
2945 -EXPORT_SYMBOL(nand_scan_bbt);
2946 --- a/drivers/mtd/nand/nand_bch.c
2947 +++ b/drivers/mtd/nand/nand_bch.c
2948 @@ -32,13 +32,11 @@
2949  /**
2950   * struct nand_bch_control - private NAND BCH control structure
2951   * @bch:       BCH control structure
2952 - * @ecclayout: private ecc layout for this BCH configuration
2953   * @errloc:    error location array
2954   * @eccmask:   XOR ecc mask, allows erased pages to be decoded as valid
2955   */
2956  struct nand_bch_control {
2957         struct bch_control   *bch;
2958 -       struct nand_ecclayout ecclayout;
2959         unsigned int         *errloc;
2960         unsigned char        *eccmask;
2961  };
2962 @@ -52,7 +50,7 @@ struct nand_bch_control {
2963  int nand_bch_calculate_ecc(struct mtd_info *mtd, const unsigned char *buf,
2964                            unsigned char *code)
2965  {
2966 -       const struct nand_chip *chip = mtd->priv;
2967 +       const struct nand_chip *chip = mtd_to_nand(mtd);
2968         struct nand_bch_control *nbc = chip->ecc.priv;
2969         unsigned int i;
2970
2971 @@ -79,7 +77,7 @@ EXPORT_SYMBOL(nand_bch_calculate_ecc);
2972  int nand_bch_correct_data(struct mtd_info *mtd, unsigned char *buf,
2973                           unsigned char *read_ecc, unsigned char *calc_ecc)
2974  {
2975 -       const struct nand_chip *chip = mtd->priv;
2976 +       const struct nand_chip *chip = mtd_to_nand(mtd);
2977         struct nand_bch_control *nbc = chip->ecc.priv;
2978         unsigned int *errloc = nbc->errloc;
2979         int i, count;
2980 @@ -98,7 +96,7 @@ int nand_bch_correct_data(struct mtd_inf
2981                 }
2982         } else if (count < 0) {
2983                 printk(KERN_ERR "ecc unrecoverable error\n");
2984 -               count = -1;
2985 +               count = -EBADMSG;
2986         }
2987         return count;
2988  }
2989 @@ -107,9 +105,6 @@ EXPORT_SYMBOL(nand_bch_correct_data);
2990  /**
2991   * nand_bch_init - [NAND Interface] Initialize NAND BCH error correction
2992   * @mtd:       MTD block structure
2993 - * @eccsize:   ecc block size in bytes
2994 - * @eccbytes:  ecc length in bytes
2995 - * @ecclayout: output default layout
2996   *
2997   * Returns:
2998   *  a pointer to a new NAND BCH control structure, or NULL upon failure
2999 @@ -123,14 +118,20 @@ EXPORT_SYMBOL(nand_bch_correct_data);
3000   * @eccsize = 512  (thus, m=13 is the smallest integer such that 2^m-1 > 512*8)
3001   * @eccbytes = 7   (7 bytes are required to store m*t = 13*4 = 52 bits)
3002   */
3003 -struct nand_bch_control *
3004 -nand_bch_init(struct mtd_info *mtd, unsigned int eccsize, unsigned int eccbytes,
3005 -             struct nand_ecclayout **ecclayout)
3006 +struct nand_bch_control *nand_bch_init(struct mtd_info *mtd)
3007  {
3008 +       struct nand_chip *nand = mtd_to_nand(mtd);
3009         unsigned int m, t, eccsteps, i;
3010 -       struct nand_ecclayout *layout;
3011         struct nand_bch_control *nbc = NULL;
3012         unsigned char *erased_page;
3013 +       unsigned int eccsize = nand->ecc.size;
3014 +       unsigned int eccbytes = nand->ecc.bytes;
3015 +       unsigned int eccstrength = nand->ecc.strength;
3016 +
3017 +       if (!eccbytes && eccstrength) {
3018 +               eccbytes = DIV_ROUND_UP(eccstrength * fls(8 * eccsize), 8);
3019 +               nand->ecc.bytes = eccbytes;
3020 +       }
3021
3022         if (!eccsize || !eccbytes) {
3023                 printk(KERN_WARNING "ecc parameters not supplied\n");
3024 @@ -158,7 +159,7 @@ nand_bch_init(struct mtd_info *mtd, unsi
3025         eccsteps = mtd->writesize/eccsize;
3026
3027         /* if no ecc placement scheme was provided, build one */
3028 -       if (!*ecclayout) {
3029 +       if (!mtd->ooblayout) {
3030
3031                 /* handle large page devices only */
3032                 if (mtd->oobsize < 64) {
3033 @@ -167,24 +168,7 @@ nand_bch_init(struct mtd_info *mtd, unsi
3034                         goto fail;
3035                 }
3036
3037 -               layout = &nbc->ecclayout;
3038 -               layout->eccbytes = eccsteps*eccbytes;
3039 -
3040 -               /* reserve 2 bytes for bad block marker */
3041 -               if (layout->eccbytes+2 > mtd->oobsize) {
3042 -                       printk(KERN_WARNING "no suitable oob scheme available "
3043 -                              "for oobsize %d eccbytes %u\n", mtd->oobsize,
3044 -                              eccbytes);
3045 -                       goto fail;
3046 -               }
3047 -               /* put ecc bytes at oob tail */
3048 -               for (i = 0; i < layout->eccbytes; i++)
3049 -                       layout->eccpos[i] = mtd->oobsize-layout->eccbytes+i;
3050 -
3051 -               layout->oobfree[0].offset = 2;
3052 -               layout->oobfree[0].length = mtd->oobsize-2-layout->eccbytes;
3053 -
3054 -               *ecclayout = layout;
3055 +               mtd_set_ooblayout(mtd, &nand_ooblayout_lp_ops);
3056         }
3057
3058         /* sanity checks */
3059 @@ -192,7 +176,8 @@ nand_bch_init(struct mtd_info *mtd, unsi
3060                 printk(KERN_WARNING "eccsize %u is too large\n", eccsize);
3061                 goto fail;
3062         }
3063 -       if ((*ecclayout)->eccbytes != (eccsteps*eccbytes)) {
3064 +
3065 +       if (mtd_ooblayout_count_eccbytes(mtd) != (eccsteps*eccbytes)) {
3066                 printk(KERN_WARNING "invalid ecc layout\n");
3067                 goto fail;
3068         }
3069 @@ -216,6 +201,9 @@ nand_bch_init(struct mtd_info *mtd, unsi
3070         for (i = 0; i < eccbytes; i++)
3071                 nbc->eccmask[i] ^= 0xff;
3072
3073 +       if (!eccstrength)
3074 +               nand->ecc.strength = (eccbytes * 8) / fls(8 * eccsize);
3075 +
3076         return nbc;
3077  fail:
3078         nand_bch_free(nbc);
3079 --- a/drivers/mtd/nand/nand_ecc.c
3080 +++ b/drivers/mtd/nand/nand_ecc.c
3081 @@ -424,7 +424,7 @@ int nand_calculate_ecc(struct mtd_info *
3082                        unsigned char *code)
3083  {
3084         __nand_calculate_ecc(buf,
3085 -                       ((struct nand_chip *)mtd->priv)->ecc.size, code);
3086 +                       mtd_to_nand(mtd)->ecc.size, code);
3087
3088         return 0;
3089  }
3090 @@ -524,7 +524,7 @@ int nand_correct_data(struct mtd_info *m
3091                       unsigned char *read_ecc, unsigned char *calc_ecc)
3092  {
3093         return __nand_correct_data(buf, read_ecc, calc_ecc,
3094 -                                  ((struct nand_chip *)mtd->priv)->ecc.size);
3095 +                                  mtd_to_nand(mtd)->ecc.size);
3096  }
3097  EXPORT_SYMBOL(nand_correct_data);
3098
3099 --- a/drivers/mtd/nand/nand_ids.c
3100 +++ b/drivers/mtd/nand/nand_ids.c
3101 @@ -50,8 +50,8 @@ struct nand_flash_dev nand_flash_ids[] =
3102                   SZ_16K, SZ_8K, SZ_4M, 0, 6, 1280, NAND_ECC_INFO(40, SZ_1K) },
3103         {"H27UCG8T2ATR-BC 64G 3.3V 8-bit",
3104                 { .id = {0xad, 0xde, 0x94, 0xda, 0x74, 0xc4} },
3105 -                 SZ_8K, SZ_8K, SZ_2M, 0, 6, 640, NAND_ECC_INFO(40, SZ_1K),
3106 -                 4 },
3107 +                 SZ_8K, SZ_8K, SZ_2M, NAND_NEED_SCRAMBLING, 6, 640,
3108 +                 NAND_ECC_INFO(40, SZ_1K), 4 },
3109
3110         LEGACY_ID_NAND("NAND 4MiB 5V 8-bit",   0x6B, 4, SZ_8K, SP_OPTIONS),
3111         LEGACY_ID_NAND("NAND 4MiB 3,3V 8-bit", 0xE3, 4, SZ_8K, SP_OPTIONS),
3112 --- a/drivers/mtd/nand/nandsim.c
3113 +++ b/drivers/mtd/nand/nandsim.c
3114 @@ -666,8 +666,8 @@ static char *get_partition_name(int i)
3115   */
3116  static int init_nandsim(struct mtd_info *mtd)
3117  {
3118 -       struct nand_chip *chip = mtd->priv;
3119 -       struct nandsim   *ns   = chip->priv;
3120 +       struct nand_chip *chip = mtd_to_nand(mtd);
3121 +       struct nandsim   *ns   = nand_get_controller_data(chip);
3122         int i, ret = 0;
3123         uint64_t remains;
3124         uint64_t next_offset;
3125 @@ -1908,7 +1908,8 @@ static void switch_state(struct nandsim
3126
3127  static u_char ns_nand_read_byte(struct mtd_info *mtd)
3128  {
3129 -       struct nandsim *ns = ((struct nand_chip *)mtd->priv)->priv;
3130 +       struct nand_chip *chip = mtd_to_nand(mtd);
3131 +       struct nandsim *ns = nand_get_controller_data(chip);
3132         u_char outb = 0x00;
3133
3134         /* Sanity and correctness checks */
3135 @@ -1969,7 +1970,8 @@ static u_char ns_nand_read_byte(struct m
3136
3137  static void ns_nand_write_byte(struct mtd_info *mtd, u_char byte)
3138  {
3139 -       struct nandsim *ns = ((struct nand_chip *)mtd->priv)->priv;
3140 +       struct nand_chip *chip = mtd_to_nand(mtd);
3141 +       struct nandsim *ns = nand_get_controller_data(chip);
3142
3143         /* Sanity and correctness checks */
3144         if (!ns->lines.ce) {
3145 @@ -2123,7 +2125,8 @@ static void ns_nand_write_byte(struct mt
3146
3147  static void ns_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int bitmask)
3148  {
3149 -       struct nandsim *ns = ((struct nand_chip *)mtd->priv)->priv;
3150 +       struct nand_chip *chip = mtd_to_nand(mtd);
3151 +       struct nandsim *ns = nand_get_controller_data(chip);
3152
3153         ns->lines.cle = bitmask & NAND_CLE ? 1 : 0;
3154         ns->lines.ale = bitmask & NAND_ALE ? 1 : 0;
3155 @@ -2141,7 +2144,7 @@ static int ns_device_ready(struct mtd_in
3156
3157  static uint16_t ns_nand_read_word(struct mtd_info *mtd)
3158  {
3159 -       struct nand_chip *chip = (struct nand_chip *)mtd->priv;
3160 +       struct nand_chip *chip = mtd_to_nand(mtd);
3161
3162         NS_DBG("read_word\n");
3163
3164 @@ -2150,7 +2153,8 @@ static uint16_t ns_nand_read_word(struct
3165
3166  static void ns_nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
3167  {
3168 -       struct nandsim *ns = ((struct nand_chip *)mtd->priv)->priv;
3169 +       struct nand_chip *chip = mtd_to_nand(mtd);
3170 +       struct nandsim *ns = nand_get_controller_data(chip);
3171
3172         /* Check that chip is expecting data input */
3173         if (!(ns->state & STATE_DATAIN_MASK)) {
3174 @@ -2177,7 +2181,8 @@ static void ns_nand_write_buf(struct mtd
3175
3176  static void ns_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
3177  {
3178 -       struct nandsim *ns = ((struct nand_chip *)mtd->priv)->priv;
3179 +       struct nand_chip *chip = mtd_to_nand(mtd);
3180 +       struct nandsim *ns = nand_get_controller_data(chip);
3181
3182         /* Sanity and correctness checks */
3183         if (!ns->lines.ce) {
3184 @@ -2198,7 +2203,7 @@ static void ns_nand_read_buf(struct mtd_
3185                 int i;
3186
3187                 for (i = 0; i < len; i++)
3188 -                       buf[i] = ((struct nand_chip *)mtd->priv)->read_byte(mtd);
3189 +                       buf[i] = mtd_to_nand(mtd)->read_byte(mtd);
3190
3191                 return;
3192         }
3193 @@ -2236,16 +2241,15 @@ static int __init ns_init_module(void)
3194         }
3195
3196         /* Allocate and initialize mtd_info, nand_chip and nandsim structures */
3197 -       nsmtd = kzalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip)
3198 -                               + sizeof(struct nandsim), GFP_KERNEL);
3199 -       if (!nsmtd) {
3200 +       chip = kzalloc(sizeof(struct nand_chip) + sizeof(struct nandsim),
3201 +                      GFP_KERNEL);
3202 +       if (!chip) {
3203                 NS_ERR("unable to allocate core structures.\n");
3204                 return -ENOMEM;
3205         }
3206 -       chip        = (struct nand_chip *)(nsmtd + 1);
3207 -        nsmtd->priv = (void *)chip;
3208 +       nsmtd       = nand_to_mtd(chip);
3209         nand        = (struct nandsim *)(chip + 1);
3210 -       chip->priv  = (void *)nand;
3211 +       nand_set_controller_data(chip, (void *)nand);
3212
3213         /*
3214          * Register simulator's callbacks.
3215 @@ -2257,6 +2261,7 @@ static int __init ns_init_module(void)
3216         chip->read_buf   = ns_nand_read_buf;
3217         chip->read_word  = ns_nand_read_word;
3218         chip->ecc.mode   = NAND_ECC_SOFT;
3219 +       chip->ecc.algo   = NAND_ECC_HAMMING;
3220         /* The NAND_SKIP_BBTSCAN option is necessary for 'overridesize' */
3221         /* and 'badblocks' parameters to work */
3222         chip->options   |= NAND_SKIP_BBTSCAN;
3223 @@ -2335,6 +2340,7 @@ static int __init ns_init_module(void)
3224                         goto error;
3225                 }
3226                 chip->ecc.mode = NAND_ECC_SOFT_BCH;
3227 +               chip->ecc.algo = NAND_ECC_BCH;
3228                 chip->ecc.size = 512;
3229                 chip->ecc.strength = bch;
3230                 chip->ecc.bytes = eccbytes;
3231 @@ -2392,7 +2398,7 @@ err_exit:
3232         for (i = 0;i < ARRAY_SIZE(nand->partitions); ++i)
3233                 kfree(nand->partitions[i].name);
3234  error:
3235 -       kfree(nsmtd);
3236 +       kfree(chip);
3237         free_lists();
3238
3239         return retval;
3240 @@ -2405,7 +2411,8 @@ module_init(ns_init_module);
3241   */
3242  static void __exit ns_cleanup_module(void)
3243  {
3244 -       struct nandsim *ns = ((struct nand_chip *)nsmtd->priv)->priv;
3245 +       struct nand_chip *chip = mtd_to_nand(nsmtd);
3246 +       struct nandsim *ns = nand_get_controller_data(chip);
3247         int i;
3248
3249         nandsim_debugfs_remove(ns);
3250 @@ -2413,7 +2420,7 @@ static void __exit ns_cleanup_module(voi
3251         nand_release(nsmtd); /* Unregister driver */
3252         for (i = 0;i < ARRAY_SIZE(ns->partitions); ++i)
3253                 kfree(ns->partitions[i].name);
3254 -       kfree(nsmtd);        /* Free other structures */
3255 +       kfree(mtd_to_nand(nsmtd));        /* Free other structures */
3256         free_lists();
3257  }
3258
3259 --- a/drivers/mtd/ofpart.c
3260 +++ b/drivers/mtd/ofpart.c
3261 @@ -26,9 +26,10 @@ static bool node_has_compatible(struct d
3262  }
3263
3264  static int parse_ofpart_partitions(struct mtd_info *master,
3265 -                                  struct mtd_partition **pparts,
3266 +                                  const struct mtd_partition **pparts,
3267                                    struct mtd_part_parser_data *data)
3268  {
3269 +       struct mtd_partition *parts;
3270         struct device_node *mtd_node;
3271         struct device_node *ofpart_node;
3272         const char *partname;
3273 @@ -37,10 +38,8 @@ static int parse_ofpart_partitions(struc
3274         bool dedicated = true;
3275
3276
3277 -       if (!data)
3278 -               return 0;
3279 -
3280 -       mtd_node = data->of_node;
3281 +       /* Pull of_node from the master device node */
3282 +       mtd_node = mtd_get_of_node(master);
3283         if (!mtd_node)
3284                 return 0;
3285
3286 @@ -72,8 +71,8 @@ static int parse_ofpart_partitions(struc
3287         if (nr_parts == 0)
3288                 return 0;
3289
3290 -       *pparts = kzalloc(nr_parts * sizeof(**pparts), GFP_KERNEL);
3291 -       if (!*pparts)
3292 +       parts = kzalloc(nr_parts * sizeof(*parts), GFP_KERNEL);
3293 +       if (!parts)
3294                 return -ENOMEM;
3295
3296         i = 0;
3297 @@ -107,19 +106,19 @@ static int parse_ofpart_partitions(struc
3298                         goto ofpart_fail;
3299                 }
3300
3301 -               (*pparts)[i].offset = of_read_number(reg, a_cells);
3302 -               (*pparts)[i].size = of_read_number(reg + a_cells, s_cells);
3303 +               parts[i].offset = of_read_number(reg, a_cells);
3304 +               parts[i].size = of_read_number(reg + a_cells, s_cells);
3305
3306                 partname = of_get_property(pp, "label", &len);
3307                 if (!partname)
3308                         partname = of_get_property(pp, "name", &len);
3309 -               (*pparts)[i].name = partname;
3310 +               parts[i].name = partname;
3311
3312                 if (of_get_property(pp, "read-only", &len))
3313 -                       (*pparts)[i].mask_flags |= MTD_WRITEABLE;
3314 +                       parts[i].mask_flags |= MTD_WRITEABLE;
3315
3316                 if (of_get_property(pp, "lock", &len))
3317 -                       (*pparts)[i].mask_flags |= MTD_POWERUP_LOCK;
3318 +                       parts[i].mask_flags |= MTD_POWERUP_LOCK;
3319
3320                 i++;
3321         }
3322 @@ -127,6 +126,7 @@ static int parse_ofpart_partitions(struc
3323         if (!nr_parts)
3324                 goto ofpart_none;
3325
3326 +       *pparts = parts;
3327         return nr_parts;
3328
3329  ofpart_fail:
3330 @@ -135,21 +135,20 @@ ofpart_fail:
3331         ret = -EINVAL;
3332  ofpart_none:
3333         of_node_put(pp);
3334 -       kfree(*pparts);
3335 -       *pparts = NULL;
3336 +       kfree(parts);
3337         return ret;
3338  }
3339
3340  static struct mtd_part_parser ofpart_parser = {
3341 -       .owner = THIS_MODULE,
3342         .parse_fn = parse_ofpart_partitions,
3343         .name = "ofpart",
3344  };
3345
3346  static int parse_ofoldpart_partitions(struct mtd_info *master,
3347 -                                     struct mtd_partition **pparts,
3348 +                                     const struct mtd_partition **pparts,
3349                                       struct mtd_part_parser_data *data)
3350  {
3351 +       struct mtd_partition *parts;
3352         struct device_node *dp;
3353         int i, plen, nr_parts;
3354         const struct {
3355 @@ -157,10 +156,8 @@ static int parse_ofoldpart_partitions(st
3356         } *part;
3357         const char *names;
3358
3359 -       if (!data)
3360 -               return 0;
3361 -
3362 -       dp = data->of_node;
3363 +       /* Pull of_node from the master device node */
3364 +       dp = mtd_get_of_node(master);
3365         if (!dp)
3366                 return 0;
3367
3368 @@ -173,37 +170,37 @@ static int parse_ofoldpart_partitions(st
3369
3370         nr_parts = plen / sizeof(part[0]);
3371
3372 -       *pparts = kzalloc(nr_parts * sizeof(*(*pparts)), GFP_KERNEL);
3373 -       if (!*pparts)
3374 +       parts = kzalloc(nr_parts * sizeof(*parts), GFP_KERNEL);
3375 +       if (!parts)
3376                 return -ENOMEM;
3377
3378         names = of_get_property(dp, "partition-names", &plen);
3379
3380         for (i = 0; i < nr_parts; i++) {
3381 -               (*pparts)[i].offset = be32_to_cpu(part->offset);
3382 -               (*pparts)[i].size   = be32_to_cpu(part->len) & ~1;
3383 +               parts[i].offset = be32_to_cpu(part->offset);
3384 +               parts[i].size   = be32_to_cpu(part->len) & ~1;
3385                 /* bit 0 set signifies read only partition */
3386                 if (be32_to_cpu(part->len) & 1)
3387 -                       (*pparts)[i].mask_flags = MTD_WRITEABLE;
3388 +                       parts[i].mask_flags = MTD_WRITEABLE;
3389
3390                 if (names && (plen > 0)) {
3391                         int len = strlen(names) + 1;
3392
3393 -                       (*pparts)[i].name = names;
3394 +                       parts[i].name = names;
3395                         plen -= len;
3396                         names += len;
3397                 } else {
3398 -                       (*pparts)[i].name = "unnamed";
3399 +                       parts[i].name = "unnamed";
3400                 }
3401
3402                 part++;
3403         }
3404
3405 +       *pparts = parts;
3406         return nr_parts;
3407  }
3408
3409  static struct mtd_part_parser ofoldpart_parser = {
3410 -       .owner = THIS_MODULE,
3411         .parse_fn = parse_ofoldpart_partitions,
3412         .name = "ofoldpart",
3413  };
3414 --- a/drivers/mtd/spi-nor/Kconfig
3415 +++ b/drivers/mtd/spi-nor/Kconfig
3416 @@ -7,6 +7,14 @@ menuconfig MTD_SPI_NOR
3417
3418  if MTD_SPI_NOR
3419
3420 +config MTD_MT81xx_NOR
3421 +       tristate "Mediatek MT81xx SPI NOR flash controller"
3422 +       depends on HAS_IOMEM
3423 +       help
3424 +         This enables access to SPI NOR flash, using MT81xx SPI NOR flash
3425 +         controller. This controller does not support generic SPI BUS, it only
3426 +         supports SPI NOR Flash.
3427 +
3428  config MTD_SPI_NOR_USE_4K_SECTORS
3429         bool "Use small 4096 B erase sectors"
3430         default y
3431 @@ -23,7 +31,7 @@ config MTD_SPI_NOR_USE_4K_SECTORS
3432
3433  config SPI_FSL_QUADSPI
3434         tristate "Freescale Quad SPI controller"
3435 -       depends on ARCH_MXC || COMPILE_TEST
3436 +       depends on ARCH_MXC || SOC_LS1021A || ARCH_LAYERSCAPE || COMPILE_TEST
3437         depends on HAS_IOMEM
3438         help
3439           This enables support for the Quad SPI controller in master mode.
3440 --- a/drivers/mtd/spi-nor/Makefile
3441 +++ b/drivers/mtd/spi-nor/Makefile
3442 @@ -1,3 +1,4 @@
3443  obj-$(CONFIG_MTD_SPI_NOR)      += spi-nor.o
3444  obj-$(CONFIG_SPI_FSL_QUADSPI)  += fsl-quadspi.o
3445 +obj-$(CONFIG_MTD_MT81xx_NOR)    += mtk-quadspi.o
3446  obj-$(CONFIG_SPI_NXP_SPIFI)    += nxp-spifi.o
3447 --- /dev/null
3448 +++ b/drivers/mtd/spi-nor/mtk-quadspi.c
3449 @@ -0,0 +1,485 @@
3450 +/*
3451 + * Copyright (c) 2015 MediaTek Inc.
3452 + * Author: Bayi Cheng <bayi.cheng@mediatek.com>
3453 + *
3454 + * This program is free software; you can redistribute it and/or modify
3455 + * it under the terms of the GNU General Public License version 2 as
3456 + * published by the Free Software Foundation.
3457 + *
3458 + * This program is distributed in the hope that it will be useful,
3459 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
3460 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3461 + * GNU General Public License for more details.
3462 + */
3463 +
3464 +#include <linux/clk.h>
3465 +#include <linux/delay.h>
3466 +#include <linux/device.h>
3467 +#include <linux/init.h>
3468 +#include <linux/io.h>
3469 +#include <linux/iopoll.h>
3470 +#include <linux/ioport.h>
3471 +#include <linux/math64.h>
3472 +#include <linux/module.h>
3473 +#include <linux/mtd/mtd.h>
3474 +#include <linux/mutex.h>
3475 +#include <linux/of.h>
3476 +#include <linux/of_device.h>
3477 +#include <linux/pinctrl/consumer.h>
3478 +#include <linux/platform_device.h>
3479 +#include <linux/slab.h>
3480 +#include <linux/mtd/mtd.h>
3481 +#include <linux/mtd/partitions.h>
3482 +#include <linux/mtd/spi-nor.h>
3483 +
3484 +#define MTK_NOR_CMD_REG                        0x00
3485 +#define MTK_NOR_CNT_REG                        0x04
3486 +#define MTK_NOR_RDSR_REG               0x08
3487 +#define MTK_NOR_RDATA_REG              0x0c
3488 +#define MTK_NOR_RADR0_REG              0x10
3489 +#define MTK_NOR_RADR1_REG              0x14
3490 +#define MTK_NOR_RADR2_REG              0x18
3491 +#define MTK_NOR_WDATA_REG              0x1c
3492 +#define MTK_NOR_PRGDATA0_REG           0x20
3493 +#define MTK_NOR_PRGDATA1_REG           0x24
3494 +#define MTK_NOR_PRGDATA2_REG           0x28
3495 +#define MTK_NOR_PRGDATA3_REG           0x2c
3496 +#define MTK_NOR_PRGDATA4_REG           0x30
3497 +#define MTK_NOR_PRGDATA5_REG           0x34
3498 +#define MTK_NOR_SHREG0_REG             0x38
3499 +#define MTK_NOR_SHREG1_REG             0x3c
3500 +#define MTK_NOR_SHREG2_REG             0x40
3501 +#define MTK_NOR_SHREG3_REG             0x44
3502 +#define MTK_NOR_SHREG4_REG             0x48
3503 +#define MTK_NOR_SHREG5_REG             0x4c
3504 +#define MTK_NOR_SHREG6_REG             0x50
3505 +#define MTK_NOR_SHREG7_REG             0x54
3506 +#define MTK_NOR_SHREG8_REG             0x58
3507 +#define MTK_NOR_SHREG9_REG             0x5c
3508 +#define MTK_NOR_CFG1_REG               0x60
3509 +#define MTK_NOR_CFG2_REG               0x64
3510 +#define MTK_NOR_CFG3_REG               0x68
3511 +#define MTK_NOR_STATUS0_REG            0x70
3512 +#define MTK_NOR_STATUS1_REG            0x74
3513 +#define MTK_NOR_STATUS2_REG            0x78
3514 +#define MTK_NOR_STATUS3_REG            0x7c
3515 +#define MTK_NOR_FLHCFG_REG             0x84
3516 +#define MTK_NOR_TIME_REG               0x94
3517 +#define MTK_NOR_PP_DATA_REG            0x98
3518 +#define MTK_NOR_PREBUF_STUS_REG                0x9c
3519 +#define MTK_NOR_DELSEL0_REG            0xa0
3520 +#define MTK_NOR_DELSEL1_REG            0xa4
3521 +#define MTK_NOR_INTRSTUS_REG           0xa8
3522 +#define MTK_NOR_INTREN_REG             0xac
3523 +#define MTK_NOR_CHKSUM_CTL_REG         0xb8
3524 +#define MTK_NOR_CHKSUM_REG             0xbc
3525 +#define MTK_NOR_CMD2_REG               0xc0
3526 +#define MTK_NOR_WRPROT_REG             0xc4
3527 +#define MTK_NOR_RADR3_REG              0xc8
3528 +#define MTK_NOR_DUAL_REG               0xcc
3529 +#define MTK_NOR_DELSEL2_REG            0xd0
3530 +#define MTK_NOR_DELSEL3_REG            0xd4
3531 +#define MTK_NOR_DELSEL4_REG            0xd8
3532 +
3533 +/* commands for mtk nor controller */
3534 +#define MTK_NOR_READ_CMD               0x0
3535 +#define MTK_NOR_RDSR_CMD               0x2
3536 +#define MTK_NOR_PRG_CMD                        0x4
3537 +#define MTK_NOR_WR_CMD                 0x10
3538 +#define MTK_NOR_PIO_WR_CMD             0x90
3539 +#define MTK_NOR_WRSR_CMD               0x20
3540 +#define MTK_NOR_PIO_READ_CMD           0x81
3541 +#define MTK_NOR_WR_BUF_ENABLE          0x1
3542 +#define MTK_NOR_WR_BUF_DISABLE         0x0
3543 +#define MTK_NOR_ENABLE_SF_CMD          0x30
3544 +#define MTK_NOR_DUAD_ADDR_EN           0x8
3545 +#define MTK_NOR_QUAD_READ_EN           0x4
3546 +#define MTK_NOR_DUAL_ADDR_EN           0x2
3547 +#define MTK_NOR_DUAL_READ_EN           0x1
3548 +#define MTK_NOR_DUAL_DISABLE           0x0
3549 +#define MTK_NOR_FAST_READ              0x1
3550 +
3551 +#define SFLASH_WRBUF_SIZE              128
3552 +
3553 +/* Can shift up to 48 bits (6 bytes) of TX/RX */
3554 +#define MTK_NOR_MAX_RX_TX_SHIFT                6
3555 +/* can shift up to 56 bits (7 bytes) transfer by MTK_NOR_PRG_CMD */
3556 +#define MTK_NOR_MAX_SHIFT              7
3557 +
3558 +/* Helpers for accessing the program data / shift data registers */
3559 +#define MTK_NOR_PRG_REG(n)             (MTK_NOR_PRGDATA0_REG + 4 * (n))
3560 +#define MTK_NOR_SHREG(n)               (MTK_NOR_SHREG0_REG + 4 * (n))
3561 +
3562 +struct mt8173_nor {
3563 +       struct spi_nor nor;
3564 +       struct device *dev;
3565 +       void __iomem *base;     /* nor flash base address */
3566 +       struct clk *spi_clk;
3567 +       struct clk *nor_clk;
3568 +};
3569 +
3570 +static void mt8173_nor_set_read_mode(struct mt8173_nor *mt8173_nor)
3571 +{
3572 +       struct spi_nor *nor = &mt8173_nor->nor;
3573 +
3574 +       switch (nor->flash_read) {
3575 +       case SPI_NOR_FAST:
3576 +               writeb(nor->read_opcode, mt8173_nor->base +
3577 +                      MTK_NOR_PRGDATA3_REG);
3578 +               writeb(MTK_NOR_FAST_READ, mt8173_nor->base +
3579 +                      MTK_NOR_CFG1_REG);
3580 +               break;
3581 +       case SPI_NOR_DUAL:
3582 +               writeb(nor->read_opcode, mt8173_nor->base +
3583 +                      MTK_NOR_PRGDATA3_REG);
3584 +               writeb(MTK_NOR_DUAL_READ_EN, mt8173_nor->base +
3585 +                      MTK_NOR_DUAL_REG);
3586 +               break;
3587 +       case SPI_NOR_QUAD:
3588 +               writeb(nor->read_opcode, mt8173_nor->base +
3589 +                      MTK_NOR_PRGDATA4_REG);
3590 +               writeb(MTK_NOR_QUAD_READ_EN, mt8173_nor->base +
3591 +                      MTK_NOR_DUAL_REG);
3592 +               break;
3593 +       default:
3594 +               writeb(MTK_NOR_DUAL_DISABLE, mt8173_nor->base +
3595 +                      MTK_NOR_DUAL_REG);
3596 +               break;
3597 +       }
3598 +}
3599 +
3600 +static int mt8173_nor_execute_cmd(struct mt8173_nor *mt8173_nor, u8 cmdval)
3601 +{
3602 +       int reg;
3603 +       u8 val = cmdval & 0x1f;
3604 +
3605 +       writeb(cmdval, mt8173_nor->base + MTK_NOR_CMD_REG);
3606 +       return readl_poll_timeout(mt8173_nor->base + MTK_NOR_CMD_REG, reg,
3607 +                                 !(reg & val), 100, 10000);
3608 +}
3609 +
3610 +static int mt8173_nor_do_tx_rx(struct mt8173_nor *mt8173_nor, u8 op,
3611 +                              u8 *tx, int txlen, u8 *rx, int rxlen)
3612 +{
3613 +       int len = 1 + txlen + rxlen;
3614 +       int i, ret, idx;
3615 +
3616 +       if (len > MTK_NOR_MAX_SHIFT)
3617 +               return -EINVAL;
3618 +
3619 +       writeb(len * 8, mt8173_nor->base + MTK_NOR_CNT_REG);
3620 +
3621 +       /* start at PRGDATA5, go down to PRGDATA0 */
3622 +       idx = MTK_NOR_MAX_RX_TX_SHIFT - 1;
3623 +
3624 +       /* opcode */
3625 +       writeb(op, mt8173_nor->base + MTK_NOR_PRG_REG(idx));
3626 +       idx--;
3627 +
3628 +       /* program TX data */
3629 +       for (i = 0; i < txlen; i++, idx--)
3630 +               writeb(tx[i], mt8173_nor->base + MTK_NOR_PRG_REG(idx));
3631 +
3632 +       /* clear out rest of TX registers */
3633 +       while (idx >= 0) {
3634 +               writeb(0, mt8173_nor->base + MTK_NOR_PRG_REG(idx));
3635 +               idx--;
3636 +       }
3637 +
3638 +       ret = mt8173_nor_execute_cmd(mt8173_nor, MTK_NOR_PRG_CMD);
3639 +       if (ret)
3640 +               return ret;
3641 +
3642 +       /* restart at first RX byte */
3643 +       idx = rxlen - 1;
3644 +
3645 +       /* read out RX data */
3646 +       for (i = 0; i < rxlen; i++, idx--)
3647 +               rx[i] = readb(mt8173_nor->base + MTK_NOR_SHREG(idx));
3648 +
3649 +       return 0;
3650 +}
3651 +
3652 +/* Do a WRSR (Write Status Register) command */
3653 +static int mt8173_nor_wr_sr(struct mt8173_nor *mt8173_nor, u8 sr)
3654 +{
3655 +       writeb(sr, mt8173_nor->base + MTK_NOR_PRGDATA5_REG);
3656 +       writeb(8, mt8173_nor->base + MTK_NOR_CNT_REG);
3657 +       return mt8173_nor_execute_cmd(mt8173_nor, MTK_NOR_WRSR_CMD);
3658 +}
3659 +
3660 +static int mt8173_nor_write_buffer_enable(struct mt8173_nor *mt8173_nor)
3661 +{
3662 +       u8 reg;
3663 +
3664 +       /* the bit0 of MTK_NOR_CFG2_REG is pre-fetch buffer
3665 +        * 0: pre-fetch buffer use for read
3666 +        * 1: pre-fetch buffer use for page program
3667 +        */
3668 +       writel(MTK_NOR_WR_BUF_ENABLE, mt8173_nor->base + MTK_NOR_CFG2_REG);
3669 +       return readb_poll_timeout(mt8173_nor->base + MTK_NOR_CFG2_REG, reg,
3670 +                                 0x01 == (reg & 0x01), 100, 10000);
3671 +}
3672 +
3673 +static int mt8173_nor_write_buffer_disable(struct mt8173_nor *mt8173_nor)
3674 +{
3675 +       u8 reg;
3676 +
3677 +       writel(MTK_NOR_WR_BUF_DISABLE, mt8173_nor->base + MTK_NOR_CFG2_REG);
3678 +       return readb_poll_timeout(mt8173_nor->base + MTK_NOR_CFG2_REG, reg,
3679 +                                 MTK_NOR_WR_BUF_DISABLE == (reg & 0x1), 100,
3680 +                                 10000);
3681 +}
3682 +
3683 +static void mt8173_nor_set_addr(struct mt8173_nor *mt8173_nor, u32 addr)
3684 +{
3685 +       int i;
3686 +
3687 +       for (i = 0; i < 3; i++) {
3688 +               writeb(addr & 0xff, mt8173_nor->base + MTK_NOR_RADR0_REG + i * 4);
3689 +               addr >>= 8;
3690 +       }
3691 +       /* Last register is non-contiguous */
3692 +       writeb(addr & 0xff, mt8173_nor->base + MTK_NOR_RADR3_REG);
3693 +}
3694 +
3695 +static int mt8173_nor_read(struct spi_nor *nor, loff_t from, size_t length,
3696 +                          size_t *retlen, u_char *buffer)
3697 +{
3698 +       int i, ret;
3699 +       int addr = (int)from;
3700 +       u8 *buf = (u8 *)buffer;
3701 +       struct mt8173_nor *mt8173_nor = nor->priv;
3702 +
3703 +       /* set mode for fast read mode ,dual mode or quad mode */
3704 +       mt8173_nor_set_read_mode(mt8173_nor);
3705 +       mt8173_nor_set_addr(mt8173_nor, addr);
3706 +
3707 +       for (i = 0; i < length; i++, (*retlen)++) {
3708 +               ret = mt8173_nor_execute_cmd(mt8173_nor, MTK_NOR_PIO_READ_CMD);
3709 +               if (ret < 0)
3710 +                       return ret;
3711 +               buf[i] = readb(mt8173_nor->base + MTK_NOR_RDATA_REG);
3712 +       }
3713 +       return 0;
3714 +}
3715 +
3716 +static int mt8173_nor_write_single_byte(struct mt8173_nor *mt8173_nor,
3717 +                                       int addr, int length, u8 *data)
3718 +{
3719 +       int i, ret;
3720 +
3721 +       mt8173_nor_set_addr(mt8173_nor, addr);
3722 +
3723 +       for (i = 0; i < length; i++) {
3724 +               writeb(*data++, mt8173_nor->base + MTK_NOR_WDATA_REG);
3725 +               ret = mt8173_nor_execute_cmd(mt8173_nor, MTK_NOR_PIO_WR_CMD);
3726 +               if (ret < 0)
3727 +                       return ret;
3728 +       }
3729 +       return 0;
3730 +}
3731 +
3732 +static int mt8173_nor_write_buffer(struct mt8173_nor *mt8173_nor, int addr,
3733 +                                  const u8 *buf)
3734 +{
3735 +       int i, bufidx, data;
3736 +
3737 +       mt8173_nor_set_addr(mt8173_nor, addr);
3738 +
3739 +       bufidx = 0;
3740 +       for (i = 0; i < SFLASH_WRBUF_SIZE; i += 4) {
3741 +               data = buf[bufidx + 3]<<24 | buf[bufidx + 2]<<16 |
3742 +                      buf[bufidx + 1]<<8 | buf[bufidx];
3743 +               bufidx += 4;
3744 +               writel(data, mt8173_nor->base + MTK_NOR_PP_DATA_REG);
3745 +       }
3746 +       return mt8173_nor_execute_cmd(mt8173_nor, MTK_NOR_WR_CMD);
3747 +}
3748 +
3749 +static void mt8173_nor_write(struct spi_nor *nor, loff_t to, size_t len,
3750 +                            size_t *retlen, const u_char *buf)
3751 +{
3752 +       int ret;
3753 +       struct mt8173_nor *mt8173_nor = nor->priv;
3754 +
3755 +       ret = mt8173_nor_write_buffer_enable(mt8173_nor);
3756 +       if (ret < 0)
3757 +               dev_warn(mt8173_nor->dev, "write buffer enable failed!\n");
3758 +
3759 +       while (len >= SFLASH_WRBUF_SIZE) {
3760 +               ret = mt8173_nor_write_buffer(mt8173_nor, to, buf);
3761 +               if (ret < 0)
3762 +                       dev_err(mt8173_nor->dev, "write buffer failed!\n");
3763 +               len -= SFLASH_WRBUF_SIZE;
3764 +               to += SFLASH_WRBUF_SIZE;
3765 +               buf += SFLASH_WRBUF_SIZE;
3766 +               (*retlen) += SFLASH_WRBUF_SIZE;
3767 +       }
3768 +       ret = mt8173_nor_write_buffer_disable(mt8173_nor);
3769 +       if (ret < 0)
3770 +               dev_warn(mt8173_nor->dev, "write buffer disable failed!\n");
3771 +
3772 +       if (len) {
3773 +               ret = mt8173_nor_write_single_byte(mt8173_nor, to, (int)len,
3774 +                                                  (u8 *)buf);
3775 +               if (ret < 0)
3776 +                       dev_err(mt8173_nor->dev, "write single byte failed!\n");
3777 +               (*retlen) += len;
3778 +       }
3779 +}
3780 +
3781 +static int mt8173_nor_read_reg(struct spi_nor *nor, u8 opcode, u8 *buf, int len)
3782 +{
3783 +       int ret;
3784 +       struct mt8173_nor *mt8173_nor = nor->priv;
3785 +
3786 +       switch (opcode) {
3787 +       case SPINOR_OP_RDSR:
3788 +               ret = mt8173_nor_execute_cmd(mt8173_nor, MTK_NOR_RDSR_CMD);
3789 +               if (ret < 0)
3790 +                       return ret;
3791 +               if (len == 1)
3792 +                       *buf = readb(mt8173_nor->base + MTK_NOR_RDSR_REG);
3793 +               else
3794 +                       dev_err(mt8173_nor->dev, "len should be 1 for read status!\n");
3795 +               break;
3796 +       default:
3797 +               ret = mt8173_nor_do_tx_rx(mt8173_nor, opcode, NULL, 0, buf, len);
3798 +               break;
3799 +       }
3800 +       return ret;
3801 +}
3802 +
3803 +static int mt8173_nor_write_reg(struct spi_nor *nor, u8 opcode, u8 *buf,
3804 +                               int len)
3805 +{
3806 +       int ret;
3807 +       struct mt8173_nor *mt8173_nor = nor->priv;
3808 +
3809 +       switch (opcode) {
3810 +       case SPINOR_OP_WRSR:
3811 +               /* We only handle 1 byte */
3812 +               ret = mt8173_nor_wr_sr(mt8173_nor, *buf);
3813 +               break;
3814 +       default:
3815 +               ret = mt8173_nor_do_tx_rx(mt8173_nor, opcode, buf, len, NULL, 0);
3816 +               if (ret)
3817 +                       dev_warn(mt8173_nor->dev, "write reg failure!\n");
3818 +               break;
3819 +       }
3820 +       return ret;
3821 +}
3822 +
3823 +static int mtk_nor_init(struct mt8173_nor *mt8173_nor,
3824 +                       struct device_node *flash_node)
3825 +{
3826 +       int ret;
3827 +       struct spi_nor *nor;
3828 +
3829 +       /* initialize controller to accept commands */
3830 +       writel(MTK_NOR_ENABLE_SF_CMD, mt8173_nor->base + MTK_NOR_WRPROT_REG);
3831 +
3832 +       nor = &mt8173_nor->nor;
3833 +       nor->dev = mt8173_nor->dev;
3834 +       nor->priv = mt8173_nor;
3835 +       spi_nor_set_flash_node(nor, flash_node);
3836 +
3837 +       /* fill the hooks to spi nor */
3838 +       nor->read = mt8173_nor_read;
3839 +       nor->read_reg = mt8173_nor_read_reg;
3840 +       nor->write = mt8173_nor_write;
3841 +       nor->write_reg = mt8173_nor_write_reg;
3842 +       nor->mtd.name = "mtk_nor";
3843 +       /* initialized with NULL */
3844 +       ret = spi_nor_scan(nor, NULL, SPI_NOR_DUAL);
3845 +       if (ret)
3846 +               return ret;
3847 +
3848 +       return mtd_device_register(&nor->mtd, NULL, 0);
3849 +}
3850 +
3851 +static int mtk_nor_drv_probe(struct platform_device *pdev)
3852 +{
3853 +       struct device_node *flash_np;
3854 +       struct resource *res;
3855 +       int ret;
3856 +       struct mt8173_nor *mt8173_nor;
3857 +
3858 +       if (!pdev->dev.of_node) {
3859 +               dev_err(&pdev->dev, "No DT found\n");
3860 +               return -EINVAL;
3861 +       }
3862 +
3863 +       mt8173_nor = devm_kzalloc(&pdev->dev, sizeof(*mt8173_nor), GFP_KERNEL);
3864 +       if (!mt8173_nor)
3865 +               return -ENOMEM;
3866 +       platform_set_drvdata(pdev, mt8173_nor);
3867 +
3868 +       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
3869 +       mt8173_nor->base = devm_ioremap_resource(&pdev->dev, res);
3870 +       if (IS_ERR(mt8173_nor->base))
3871 +               return PTR_ERR(mt8173_nor->base);
3872 +
3873 +       mt8173_nor->spi_clk = devm_clk_get(&pdev->dev, "spi");
3874 +       if (IS_ERR(mt8173_nor->spi_clk))
3875 +               return PTR_ERR(mt8173_nor->spi_clk);
3876 +
3877 +       mt8173_nor->nor_clk = devm_clk_get(&pdev->dev, "sf");
3878 +       if (IS_ERR(mt8173_nor->nor_clk))
3879 +               return PTR_ERR(mt8173_nor->nor_clk);
3880 +
3881 +       mt8173_nor->dev = &pdev->dev;
3882 +       ret = clk_prepare_enable(mt8173_nor->spi_clk);
3883 +       if (ret)
3884 +               return ret;
3885 +
3886 +       ret = clk_prepare_enable(mt8173_nor->nor_clk);
3887 +       if (ret) {
3888 +               clk_disable_unprepare(mt8173_nor->spi_clk);
3889 +               return ret;
3890 +       }
3891 +       /* only support one attached flash */
3892 +       flash_np = of_get_next_available_child(pdev->dev.of_node, NULL);
3893 +       if (!flash_np) {
3894 +               dev_err(&pdev->dev, "no SPI flash device to configure\n");
3895 +               ret = -ENODEV;
3896 +               goto nor_free;
3897 +       }
3898 +       ret = mtk_nor_init(mt8173_nor, flash_np);
3899 +
3900 +nor_free:
3901 +       if (ret) {
3902 +               clk_disable_unprepare(mt8173_nor->spi_clk);
3903 +               clk_disable_unprepare(mt8173_nor->nor_clk);
3904 +       }
3905 +       return ret;
3906 +}
3907 +
3908 +static int mtk_nor_drv_remove(struct platform_device *pdev)
3909 +{
3910 +       struct mt8173_nor *mt8173_nor = platform_get_drvdata(pdev);
3911 +
3912 +       clk_disable_unprepare(mt8173_nor->spi_clk);
3913 +       clk_disable_unprepare(mt8173_nor->nor_clk);
3914 +       return 0;
3915 +}
3916 +
3917 +static const struct of_device_id mtk_nor_of_ids[] = {
3918 +       { .compatible = "mediatek,mt8173-nor"},
3919 +       { /* sentinel */ }
3920 +};
3921 +MODULE_DEVICE_TABLE(of, mtk_nor_of_ids);
3922 +
3923 +static struct platform_driver mtk_nor_driver = {
3924 +       .probe = mtk_nor_drv_probe,
3925 +       .remove = mtk_nor_drv_remove,
3926 +       .driver = {
3927 +               .name = "mtk-nor",
3928 +               .of_match_table = mtk_nor_of_ids,
3929 +       },
3930 +};
3931 +
3932 +module_platform_driver(mtk_nor_driver);
3933 +MODULE_LICENSE("GPL v2");
3934 +MODULE_DESCRIPTION("MediaTek SPI NOR Flash Driver");
3935 --- a/drivers/mtd/spi-nor/spi-nor.c
3936 +++ b/drivers/mtd/spi-nor/spi-nor.c
3937 @@ -38,6 +38,7 @@
3938  #define CHIP_ERASE_2MB_READY_WAIT_JIFFIES      (40UL * HZ)
3939
3940  #define SPI_NOR_MAX_ID_LEN     6
3941 +#define SPI_NOR_MAX_ADDR_WIDTH 4
3942
3943  struct flash_info {
3944         char            *name;
3945 @@ -60,15 +61,20 @@ struct flash_info {
3946         u16             addr_width;
3947
3948         u16             flags;
3949 -#define        SECT_4K                 0x01    /* SPINOR_OP_BE_4K works uniformly */
3950 -#define        SPI_NOR_NO_ERASE        0x02    /* No erase command needed */
3951 -#define        SST_WRITE               0x04    /* use SST byte programming */
3952 -#define        SPI_NOR_NO_FR           0x08    /* Can't do fastread */
3953 -#define        SECT_4K_PMC             0x10    /* SPINOR_OP_BE_4K_PMC works uniformly */
3954 -#define        SPI_NOR_DUAL_READ       0x20    /* Flash supports Dual Read */
3955 -#define        SPI_NOR_QUAD_READ       0x40    /* Flash supports Quad Read */
3956 -#define        USE_FSR                 0x80    /* use flag status register */
3957 -#define        SPI_NOR_HAS_LOCK        0x100   /* Flash supports lock/unlock via SR */
3958 +#define SECT_4K                        BIT(0)  /* SPINOR_OP_BE_4K works uniformly */
3959 +#define SPI_NOR_NO_ERASE       BIT(1)  /* No erase command needed */
3960 +#define SST_WRITE              BIT(2)  /* use SST byte programming */
3961 +#define SPI_NOR_NO_FR          BIT(3)  /* Can't do fastread */
3962 +#define SECT_4K_PMC            BIT(4)  /* SPINOR_OP_BE_4K_PMC works uniformly */
3963 +#define SPI_NOR_DUAL_READ      BIT(5)  /* Flash supports Dual Read */
3964 +#define SPI_NOR_QUAD_READ      BIT(6)  /* Flash supports Quad Read */
3965 +#define USE_FSR                        BIT(7)  /* use flag status register */
3966 +#define SPI_NOR_HAS_LOCK       BIT(8)  /* Flash supports lock/unlock via SR */
3967 +#define SPI_NOR_HAS_TB         BIT(9)  /*
3968 +                                        * Flash SR has Top/Bottom (TB) protect
3969 +                                        * bit. Must be used with
3970 +                                        * SPI_NOR_HAS_LOCK.
3971 +                                        */
3972  };
3973
3974  #define JEDEC_MFR(info)        ((info)->id[0])
3975 @@ -314,6 +320,29 @@ static void spi_nor_unlock_and_unprep(st
3976  }
3977
3978  /*
3979 + * Initiate the erasure of a single sector
3980 + */
3981 +static int spi_nor_erase_sector(struct spi_nor *nor, u32 addr)
3982 +{
3983 +       u8 buf[SPI_NOR_MAX_ADDR_WIDTH];
3984 +       int i;
3985 +
3986 +       if (nor->erase)
3987 +               return nor->erase(nor, addr);
3988 +
3989 +       /*
3990 +        * Default implementation, if driver doesn't have a specialized HW
3991 +        * control
3992 +        */
3993 +       for (i = nor->addr_width - 1; i >= 0; i--) {
3994 +               buf[i] = addr & 0xff;
3995 +               addr >>= 8;
3996 +       }
3997 +
3998 +       return nor->write_reg(nor, nor->erase_opcode, buf, nor->addr_width);
3999 +}
4000 +
4001 +/*
4002   * Erase an address range on the nor chip.  The address range may extend
4003   * one or more erase sectors.  Return an error is there is a problem erasing.
4004   */
4005 @@ -372,10 +401,9 @@ static int spi_nor_erase(struct mtd_info
4006                 while (len) {
4007                         write_enable(nor);
4008
4009 -                       if (nor->erase(nor, addr)) {
4010 -                               ret = -EIO;
4011 +                       ret = spi_nor_erase_sector(nor, addr);
4012 +                       if (ret)
4013                                 goto erase_err;
4014 -                       }
4015
4016                         addr += mtd->erasesize;
4017                         len -= mtd->erasesize;
4018 @@ -388,17 +416,13 @@ static int spi_nor_erase(struct mtd_info
4019
4020         write_disable(nor);
4021
4022 +erase_err:
4023         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_ERASE);
4024
4025 -       instr->state = MTD_ERASE_DONE;
4026 +       instr->state = ret ? MTD_ERASE_FAILED : MTD_ERASE_DONE;
4027         mtd_erase_callback(instr);
4028
4029         return ret;
4030 -
4031 -erase_err:
4032 -       spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_ERASE);
4033 -       instr->state = MTD_ERASE_FAILED;
4034 -       return ret;
4035  }
4036
4037  static void stm_get_locked_range(struct spi_nor *nor, u8 sr, loff_t *ofs,
4038 @@ -416,32 +440,58 @@ static void stm_get_locked_range(struct
4039         } else {
4040                 pow = ((sr & mask) ^ mask) >> shift;
4041                 *len = mtd->size >> pow;
4042 -               *ofs = mtd->size - *len;
4043 +               if (nor->flags & SNOR_F_HAS_SR_TB && sr & SR_TB)
4044 +                       *ofs = 0;
4045 +               else
4046 +                       *ofs = mtd->size - *len;
4047         }
4048  }
4049
4050  /*
4051 - * Return 1 if the entire region is locked, 0 otherwise
4052 + * Return 1 if the entire region is locked (if @locked is true) or unlocked (if
4053 + * @locked is false); 0 otherwise
4054   */
4055 -static int stm_is_locked_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
4056 -                           u8 sr)
4057 +static int stm_check_lock_status_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
4058 +                                   u8 sr, bool locked)
4059  {
4060         loff_t lock_offs;
4061         uint64_t lock_len;
4062
4063 +       if (!len)
4064 +               return 1;
4065 +
4066         stm_get_locked_range(nor, sr, &lock_offs, &lock_len);
4067
4068 -       return (ofs + len <= lock_offs + lock_len) && (ofs >= lock_offs);
4069 +       if (locked)
4070 +               /* Requested range is a sub-range of locked range */
4071 +               return (ofs + len <= lock_offs + lock_len) && (ofs >= lock_offs);
4072 +       else
4073 +               /* Requested range does not overlap with locked range */
4074 +               return (ofs >= lock_offs + lock_len) || (ofs + len <= lock_offs);
4075 +}
4076 +
4077 +static int stm_is_locked_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
4078 +                           u8 sr)
4079 +{
4080 +       return stm_check_lock_status_sr(nor, ofs, len, sr, true);
4081 +}
4082 +
4083 +static int stm_is_unlocked_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
4084 +                             u8 sr)
4085 +{
4086 +       return stm_check_lock_status_sr(nor, ofs, len, sr, false);
4087  }
4088
4089  /*
4090   * Lock a region of the flash. Compatible with ST Micro and similar flash.
4091 - * Supports only the block protection bits BP{0,1,2} in the status register
4092 + * Supports the block protection bits BP{0,1,2} in the status register
4093   * (SR). Does not support these features found in newer SR bitfields:
4094 - *   - TB: top/bottom protect - only handle TB=0 (top protect)
4095   *   - SEC: sector/block protect - only handle SEC=0 (block protect)
4096   *   - CMP: complement protect - only support CMP=0 (range is not complemented)
4097   *
4098 + * Support for the following is provided conditionally for some flash:
4099 + *   - TB: top/bottom protect
4100 + *
4101   * Sample table portion for 8MB flash (Winbond w25q64fw):
4102   *
4103   *   SEC  |  TB   |  BP2  |  BP1  |  BP0  |  Prot Length  | Protected Portion
4104 @@ -454,26 +504,55 @@ static int stm_is_locked_sr(struct spi_n
4105   *    0   |   0   |   1   |   0   |   1   |  2 MB         | Upper 1/4
4106   *    0   |   0   |   1   |   1   |   0   |  4 MB         | Upper 1/2
4107   *    X   |   X   |   1   |   1   |   1   |  8 MB         | ALL
4108 + *  ------|-------|-------|-------|-------|---------------|-------------------
4109 + *    0   |   1   |   0   |   0   |   1   |  128 KB       | Lower 1/64
4110 + *    0   |   1   |   0   |   1   |   0   |  256 KB       | Lower 1/32
4111 + *    0   |   1   |   0   |   1   |   1   |  512 KB       | Lower 1/16
4112 + *    0   |   1   |   1   |   0   |   0   |  1 MB         | Lower 1/8
4113 + *    0   |   1   |   1   |   0   |   1   |  2 MB         | Lower 1/4
4114 + *    0   |   1   |   1   |   1   |   0   |  4 MB         | Lower 1/2
4115   *
4116   * Returns negative on errors, 0 on success.
4117   */
4118  static int stm_lock(struct spi_nor *nor, loff_t ofs, uint64_t len)
4119  {
4120         struct mtd_info *mtd = &nor->mtd;
4121 -       u8 status_old, status_new;
4122 +       int status_old, status_new;
4123         u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
4124         u8 shift = ffs(mask) - 1, pow, val;
4125 +       loff_t lock_len;
4126 +       bool can_be_top = true, can_be_bottom = nor->flags & SNOR_F_HAS_SR_TB;
4127 +       bool use_top;
4128 +       int ret;
4129
4130         status_old = read_sr(nor);
4131 +       if (status_old < 0)
4132 +               return status_old;
4133
4134 -       /* SPI NOR always locks to the end */
4135 -       if (ofs + len != mtd->size) {
4136 -               /* Does combined region extend to end? */
4137 -               if (!stm_is_locked_sr(nor, ofs + len, mtd->size - ofs - len,
4138 -                                     status_old))
4139 -                       return -EINVAL;
4140 -               len = mtd->size - ofs;
4141 -       }
4142 +       /* If nothing in our range is unlocked, we don't need to do anything */
4143 +       if (stm_is_locked_sr(nor, ofs, len, status_old))
4144 +               return 0;
4145 +
4146 +       /* If anything below us is unlocked, we can't use 'bottom' protection */
4147 +       if (!stm_is_locked_sr(nor, 0, ofs, status_old))
4148 +               can_be_bottom = false;
4149 +
4150 +       /* If anything above us is unlocked, we can't use 'top' protection */
4151 +       if (!stm_is_locked_sr(nor, ofs + len, mtd->size - (ofs + len),
4152 +                               status_old))
4153 +               can_be_top = false;
4154 +
4155 +       if (!can_be_bottom && !can_be_top)
4156 +               return -EINVAL;
4157 +
4158 +       /* Prefer top, if both are valid */
4159 +       use_top = can_be_top;
4160 +
4161 +       /* lock_len: length of region that should end up locked */
4162 +       if (use_top)
4163 +               lock_len = mtd->size - ofs;
4164 +       else
4165 +               lock_len = ofs + len;
4166
4167         /*
4168          * Need smallest pow such that:
4169 @@ -484,7 +563,7 @@ static int stm_lock(struct spi_nor *nor,
4170          *
4171          *   pow = ceil(log2(size / len)) = log2(size) - floor(log2(len))
4172          */
4173 -       pow = ilog2(mtd->size) - ilog2(len);
4174 +       pow = ilog2(mtd->size) - ilog2(lock_len);
4175         val = mask - (pow << shift);
4176         if (val & ~mask)
4177                 return -EINVAL;
4178 @@ -492,14 +571,27 @@ static int stm_lock(struct spi_nor *nor,
4179         if (!(val & mask))
4180                 return -EINVAL;
4181
4182 -       status_new = (status_old & ~mask) | val;
4183 +       status_new = (status_old & ~mask & ~SR_TB) | val;
4184 +
4185 +       /* Disallow further writes if WP pin is asserted */
4186 +       status_new |= SR_SRWD;
4187 +
4188 +       if (!use_top)
4189 +               status_new |= SR_TB;
4190 +
4191 +       /* Don't bother if they're the same */
4192 +       if (status_new == status_old)
4193 +               return 0;
4194
4195         /* Only modify protection if it will not unlock other areas */
4196 -       if ((status_new & mask) <= (status_old & mask))
4197 +       if ((status_new & mask) < (status_old & mask))
4198                 return -EINVAL;
4199
4200         write_enable(nor);
4201 -       return write_sr(nor, status_new);
4202 +       ret = write_sr(nor, status_new);
4203 +       if (ret)
4204 +               return ret;
4205 +       return spi_nor_wait_till_ready(nor);
4206  }
4207
4208  /*
4209 @@ -510,17 +602,43 @@ static int stm_lock(struct spi_nor *nor,
4210  static int stm_unlock(struct spi_nor *nor, loff_t ofs, uint64_t len)
4211  {
4212         struct mtd_info *mtd = &nor->mtd;
4213 -       uint8_t status_old, status_new;
4214 +       int status_old, status_new;
4215         u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
4216         u8 shift = ffs(mask) - 1, pow, val;
4217 +       loff_t lock_len;
4218 +       bool can_be_top = true, can_be_bottom = nor->flags & SNOR_F_HAS_SR_TB;
4219 +       bool use_top;
4220 +       int ret;
4221
4222         status_old = read_sr(nor);
4223 +       if (status_old < 0)
4224 +               return status_old;
4225 +
4226 +       /* If nothing in our range is locked, we don't need to do anything */
4227 +       if (stm_is_unlocked_sr(nor, ofs, len, status_old))
4228 +               return 0;
4229 +
4230 +       /* If anything below us is locked, we can't use 'top' protection */
4231 +       if (!stm_is_unlocked_sr(nor, 0, ofs, status_old))
4232 +               can_be_top = false;
4233 +
4234 +       /* If anything above us is locked, we can't use 'bottom' protection */
4235 +       if (!stm_is_unlocked_sr(nor, ofs + len, mtd->size - (ofs + len),
4236 +                               status_old))
4237 +               can_be_bottom = false;
4238
4239 -       /* Cannot unlock; would unlock larger region than requested */
4240 -       if (stm_is_locked_sr(nor, ofs - mtd->erasesize, mtd->erasesize,
4241 -                            status_old))
4242 +       if (!can_be_bottom && !can_be_top)
4243                 return -EINVAL;
4244
4245 +       /* Prefer top, if both are valid */
4246 +       use_top = can_be_top;
4247 +
4248 +       /* lock_len: length of region that should remain locked */
4249 +       if (use_top)
4250 +               lock_len = mtd->size - (ofs + len);
4251 +       else
4252 +               lock_len = ofs;
4253 +
4254         /*
4255          * Need largest pow such that:
4256          *
4257 @@ -530,8 +648,8 @@ static int stm_unlock(struct spi_nor *no
4258          *
4259          *   pow = floor(log2(size / len)) = log2(size) - ceil(log2(len))
4260          */
4261 -       pow = ilog2(mtd->size) - order_base_2(mtd->size - (ofs + len));
4262 -       if (ofs + len == mtd->size) {
4263 +       pow = ilog2(mtd->size) - order_base_2(lock_len);
4264 +       if (lock_len == 0) {
4265                 val = 0; /* fully unlocked */
4266         } else {
4267                 val = mask - (pow << shift);
4268 @@ -540,14 +658,28 @@ static int stm_unlock(struct spi_nor *no
4269                         return -EINVAL;
4270         }
4271
4272 -       status_new = (status_old & ~mask) | val;
4273 +       status_new = (status_old & ~mask & ~SR_TB) | val;
4274 +
4275 +       /* Don't protect status register if we're fully unlocked */
4276 +       if (lock_len == mtd->size)
4277 +               status_new &= ~SR_SRWD;
4278 +
4279 +       if (!use_top)
4280 +               status_new |= SR_TB;
4281 +
4282 +       /* Don't bother if they're the same */
4283 +       if (status_new == status_old)
4284 +               return 0;
4285
4286         /* Only modify protection if it will not lock other areas */
4287 -       if ((status_new & mask) >= (status_old & mask))
4288 +       if ((status_new & mask) > (status_old & mask))
4289                 return -EINVAL;
4290
4291         write_enable(nor);
4292 -       return write_sr(nor, status_new);
4293 +       ret = write_sr(nor, status_new);
4294 +       if (ret)
4295 +               return ret;
4296 +       return spi_nor_wait_till_ready(nor);
4297  }
4298
4299  /*
4300 @@ -737,8 +869,8 @@ static const struct flash_info spi_nor_i
4301         { "n25q032a",    INFO(0x20bb16, 0, 64 * 1024,   64, SPI_NOR_QUAD_READ) },
4302         { "n25q064",     INFO(0x20ba17, 0, 64 * 1024,  128, SECT_4K | SPI_NOR_QUAD_READ) },
4303         { "n25q064a",    INFO(0x20bb17, 0, 64 * 1024,  128, SECT_4K | SPI_NOR_QUAD_READ) },
4304 -       { "n25q128a11",  INFO(0x20bb18, 0, 64 * 1024,  256, SPI_NOR_QUAD_READ) },
4305 -       { "n25q128a13",  INFO(0x20ba18, 0, 64 * 1024,  256, SPI_NOR_QUAD_READ) },
4306 +       { "n25q128a11",  INFO(0x20bb18, 0, 64 * 1024,  256, SECT_4K | SPI_NOR_QUAD_READ) },
4307 +       { "n25q128a13",  INFO(0x20ba18, 0, 64 * 1024,  256, SECT_4K | SPI_NOR_QUAD_READ) },
4308         { "n25q256a",    INFO(0x20ba19, 0, 64 * 1024,  512, SECT_4K | SPI_NOR_QUAD_READ) },
4309         { "n25q512a",    INFO(0x20bb20, 0, 64 * 1024, 1024, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ) },
4310         { "n25q512ax3",  INFO(0x20ba20, 0, 64 * 1024, 1024, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ) },
4311 @@ -772,6 +904,7 @@ static const struct flash_info spi_nor_i
4312         { "s25fl008k",  INFO(0xef4014,      0,  64 * 1024,  16, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
4313         { "s25fl016k",  INFO(0xef4015,      0,  64 * 1024,  32, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
4314         { "s25fl064k",  INFO(0xef4017,      0,  64 * 1024, 128, SECT_4K) },
4315 +       { "s25fl116k",  INFO(0x014015,      0,  64 * 1024,  32, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
4316         { "s25fl132k",  INFO(0x014016,      0,  64 * 1024,  64, SECT_4K) },
4317         { "s25fl164k",  INFO(0x014017,      0,  64 * 1024, 128, SECT_4K) },
4318         { "s25fl204k",  INFO(0x014013,      0,  64 * 1024,   8, SECT_4K | SPI_NOR_DUAL_READ) },
4319 @@ -835,11 +968,23 @@ static const struct flash_info spi_nor_i
4320         { "w25x16", INFO(0xef3015, 0, 64 * 1024,  32, SECT_4K) },
4321         { "w25x32", INFO(0xef3016, 0, 64 * 1024,  64, SECT_4K) },
4322         { "w25q32", INFO(0xef4016, 0, 64 * 1024,  64, SECT_4K) },
4323 -       { "w25q32dw", INFO(0xef6016, 0, 64 * 1024,  64, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
4324 +       {
4325 +               "w25q32dw", INFO(0xef6016, 0, 64 * 1024,  64,
4326 +                       SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
4327 +                       SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
4328 +       },
4329         { "w25x64", INFO(0xef3017, 0, 64 * 1024, 128, SECT_4K) },
4330         { "w25q64", INFO(0xef4017, 0, 64 * 1024, 128, SECT_4K) },
4331 -       { "w25q64dw", INFO(0xef6017, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
4332 -       { "w25q128fw", INFO(0xef6018, 0, 64 * 1024, 256, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
4333 +       {
4334 +               "w25q64dw", INFO(0xef6017, 0, 64 * 1024, 128,
4335 +                       SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
4336 +                       SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
4337 +       },
4338 +       {
4339 +               "w25q128fw", INFO(0xef6018, 0, 64 * 1024, 256,
4340 +                       SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
4341 +                       SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
4342 +       },
4343         { "w25q80", INFO(0xef5014, 0, 64 * 1024,  16, SECT_4K) },
4344         { "w25q80bl", INFO(0xef4014, 0, 64 * 1024,  16, SECT_4K) },
4345         { "w25q128", INFO(0xef4018, 0, 64 * 1024, 256, SECT_4K) },
4346 @@ -862,7 +1007,7 @@ static const struct flash_info *spi_nor_
4347
4348         tmp = nor->read_reg(nor, SPINOR_OP_RDID, id, SPI_NOR_MAX_ID_LEN);
4349         if (tmp < 0) {
4350 -               dev_dbg(nor->dev, " error %d reading JEDEC ID\n", tmp);
4351 +               dev_dbg(nor->dev, "error %d reading JEDEC ID\n", tmp);
4352                 return ERR_PTR(tmp);
4353         }
4354
4355 @@ -873,7 +1018,7 @@ static const struct flash_info *spi_nor_
4356                                 return &spi_nor_ids[tmp];
4357                 }
4358         }
4359 -       dev_err(nor->dev, "unrecognized JEDEC id bytes: %02x, %2x, %2x\n",
4360 +       dev_err(nor->dev, "unrecognized JEDEC id bytes: %02x, %02x, %02x\n",
4361                 id[0], id[1], id[2]);
4362         return ERR_PTR(-ENODEV);
4363  }
4364 @@ -1019,6 +1164,8 @@ static int macronix_quad_enable(struct s
4365         int ret, val;
4366
4367         val = read_sr(nor);
4368 +       if (val < 0)
4369 +               return val;
4370         write_enable(nor);
4371
4372         write_sr(nor, val | SR_QUAD_EN_MX);
4373 @@ -1100,7 +1247,7 @@ static int set_quad_mode(struct spi_nor
4374  static int spi_nor_check(struct spi_nor *nor)
4375  {
4376         if (!nor->dev || !nor->read || !nor->write ||
4377 -               !nor->read_reg || !nor->write_reg || !nor->erase) {
4378 +               !nor->read_reg || !nor->write_reg) {
4379                 pr_err("spi-nor: please fill all the necessary fields!\n");
4380                 return -EINVAL;
4381         }
4382 @@ -1113,7 +1260,7 @@ int spi_nor_scan(struct spi_nor *nor, co
4383         const struct flash_info *info = NULL;
4384         struct device *dev = nor->dev;
4385         struct mtd_info *mtd = &nor->mtd;
4386 -       struct device_node *np = nor->flash_node;
4387 +       struct device_node *np = spi_nor_get_flash_node(nor);
4388         int ret;
4389         int i;
4390
4391 @@ -1167,6 +1314,7 @@ int spi_nor_scan(struct spi_nor *nor, co
4392             info->flags & SPI_NOR_HAS_LOCK) {
4393                 write_enable(nor);
4394                 write_sr(nor, 0);
4395 +               spi_nor_wait_till_ready(nor);
4396         }
4397
4398         if (!mtd->name)
4399 @@ -1201,6 +1349,8 @@ int spi_nor_scan(struct spi_nor *nor, co
4400
4401         if (info->flags & USE_FSR)
4402                 nor->flags |= SNOR_F_USE_FSR;
4403 +       if (info->flags & SPI_NOR_HAS_TB)
4404 +               nor->flags |= SNOR_F_HAS_SR_TB;
4405
4406  #ifdef CONFIG_MTD_SPI_NOR_USE_4K_SECTORS
4407         /* prefer "small sector" erase if possible */
4408 @@ -1303,6 +1453,12 @@ int spi_nor_scan(struct spi_nor *nor, co
4409                 nor->addr_width = 3;
4410         }
4411
4412 +       if (nor->addr_width > SPI_NOR_MAX_ADDR_WIDTH) {
4413 +               dev_err(dev, "address width is too large: %u\n",
4414 +                       nor->addr_width);
4415 +               return -EINVAL;
4416 +       }
4417 +
4418         nor->read_dummy = spi_nor_read_dummy_cycles(nor);
4419
4420         dev_info(dev, "%s (%lld Kbytes)\n", info->name,
4421 --- a/drivers/mtd/tests/mtd_nandecctest.c
4422 +++ b/drivers/mtd/tests/mtd_nandecctest.c
4423 @@ -187,7 +187,7 @@ static int double_bit_error_detect(void
4424         __nand_calculate_ecc(error_data, size, calc_ecc);
4425         ret = __nand_correct_data(error_data, error_ecc, calc_ecc, size);
4426
4427 -       return (ret == -1) ? 0 : -EINVAL;
4428 +       return (ret == -EBADMSG) ? 0 : -EINVAL;
4429  }
4430
4431  static const struct nand_ecc_test nand_ecc_test[] = {
4432 --- a/drivers/mtd/tests/oobtest.c
4433 +++ b/drivers/mtd/tests/oobtest.c
4434 @@ -215,19 +215,19 @@ static int verify_eraseblock(int ebnum)
4435                         pr_info("ignoring error as within bitflip_limit\n");
4436                 }
4437
4438 -               if (use_offset != 0 || use_len < mtd->ecclayout->oobavail) {
4439 +               if (use_offset != 0 || use_len < mtd->oobavail) {
4440                         int k;
4441
4442                         ops.mode      = MTD_OPS_AUTO_OOB;
4443                         ops.len       = 0;
4444                         ops.retlen    = 0;
4445 -                       ops.ooblen    = mtd->ecclayout->oobavail;
4446 +                       ops.ooblen    = mtd->oobavail;
4447                         ops.oobretlen = 0;
4448                         ops.ooboffs   = 0;
4449                         ops.datbuf    = NULL;
4450                         ops.oobbuf    = readbuf;
4451                         err = mtd_read_oob(mtd, addr, &ops);
4452 -                       if (err || ops.oobretlen != mtd->ecclayout->oobavail) {
4453 +                       if (err || ops.oobretlen != mtd->oobavail) {
4454                                 pr_err("error: readoob failed at %#llx\n",
4455                                                 (long long)addr);
4456                                 errcnt += 1;
4457 @@ -244,7 +244,7 @@ static int verify_eraseblock(int ebnum)
4458                         /* verify post-(use_offset + use_len) area for 0xff */
4459                         k = use_offset + use_len;
4460                         bitflips += memffshow(addr, k, readbuf + k,
4461 -                                             mtd->ecclayout->oobavail - k);
4462 +                                             mtd->oobavail - k);
4463
4464                         if (bitflips > bitflip_limit) {
4465                                 pr_err("error: verify failed at %#llx\n",
4466 @@ -269,8 +269,8 @@ static int verify_eraseblock_in_one_go(i
4467         struct mtd_oob_ops ops;
4468         int err = 0;
4469         loff_t addr = (loff_t)ebnum * mtd->erasesize;
4470 -       size_t len = mtd->ecclayout->oobavail * pgcnt;
4471 -       size_t oobavail = mtd->ecclayout->oobavail;
4472 +       size_t len = mtd->oobavail * pgcnt;
4473 +       size_t oobavail = mtd->oobavail;
4474         size_t bitflips;
4475         int i;
4476
4477 @@ -394,8 +394,8 @@ static int __init mtd_oobtest_init(void)
4478                 goto out;
4479
4480         use_offset = 0;
4481 -       use_len = mtd->ecclayout->oobavail;
4482 -       use_len_max = mtd->ecclayout->oobavail;
4483 +       use_len = mtd->oobavail;
4484 +       use_len_max = mtd->oobavail;
4485         vary_offset = 0;
4486
4487         /* First test: write all OOB, read it back and verify */
4488 @@ -460,8 +460,8 @@ static int __init mtd_oobtest_init(void)
4489
4490         /* Write all eraseblocks */
4491         use_offset = 0;
4492 -       use_len = mtd->ecclayout->oobavail;
4493 -       use_len_max = mtd->ecclayout->oobavail;
4494 +       use_len = mtd->oobavail;
4495 +       use_len_max = mtd->oobavail;
4496         vary_offset = 1;
4497         prandom_seed_state(&rnd_state, 5);
4498
4499 @@ -471,8 +471,8 @@ static int __init mtd_oobtest_init(void)
4500
4501         /* Check all eraseblocks */
4502         use_offset = 0;
4503 -       use_len = mtd->ecclayout->oobavail;
4504 -       use_len_max = mtd->ecclayout->oobavail;
4505 +       use_len = mtd->oobavail;
4506 +       use_len_max = mtd->oobavail;
4507         vary_offset = 1;
4508         prandom_seed_state(&rnd_state, 5);
4509         err = verify_all_eraseblocks();
4510 @@ -480,8 +480,8 @@ static int __init mtd_oobtest_init(void)
4511                 goto out;
4512
4513         use_offset = 0;
4514 -       use_len = mtd->ecclayout->oobavail;
4515 -       use_len_max = mtd->ecclayout->oobavail;
4516 +       use_len = mtd->oobavail;
4517 +       use_len_max = mtd->oobavail;
4518         vary_offset = 0;
4519
4520         /* Fourth test: try to write off end of device */
4521 @@ -501,7 +501,7 @@ static int __init mtd_oobtest_init(void)
4522         ops.retlen    = 0;
4523         ops.ooblen    = 1;
4524         ops.oobretlen = 0;
4525 -       ops.ooboffs   = mtd->ecclayout->oobavail;
4526 +       ops.ooboffs   = mtd->oobavail;
4527         ops.datbuf    = NULL;
4528         ops.oobbuf    = writebuf;
4529         pr_info("attempting to start write past end of OOB\n");
4530 @@ -521,7 +521,7 @@ static int __init mtd_oobtest_init(void)
4531         ops.retlen    = 0;
4532         ops.ooblen    = 1;
4533         ops.oobretlen = 0;
4534 -       ops.ooboffs   = mtd->ecclayout->oobavail;
4535 +       ops.ooboffs   = mtd->oobavail;
4536         ops.datbuf    = NULL;
4537         ops.oobbuf    = readbuf;
4538         pr_info("attempting to start read past end of OOB\n");
4539 @@ -543,7 +543,7 @@ static int __init mtd_oobtest_init(void)
4540                 ops.mode      = MTD_OPS_AUTO_OOB;
4541                 ops.len       = 0;
4542                 ops.retlen    = 0;
4543 -               ops.ooblen    = mtd->ecclayout->oobavail + 1;
4544 +               ops.ooblen    = mtd->oobavail + 1;
4545                 ops.oobretlen = 0;
4546                 ops.ooboffs   = 0;
4547                 ops.datbuf    = NULL;
4548 @@ -563,7 +563,7 @@ static int __init mtd_oobtest_init(void)
4549                 ops.mode      = MTD_OPS_AUTO_OOB;
4550                 ops.len       = 0;
4551                 ops.retlen    = 0;
4552 -               ops.ooblen    = mtd->ecclayout->oobavail + 1;
4553 +               ops.ooblen    = mtd->oobavail + 1;
4554                 ops.oobretlen = 0;
4555                 ops.ooboffs   = 0;
4556                 ops.datbuf    = NULL;
4557 @@ -587,7 +587,7 @@ static int __init mtd_oobtest_init(void)
4558                 ops.mode      = MTD_OPS_AUTO_OOB;
4559                 ops.len       = 0;
4560                 ops.retlen    = 0;
4561 -               ops.ooblen    = mtd->ecclayout->oobavail;
4562 +               ops.ooblen    = mtd->oobavail;
4563                 ops.oobretlen = 0;
4564                 ops.ooboffs   = 1;
4565                 ops.datbuf    = NULL;
4566 @@ -607,7 +607,7 @@ static int __init mtd_oobtest_init(void)
4567                 ops.mode      = MTD_OPS_AUTO_OOB;
4568                 ops.len       = 0;
4569                 ops.retlen    = 0;
4570 -               ops.ooblen    = mtd->ecclayout->oobavail;
4571 +               ops.ooblen    = mtd->oobavail;
4572                 ops.oobretlen = 0;
4573                 ops.ooboffs   = 1;
4574                 ops.datbuf    = NULL;
4575 @@ -638,7 +638,7 @@ static int __init mtd_oobtest_init(void)
4576         for (i = 0; i < ebcnt - 1; ++i) {
4577                 int cnt = 2;
4578                 int pg;
4579 -               size_t sz = mtd->ecclayout->oobavail;
4580 +               size_t sz = mtd->oobavail;
4581                 if (bbt[i] || bbt[i + 1])
4582                         continue;
4583                 addr = (loff_t)(i + 1) * mtd->erasesize - mtd->writesize;
4584 @@ -673,13 +673,12 @@ static int __init mtd_oobtest_init(void)
4585         for (i = 0; i < ebcnt - 1; ++i) {
4586                 if (bbt[i] || bbt[i + 1])
4587                         continue;
4588 -               prandom_bytes_state(&rnd_state, writebuf,
4589 -                                       mtd->ecclayout->oobavail * 2);
4590 +               prandom_bytes_state(&rnd_state, writebuf, mtd->oobavail * 2);
4591                 addr = (loff_t)(i + 1) * mtd->erasesize - mtd->writesize;
4592                 ops.mode      = MTD_OPS_AUTO_OOB;
4593                 ops.len       = 0;
4594                 ops.retlen    = 0;
4595 -               ops.ooblen    = mtd->ecclayout->oobavail * 2;
4596 +               ops.ooblen    = mtd->oobavail * 2;
4597                 ops.oobretlen = 0;
4598                 ops.ooboffs   = 0;
4599                 ops.datbuf    = NULL;
4600 @@ -688,7 +687,7 @@ static int __init mtd_oobtest_init(void)
4601                 if (err)
4602                         goto out;
4603                 if (memcmpshow(addr, readbuf, writebuf,
4604 -                              mtd->ecclayout->oobavail * 2)) {
4605 +                              mtd->oobavail * 2)) {
4606                         pr_err("error: verify failed at %#llx\n",
4607                                (long long)addr);
4608                         errcnt += 1;
4609 --- a/drivers/mtd/tests/pagetest.c
4610 +++ b/drivers/mtd/tests/pagetest.c
4611 @@ -127,13 +127,12 @@ static int crosstest(void)
4612         unsigned char *pp1, *pp2, *pp3, *pp4;
4613
4614         pr_info("crosstest\n");
4615 -       pp1 = kmalloc(pgsize * 4, GFP_KERNEL);
4616 +       pp1 = kzalloc(pgsize * 4, GFP_KERNEL);
4617         if (!pp1)
4618                 return -ENOMEM;
4619         pp2 = pp1 + pgsize;
4620         pp3 = pp2 + pgsize;
4621         pp4 = pp3 + pgsize;
4622 -       memset(pp1, 0, pgsize * 4);
4623
4624         addr0 = 0;
4625         for (i = 0; i < ebcnt && bbt[i]; ++i)
4626 --- a/include/linux/mtd/bbm.h
4627 +++ b/include/linux/mtd/bbm.h
4628 @@ -166,7 +166,6 @@ struct bbm_info {
4629  };
4630
4631  /* OneNAND BBT interface */
4632 -extern int onenand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd);
4633  extern int onenand_default_bbt(struct mtd_info *mtd);
4634
4635  #endif /* __LINUX_MTD_BBM_H */
4636 --- a/include/linux/mtd/fsmc.h
4637 +++ b/include/linux/mtd/fsmc.h
4638 @@ -103,24 +103,6 @@
4639
4640  #define FSMC_BUSY_WAIT_TIMEOUT (1 * HZ)
4641
4642 -/*
4643 - * There are 13 bytes of ecc for every 512 byte block in FSMC version 8
4644 - * and it has to be read consecutively and immediately after the 512
4645 - * byte data block for hardware to generate the error bit offsets
4646 - * Managing the ecc bytes in the following way is easier. This way is
4647 - * similar to oobfree structure maintained already in u-boot nand driver
4648 - */
4649 -#define MAX_ECCPLACE_ENTRIES   32
4650 -
4651 -struct fsmc_nand_eccplace {
4652 -       uint8_t offset;
4653 -       uint8_t length;
4654 -};
4655 -
4656 -struct fsmc_eccplace {
4657 -       struct fsmc_nand_eccplace eccplace[MAX_ECCPLACE_ENTRIES];
4658 -};
4659 -
4660  struct fsmc_nand_timings {
4661         uint8_t tclr;
4662         uint8_t tar;
4663 --- a/include/linux/mtd/inftl.h
4664 +++ b/include/linux/mtd/inftl.h
4665 @@ -44,7 +44,6 @@ struct INFTLrecord {
4666         unsigned int nb_blocks;         /* number of physical blocks */
4667         unsigned int nb_boot_blocks;    /* number of blocks used by the bios */
4668         struct erase_info instr;
4669 -       struct nand_ecclayout oobinfo;
4670  };
4671
4672  int INFTL_mount(struct INFTLrecord *s);
4673 --- a/include/linux/mtd/map.h
4674 +++ b/include/linux/mtd/map.h
4675 @@ -137,7 +137,9 @@
4676  #endif
4677
4678  #ifndef map_bankwidth
4679 +#ifdef CONFIG_MTD
4680  #warning "No CONFIG_MTD_MAP_BANK_WIDTH_xx selected. No NOR chip support can work"
4681 +#endif
4682  static inline int map_bankwidth(void *map)
4683  {
4684         BUG();
4685 @@ -233,8 +235,11 @@ struct map_info {
4686            If there is no cache to care about this can be set to NULL. */
4687         void (*inval_cache)(struct map_info *, unsigned long, ssize_t);
4688
4689 -       /* set_vpp() must handle being reentered -- enable, enable, disable
4690 -          must leave it enabled. */
4691 +       /* This will be called with 1 as parameter when the first map user
4692 +        * needs VPP, and called with 0 when the last user exits. The map
4693 +        * core maintains a reference counter, and assumes that VPP is a
4694 +        * global resource applying to all mapped flash chips on the system.
4695 +        */
4696         void (*set_vpp)(struct map_info *, int);
4697
4698         unsigned long pfow_base;
4699 --- a/include/linux/mtd/mtd.h
4700 +++ b/include/linux/mtd/mtd.h
4701 @@ -100,17 +100,35 @@ struct mtd_oob_ops {
4702
4703  #define MTD_MAX_OOBFREE_ENTRIES_LARGE  32
4704  #define MTD_MAX_ECCPOS_ENTRIES_LARGE   640
4705 +/**
4706 + * struct mtd_oob_region - oob region definition
4707 + * @offset: region offset
4708 + * @length: region length
4709 + *
4710 + * This structure describes a region of the OOB area, and is used
4711 + * to retrieve ECC or free bytes sections.
4712 + * Each section is defined by an offset within the OOB area and a
4713 + * length.
4714 + */
4715 +struct mtd_oob_region {
4716 +       u32 offset;
4717 +       u32 length;
4718 +};
4719 +
4720  /*
4721 - * Internal ECC layout control structure. For historical reasons, there is a
4722 - * similar, smaller struct nand_ecclayout_user (in mtd-abi.h) that is retained
4723 - * for export to user-space via the ECCGETLAYOUT ioctl.
4724 - * nand_ecclayout should be expandable in the future simply by the above macros.
4725 + * struct mtd_ooblayout_ops - NAND OOB layout operations
4726 + * @ecc: function returning an ECC region in the OOB area.
4727 + *      Should return -ERANGE if %section exceeds the total number of
4728 + *      ECC sections.
4729 + * @free: function returning a free region in the OOB area.
4730 + *       Should return -ERANGE if %section exceeds the total number of
4731 + *       free sections.
4732   */
4733 -struct nand_ecclayout {
4734 -       __u32 eccbytes;
4735 -       __u32 eccpos[MTD_MAX_ECCPOS_ENTRIES_LARGE];
4736 -       __u32 oobavail;
4737 -       struct nand_oobfree oobfree[MTD_MAX_OOBFREE_ENTRIES_LARGE];
4738 +struct mtd_ooblayout_ops {
4739 +       int (*ecc)(struct mtd_info *mtd, int section,
4740 +                  struct mtd_oob_region *oobecc);
4741 +       int (*free)(struct mtd_info *mtd, int section,
4742 +                   struct mtd_oob_region *oobfree);
4743  };
4744
4745  struct module; /* only needed for owner field in mtd_info */
4746 @@ -171,8 +189,8 @@ struct mtd_info {
4747         const char *name;
4748         int index;
4749
4750 -       /* ECC layout structure pointer - read only! */
4751 -       struct nand_ecclayout *ecclayout;
4752 +       /* OOB layout description */
4753 +       const struct mtd_ooblayout_ops *ooblayout;
4754
4755         /* the ecc step size. */
4756         unsigned int ecc_step_size;
4757 @@ -258,6 +276,46 @@ struct mtd_info {
4758         int usecount;
4759  };
4760
4761 +int mtd_ooblayout_ecc(struct mtd_info *mtd, int section,
4762 +                     struct mtd_oob_region *oobecc);
4763 +int mtd_ooblayout_find_eccregion(struct mtd_info *mtd, int eccbyte,
4764 +                                int *section,
4765 +                                struct mtd_oob_region *oobregion);
4766 +int mtd_ooblayout_get_eccbytes(struct mtd_info *mtd, u8 *eccbuf,
4767 +                              const u8 *oobbuf, int start, int nbytes);
4768 +int mtd_ooblayout_set_eccbytes(struct mtd_info *mtd, const u8 *eccbuf,
4769 +                              u8 *oobbuf, int start, int nbytes);
4770 +int mtd_ooblayout_free(struct mtd_info *mtd, int section,
4771 +                      struct mtd_oob_region *oobfree);
4772 +int mtd_ooblayout_get_databytes(struct mtd_info *mtd, u8 *databuf,
4773 +                               const u8 *oobbuf, int start, int nbytes);
4774 +int mtd_ooblayout_set_databytes(struct mtd_info *mtd, const u8 *databuf,
4775 +                               u8 *oobbuf, int start, int nbytes);
4776 +int mtd_ooblayout_count_freebytes(struct mtd_info *mtd);
4777 +int mtd_ooblayout_count_eccbytes(struct mtd_info *mtd);
4778 +
4779 +static inline void mtd_set_ooblayout(struct mtd_info *mtd,
4780 +                                    const struct mtd_ooblayout_ops *ooblayout)
4781 +{
4782 +       mtd->ooblayout = ooblayout;
4783 +}
4784 +
4785 +static inline void mtd_set_of_node(struct mtd_info *mtd,
4786 +                                  struct device_node *np)
4787 +{
4788 +       mtd->dev.of_node = np;
4789 +}
4790 +
4791 +static inline struct device_node *mtd_get_of_node(struct mtd_info *mtd)
4792 +{
4793 +       return mtd->dev.of_node;
4794 +}
4795 +
4796 +static inline int mtd_oobavail(struct mtd_info *mtd, struct mtd_oob_ops *ops)
4797 +{
4798 +       return ops->mode == MTD_OPS_AUTO_OOB ? mtd->oobavail : mtd->oobsize;
4799 +}
4800 +
4801  int mtd_erase(struct mtd_info *mtd, struct erase_info *instr);
4802  int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
4803               void **virt, resource_size_t *phys);
4804 --- a/include/linux/mtd/nand.h
4805 +++ b/include/linux/mtd/nand.h
4806 @@ -119,6 +119,12 @@ typedef enum {
4807         NAND_ECC_SOFT_BCH,
4808  } nand_ecc_modes_t;
4809
4810 +enum nand_ecc_algo {
4811 +       NAND_ECC_UNKNOWN,
4812 +       NAND_ECC_HAMMING,
4813 +       NAND_ECC_BCH,
4814 +};
4815 +
4816  /*
4817   * Constants for Hardware ECC
4818   */
4819 @@ -129,6 +135,14 @@ typedef enum {
4820  /* Enable Hardware ECC before syndrome is read back from flash */
4821  #define NAND_ECC_READSYN       2
4822
4823 +/*
4824 + * Enable generic NAND 'page erased' check. This check is only done when
4825 + * ecc.correct() returns -EBADMSG.
4826 + * Set this flag if your implementation does not fix bitflips in erased
4827 + * pages and you want to rely on the default implementation.
4828 + */
4829 +#define NAND_ECC_GENERIC_ERASED_CHECK  BIT(0)
4830 +
4831  /* Bit mask for flags passed to do_nand_read_ecc */
4832  #define NAND_GET_DEVICE                0x80
4833
4834 @@ -160,6 +174,12 @@ typedef enum {
4835  /* Device supports subpage reads */
4836  #define NAND_SUBPAGE_READ      0x00001000
4837
4838 +/*
4839 + * Some MLC NANDs need data scrambling to limit bitflips caused by repeated
4840 + * patterns.
4841 + */
4842 +#define NAND_NEED_SCRAMBLING   0x00002000
4843 +
4844  /* Options valid for Samsung large page devices */
4845  #define NAND_SAMSUNG_LP_OPTIONS NAND_CACHEPRG
4846
4847 @@ -276,15 +296,15 @@ struct nand_onfi_params {
4848         __le16 t_r;
4849         __le16 t_ccs;
4850         __le16 src_sync_timing_mode;
4851 -       __le16 src_ssync_features;
4852 +       u8 src_ssync_features;
4853         __le16 clk_pin_capacitance_typ;
4854         __le16 io_pin_capacitance_typ;
4855         __le16 input_pin_capacitance_typ;
4856         u8 input_pin_capacitance_max;
4857         u8 driver_strength_support;
4858         __le16 t_int_r;
4859 -       __le16 t_ald;
4860 -       u8 reserved4[7];
4861 +       __le16 t_adl;
4862 +       u8 reserved4[8];
4863
4864         /* vendor */
4865         __le16 vendor_revision;
4866 @@ -407,7 +427,7 @@ struct nand_jedec_params {
4867         __le16 input_pin_capacitance_typ;
4868         __le16 clk_pin_capacitance_typ;
4869         u8 driver_strength_support;
4870 -       __le16 t_ald;
4871 +       __le16 t_adl;
4872         u8 reserved4[36];
4873
4874         /* ECC and endurance block */
4875 @@ -444,6 +464,7 @@ struct nand_hw_control {
4876  /**
4877   * struct nand_ecc_ctrl - Control structure for ECC
4878   * @mode:      ECC mode
4879 + * @algo:      ECC algorithm
4880   * @steps:     number of ECC steps per page
4881   * @size:      data bytes per ECC step
4882   * @bytes:     ECC bytes per step
4883 @@ -451,12 +472,18 @@ struct nand_hw_control {
4884   * @total:     total number of ECC bytes per page
4885   * @prepad:    padding information for syndrome based ECC generators
4886   * @postpad:   padding information for syndrome based ECC generators
4887 - * @layout:    ECC layout control struct pointer
4888 + * @options:   ECC specific options (see NAND_ECC_XXX flags defined above)
4889   * @priv:      pointer to private ECC control data
4890   * @hwctl:     function to control hardware ECC generator. Must only
4891   *             be provided if an hardware ECC is available
4892   * @calculate: function for ECC calculation or readback from ECC hardware
4893 - * @correct:   function for ECC correction, matching to ECC generator (sw/hw)
4894 + * @correct:   function for ECC correction, matching to ECC generator (sw/hw).
4895 + *             Should return a positive number representing the number of
4896 + *             corrected bitflips, -EBADMSG if the number of bitflips exceed
4897 + *             ECC strength, or any other error code if the error is not
4898 + *             directly related to correction.
4899 + *             If -EBADMSG is returned the input buffers should be left
4900 + *             untouched.
4901   * @read_page_raw:     function to read a raw page without ECC. This function
4902   *                     should hide the specific layout used by the ECC
4903   *                     controller and always return contiguous in-band and
4904 @@ -487,6 +514,7 @@ struct nand_hw_control {
4905   */
4906  struct nand_ecc_ctrl {
4907         nand_ecc_modes_t mode;
4908 +       enum nand_ecc_algo algo;
4909         int steps;
4910         int size;
4911         int bytes;
4912 @@ -494,7 +522,7 @@ struct nand_ecc_ctrl {
4913         int strength;
4914         int prepad;
4915         int postpad;
4916 -       struct nand_ecclayout   *layout;
4917 +       unsigned int options;
4918         void *priv;
4919         void (*hwctl)(struct mtd_info *mtd, int mode);
4920         int (*calculate)(struct mtd_info *mtd, const uint8_t *dat,
4921 @@ -540,11 +568,11 @@ struct nand_buffers {
4922
4923  /**
4924   * struct nand_chip - NAND Private Flash Chip Data
4925 + * @mtd:               MTD device registered to the MTD framework
4926   * @IO_ADDR_R:         [BOARDSPECIFIC] address to read the 8 I/O lines of the
4927   *                     flash device
4928   * @IO_ADDR_W:         [BOARDSPECIFIC] address to write the 8 I/O lines of the
4929   *                     flash device.
4930 - * @flash_node:                [BOARDSPECIFIC] device node describing this instance
4931   * @read_byte:         [REPLACEABLE] read one byte from the chip
4932   * @read_word:         [REPLACEABLE] read one word from the chip
4933   * @write_byte:                [REPLACEABLE] write a single byte to the chip on the
4934 @@ -640,18 +668,17 @@ struct nand_buffers {
4935   */
4936
4937  struct nand_chip {
4938 +       struct mtd_info mtd;
4939         void __iomem *IO_ADDR_R;
4940         void __iomem *IO_ADDR_W;
4941
4942 -       struct device_node *flash_node;
4943 -
4944         uint8_t (*read_byte)(struct mtd_info *mtd);
4945         u16 (*read_word)(struct mtd_info *mtd);
4946         void (*write_byte)(struct mtd_info *mtd, uint8_t byte);
4947         void (*write_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
4948         void (*read_buf)(struct mtd_info *mtd, uint8_t *buf, int len);
4949         void (*select_chip)(struct mtd_info *mtd, int chip);
4950 -       int (*block_bad)(struct mtd_info *mtd, loff_t ofs, int getchip);
4951 +       int (*block_bad)(struct mtd_info *mtd, loff_t ofs);
4952         int (*block_markbad)(struct mtd_info *mtd, loff_t ofs);
4953         void (*cmd_ctrl)(struct mtd_info *mtd, int dat, unsigned int ctrl);
4954         int (*dev_ready)(struct mtd_info *mtd);
4955 @@ -719,6 +746,40 @@ struct nand_chip {
4956         void *priv;
4957  };
4958
4959 +extern const struct mtd_ooblayout_ops nand_ooblayout_sp_ops;
4960 +extern const struct mtd_ooblayout_ops nand_ooblayout_lp_ops;
4961 +
4962 +static inline void nand_set_flash_node(struct nand_chip *chip,
4963 +                                      struct device_node *np)
4964 +{
4965 +       mtd_set_of_node(&chip->mtd, np);
4966 +}
4967 +
4968 +static inline struct device_node *nand_get_flash_node(struct nand_chip *chip)
4969 +{
4970 +       return mtd_get_of_node(&chip->mtd);
4971 +}
4972 +
4973 +static inline struct nand_chip *mtd_to_nand(struct mtd_info *mtd)
4974 +{
4975 +       return container_of(mtd, struct nand_chip, mtd);
4976 +}
4977 +
4978 +static inline struct mtd_info *nand_to_mtd(struct nand_chip *chip)
4979 +{
4980 +       return &chip->mtd;
4981 +}
4982 +
4983 +static inline void *nand_get_controller_data(struct nand_chip *chip)
4984 +{
4985 +       return chip->priv;
4986 +}
4987 +
4988 +static inline void nand_set_controller_data(struct nand_chip *chip, void *priv)
4989 +{
4990 +       chip->priv = priv;
4991 +}
4992 +
4993  /*
4994   * NAND Flash Manufacturer ID Codes
4995   */
4996 @@ -850,7 +911,6 @@ extern int nand_do_read(struct mtd_info
4997   * @chip_delay:                R/B delay value in us
4998   * @options:           Option flags, e.g. 16bit buswidth
4999   * @bbt_options:       BBT option flags, e.g. NAND_BBT_USE_FLASH
5000 - * @ecclayout:         ECC layout info structure
5001   * @part_probe_types:  NULL-terminated array of probe types
5002   */
5003  struct platform_nand_chip {
5004 @@ -858,7 +918,6 @@ struct platform_nand_chip {
5005         int chip_offset;
5006         int nr_partitions;
5007         struct mtd_partition *partitions;
5008 -       struct nand_ecclayout *ecclayout;
5009         int chip_delay;
5010         unsigned int options;
5011         unsigned int bbt_options;
5012 @@ -908,15 +967,6 @@ struct platform_nand_data {
5013         struct platform_nand_ctrl ctrl;
5014  };
5015
5016 -/* Some helpers to access the data structures */
5017 -static inline
5018 -struct platform_nand_chip *get_platform_nandchip(struct mtd_info *mtd)
5019 -{
5020 -       struct nand_chip *chip = mtd->priv;
5021 -
5022 -       return chip->priv;
5023 -}
5024 -
5025  /* return the supported features. */
5026  static inline int onfi_feature(struct nand_chip *chip)
5027  {
5028 --- a/include/linux/mtd/nand_bch.h
5029 +++ b/include/linux/mtd/nand_bch.h
5030 @@ -32,9 +32,7 @@ int nand_bch_correct_data(struct mtd_inf
5031  /*
5032   * Initialize BCH encoder/decoder
5033   */
5034 -struct nand_bch_control *
5035 -nand_bch_init(struct mtd_info *mtd, unsigned int eccsize,
5036 -             unsigned int eccbytes, struct nand_ecclayout **ecclayout);
5037 +struct nand_bch_control *nand_bch_init(struct mtd_info *mtd);
5038  /*
5039   * Release BCH encoder/decoder resources
5040   */
5041 @@ -55,12 +53,10 @@ static inline int
5042  nand_bch_correct_data(struct mtd_info *mtd, unsigned char *buf,
5043                       unsigned char *read_ecc, unsigned char *calc_ecc)
5044  {
5045 -       return -1;
5046 +       return -ENOTSUPP;
5047  }
5048
5049 -static inline struct nand_bch_control *
5050 -nand_bch_init(struct mtd_info *mtd, unsigned int eccsize,
5051 -             unsigned int eccbytes, struct nand_ecclayout **ecclayout)
5052 +static inline struct nand_bch_control *nand_bch_init(struct mtd_info *mtd)
5053  {
5054         return NULL;
5055  }
5056 --- a/include/linux/mtd/nftl.h
5057 +++ b/include/linux/mtd/nftl.h
5058 @@ -50,7 +50,6 @@ struct NFTLrecord {
5059          unsigned int nb_blocks;                /* number of physical blocks */
5060          unsigned int nb_boot_blocks;   /* number of blocks used by the bios */
5061          struct erase_info instr;
5062 -       struct nand_ecclayout oobinfo;
5063  };
5064
5065  int NFTL_mount(struct NFTLrecord *s);
5066 --- a/include/linux/mtd/onenand.h
5067 +++ b/include/linux/mtd/onenand.h
5068 @@ -80,7 +80,6 @@ struct onenand_bufferram {
5069   * @page_buf:          [INTERN] page main data buffer
5070   * @oob_buf:           [INTERN] page oob data buffer
5071   * @subpagesize:       [INTERN] holds the subpagesize
5072 - * @ecclayout:         [REPLACEABLE] the default ecc placement scheme
5073   * @bbm:               [REPLACEABLE] pointer to Bad Block Management
5074   * @priv:              [OPTIONAL] pointer to private chip date
5075   */
5076 @@ -134,7 +133,6 @@ struct onenand_chip {
5077  #endif
5078
5079         int                     subpagesize;
5080 -       struct nand_ecclayout   *ecclayout;
5081
5082         void                    *bbm;
5083
5084 --- a/include/linux/mtd/partitions.h
5085 +++ b/include/linux/mtd/partitions.h
5086 @@ -42,7 +42,6 @@ struct mtd_partition {
5087         uint64_t size;                  /* partition size */
5088         uint64_t offset;                /* offset within the master MTD space */
5089         uint32_t mask_flags;            /* master MTD flags to mask out for this partition */
5090 -       struct nand_ecclayout *ecclayout;       /* out of band layout for this partition (NAND only) */
5091  };
5092
5093  #define MTDPART_OFS_RETAIN     (-3)
5094 @@ -56,11 +55,9 @@ struct device_node;
5095  /**
5096   * struct mtd_part_parser_data - used to pass data to MTD partition parsers.
5097   * @origin: for RedBoot, start address of MTD device
5098 - * @of_node: for OF parsers, device node containing partitioning information
5099   */
5100  struct mtd_part_parser_data {
5101         unsigned long origin;
5102 -       struct device_node *of_node;
5103  };
5104
5105
5106 @@ -78,14 +75,34 @@ struct mtd_part_parser {
5107         struct list_head list;
5108         struct module *owner;
5109         const char *name;
5110 -       int (*parse_fn)(struct mtd_info *, struct mtd_partition **,
5111 +       int (*parse_fn)(struct mtd_info *, const struct mtd_partition **,
5112                         struct mtd_part_parser_data *);
5113 +       void (*cleanup)(const struct mtd_partition *pparts, int nr_parts);
5114         enum mtd_parser_type type;
5115  };
5116
5117 -extern void register_mtd_parser(struct mtd_part_parser *parser);
5118 +/* Container for passing around a set of parsed partitions */
5119 +struct mtd_partitions {
5120 +       const struct mtd_partition *parts;
5121 +       int nr_parts;
5122 +       const struct mtd_part_parser *parser;
5123 +};
5124 +
5125 +extern int __register_mtd_parser(struct mtd_part_parser *parser,
5126 +                                struct module *owner);
5127 +#define register_mtd_parser(parser) __register_mtd_parser(parser, THIS_MODULE)
5128 +
5129  extern void deregister_mtd_parser(struct mtd_part_parser *parser);
5130
5131 +/*
5132 + * module_mtd_part_parser() - Helper macro for MTD partition parsers that don't
5133 + * do anything special in module init/exit. Each driver may only use this macro
5134 + * once, and calling it replaces module_init() and module_exit().
5135 + */
5136 +#define module_mtd_part_parser(__mtd_part_parser) \
5137 +       module_driver(__mtd_part_parser, register_mtd_parser, \
5138 +                     deregister_mtd_parser)
5139 +
5140  int mtd_is_partition(const struct mtd_info *mtd);
5141  int mtd_add_partition(struct mtd_info *master, const char *name,
5142                       long long offset, long long length);
5143 --- a/include/linux/mtd/sh_flctl.h
5144 +++ b/include/linux/mtd/sh_flctl.h
5145 @@ -143,11 +143,11 @@ enum flctl_ecc_res_t {
5146  struct dma_chan;
5147
5148  struct sh_flctl {
5149 -       struct mtd_info         mtd;
5150         struct nand_chip        chip;
5151         struct platform_device  *pdev;
5152         struct dev_pm_qos_request pm_qos;
5153         void __iomem            *reg;
5154 +       resource_size_t         fifo;
5155
5156         uint8_t done_buff[2048 + 64];   /* max size 2048 + 64 */
5157         int     read_bytes;
5158 @@ -186,7 +186,7 @@ struct sh_flctl_platform_data {
5159
5160  static inline struct sh_flctl *mtd_to_flctl(struct mtd_info *mtdinfo)
5161  {
5162 -       return container_of(mtdinfo, struct sh_flctl, mtd);
5163 +       return container_of(mtd_to_nand(mtdinfo), struct sh_flctl, chip);
5164  }
5165
5166  #endif /* __SH_FLCTL_H__ */
5167 --- a/include/linux/mtd/sharpsl.h
5168 +++ b/include/linux/mtd/sharpsl.h
5169 @@ -14,7 +14,7 @@
5170
5171  struct sharpsl_nand_platform_data {
5172         struct nand_bbt_descr   *badblock_pattern;
5173 -       struct nand_ecclayout   *ecc_layout;
5174 +       const struct mtd_ooblayout_ops *ecc_layout;
5175         struct mtd_partition    *partitions;
5176         unsigned int            nr_partitions;
5177  };
5178 --- a/include/uapi/mtd/mtd-abi.h
5179 +++ b/include/uapi/mtd/mtd-abi.h
5180 @@ -228,7 +228,7 @@ struct nand_oobfree {
5181   * complete set of ECC information. The ioctl truncates the larger internal
5182   * structure to retain binary compatibility with the static declaration of the
5183   * ioctl. Note that the "MTD_MAX_..._ENTRIES" macros represent the max size of
5184 - * the user struct, not the MAX size of the internal struct nand_ecclayout.
5185 + * the user struct, not the MAX size of the internal OOB layout representation.
5186   */
5187  struct nand_ecclayout_user {
5188         __u32 eccbytes;
5189 --- a/fs/jffs2/wbuf.c
5190 +++ b/fs/jffs2/wbuf.c
5191 @@ -1153,7 +1153,7 @@ static struct jffs2_sb_info *work_to_sb(
5192  {
5193         struct delayed_work *dwork;
5194
5195 -       dwork = container_of(work, struct delayed_work, work);
5196 +       dwork = to_delayed_work(work);
5197         return container_of(dwork, struct jffs2_sb_info, wbuf_dwork);
5198  }
5199
5200 @@ -1183,22 +1183,20 @@ void jffs2_dirty_trigger(struct jffs2_sb
5201
5202  int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
5203  {
5204 -       struct nand_ecclayout *oinfo = c->mtd->ecclayout;
5205 -
5206         if (!c->mtd->oobsize)
5207                 return 0;
5208
5209         /* Cleanmarker is out-of-band, so inline size zero */
5210         c->cleanmarker_size = 0;
5211
5212 -       if (!oinfo || oinfo->oobavail == 0) {
5213 +       if (c->mtd->oobavail == 0) {
5214                 pr_err("inconsistent device description\n");
5215                 return -EINVAL;
5216         }
5217
5218         jffs2_dbg(1, "using OOB on NAND\n");
5219
5220 -       c->oobavail = oinfo->oobavail;
5221 +       c->oobavail = c->mtd->oobavail;
5222
5223         /* Initialise write buffer */
5224         init_rwsem(&c->wbuf_sem);
5225 --- a/include/linux/mtd/spi-nor.h
5226 +++ b/include/linux/mtd/spi-nor.h
5227 @@ -85,6 +85,7 @@
5228  #define SR_BP0                 BIT(2)  /* Block protect 0 */
5229  #define SR_BP1                 BIT(3)  /* Block protect 1 */
5230  #define SR_BP2                 BIT(4)  /* Block protect 2 */
5231 +#define SR_TB                  BIT(5)  /* Top/Bottom protect */
5232  #define SR_SRWD                        BIT(7)  /* SR write protect */
5233
5234  #define SR_QUAD_EN_MX          BIT(6)  /* Macronix Quad I/O */
5235 @@ -116,6 +117,7 @@ enum spi_nor_ops {
5236
5237  enum spi_nor_option_flags {
5238         SNOR_F_USE_FSR          = BIT(0),
5239 +       SNOR_F_HAS_SR_TB        = BIT(1),
5240  };
5241
5242  /**
5243 @@ -123,7 +125,6 @@ enum spi_nor_option_flags {
5244   * @mtd:               point to a mtd_info structure
5245   * @lock:              the lock for the read/write/erase/lock/unlock operations
5246   * @dev:               point to a spi device, or a spi nor controller device.
5247 - * @flash_node:                point to a device node describing this flash instance.
5248   * @page_size:         the page size of the SPI NOR
5249   * @addr_width:                number of address bytes
5250   * @erase_opcode:      the opcode for erasing a sector
5251 @@ -143,7 +144,8 @@ enum spi_nor_option_flags {
5252   * @read:              [DRIVER-SPECIFIC] read data from the SPI NOR
5253   * @write:             [DRIVER-SPECIFIC] write data to the SPI NOR
5254   * @erase:             [DRIVER-SPECIFIC] erase a sector of the SPI NOR
5255 - *                     at the offset @offs
5256 + *                     at the offset @offs; if not provided by the driver,
5257 + *                     spi-nor will send the erase opcode via write_reg()
5258   * @flash_lock:                [FLASH-SPECIFIC] lock a region of the SPI NOR
5259   * @flash_unlock:      [FLASH-SPECIFIC] unlock a region of the SPI NOR
5260   * @flash_is_locked:   [FLASH-SPECIFIC] check if a region of the SPI NOR is
5261 @@ -154,7 +156,6 @@ struct spi_nor {
5262         struct mtd_info         mtd;
5263         struct mutex            lock;
5264         struct device           *dev;
5265 -       struct device_node      *flash_node;
5266         u32                     page_size;
5267         u8                      addr_width;
5268         u8                      erase_opcode;
5269 @@ -184,6 +185,17 @@ struct spi_nor {
5270         void *priv;
5271  };
5272
5273 +static inline void spi_nor_set_flash_node(struct spi_nor *nor,
5274 +                                         struct device_node *np)
5275 +{
5276 +       mtd_set_of_node(&nor->mtd, np);
5277 +}
5278 +
5279 +static inline struct device_node *spi_nor_get_flash_node(struct spi_nor *nor)
5280 +{
5281 +       return mtd_get_of_node(&nor->mtd);
5282 +}
5283 +
5284  /**
5285   * spi_nor_scan() - scan the SPI NOR
5286   * @nor:       the spi_nor structure