From d10caae910327f3bf5163943d364c6c914921239 Mon Sep 17 00:00:00 2001 From: Zoltan HERPAI Date: Sun, 9 Aug 2015 12:25:18 +0000 Subject: sunxi: add support for 4.1 Signed-off-by: Zoltan HERPAI git-svn-id: svn://svn.openwrt.org/openwrt/trunk@46571 3c298f89-4303-0410-b956-a3cf2f4a3e73 --- .../111-mtd-add-support-for-nand-partitions.patch | 1307 ++++++++++++++++++++ 1 file changed, 1307 insertions(+) create mode 100644 target/linux/sunxi/patches-4.1/111-mtd-add-support-for-nand-partitions.patch (limited to 'target/linux/sunxi/patches-4.1/111-mtd-add-support-for-nand-partitions.patch') diff --git a/target/linux/sunxi/patches-4.1/111-mtd-add-support-for-nand-partitions.patch b/target/linux/sunxi/patches-4.1/111-mtd-add-support-for-nand-partitions.patch new file mode 100644 index 0000000000..88e313dbb5 --- /dev/null +++ b/target/linux/sunxi/patches-4.1/111-mtd-add-support-for-nand-partitions.patch @@ -0,0 +1,1307 @@ +From a95cc309cf74eed3fc457dec3dcc44d9bf79e0e6 Mon Sep 17 00:00:00 2001 +From: Boris BREZILLON +Date: Mon, 28 Jul 2014 15:01:15 +0200 +Subject: [PATCH] mtd: nand: Add support for NAND partitions + +Add support for NAND partitions, and indirectly for per partition ECC +config, and also per partiton random seed support for the upcoming +randomizer support. + +This is necessary to be able to use different ECC / randomizer settings for +the parts of the NAND which are read directly by a bootrom (which has a +fixed ECC / random seed setting) and the generic data part of the NAND for +which we often want a stronger ECC and / or random seed. + +Provide helper functions to add/delete/allocate nand partitions. +NAND core code now make use of the partition specific nand_ecc_ctrl struct +(if available) when doing read/write operations. + +Signed-off-by: Boris BREZILLON +Signed-off-by: Hans de Goede +--- + drivers/mtd/nand/Kconfig | 4 + + drivers/mtd/nand/Makefile | 2 + + drivers/mtd/nand/nand_base.c | 712 +++++++++++++++++++++++++++++++++++-------- + drivers/mtd/nand/nand_bch.c | 16 +- + drivers/mtd/nand/nand_ecc.c | 4 +- + include/linux/mtd/nand.h | 38 +++ + 6 files changed, 635 insertions(+), 141 deletions(-) + +diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig +index 5897d8d..8242470 100644 +--- a/drivers/mtd/nand/Kconfig ++++ b/drivers/mtd/nand/Kconfig +@@ -22,6 +22,10 @@ menuconfig MTD_NAND + + if MTD_NAND + ++config MTD_OF_NAND_PARTS ++ tristate ++ default n ++ + config MTD_NAND_BCH + tristate + select BCH +diff --git a/drivers/mtd/nand/Makefile b/drivers/mtd/nand/Makefile +index 582bbd05..fcbe032 100644 +--- a/drivers/mtd/nand/Makefile ++++ b/drivers/mtd/nand/Makefile +@@ -53,4 +53,6 @@ obj-$(CONFIG_MTD_NAND_BCM47XXNFLASH) += bcm47xxnflash/ + obj-$(CONFIG_MTD_NAND_SUNXI) += sunxi_nand.o + obj-$(CONFIG_MTD_NAND_HISI504) += hisi504_nand.o + ++obj-$(CONFIG_MTD_OF_NAND_PARTS) += ofnandpart.o ++ + nand-objs := nand_base.o nand_bbt.o nand_timings.o +diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c +index f580ed1..a30b67f 100644 +--- a/drivers/mtd/nand/nand_base.c ++++ b/drivers/mtd/nand/nand_base.c +@@ -1134,26 +1134,26 @@ static int nand_read_page_raw_syndrome(struct mtd_info *mtd, + struct nand_chip *chip, uint8_t *buf, + int oob_required, int page) + { +- int eccsize = chip->ecc.size; +- int eccbytes = chip->ecc.bytes; ++ int eccsize = chip->cur_ecc->size; ++ int eccbytes = chip->cur_ecc->bytes; + uint8_t *oob = chip->oob_poi; + int steps, size; + +- for (steps = chip->ecc.steps; steps > 0; steps--) { ++ for (steps = chip->cur_ecc->steps; steps > 0; steps--) { + chip->read_buf(mtd, buf, eccsize); + buf += eccsize; + +- if (chip->ecc.prepad) { +- chip->read_buf(mtd, oob, chip->ecc.prepad); +- oob += chip->ecc.prepad; ++ if (chip->cur_ecc->prepad) { ++ chip->read_buf(mtd, oob, chip->cur_ecc->prepad); ++ oob += chip->cur_ecc->prepad; + } + + chip->read_buf(mtd, oob, eccbytes); + oob += eccbytes; + +- if (chip->ecc.postpad) { +- chip->read_buf(mtd, oob, chip->ecc.postpad); +- oob += chip->ecc.postpad; ++ if (chip->cur_ecc->postpad) { ++ chip->read_buf(mtd, oob, chip->cur_ecc->postpad); ++ oob += chip->cur_ecc->postpad; + } + } + +@@ -1175,30 +1175,31 @@ static int nand_read_page_raw_syndrome(struct mtd_info *mtd, + static int nand_read_page_swecc(struct mtd_info *mtd, struct nand_chip *chip, + uint8_t *buf, int oob_required, int page) + { +- int i, eccsize = chip->ecc.size; +- int eccbytes = chip->ecc.bytes; +- int eccsteps = chip->ecc.steps; ++ int i, eccsize = chip->cur_ecc->size; ++ int eccbytes = chip->cur_ecc->bytes; ++ int eccsteps = chip->cur_ecc->steps; + uint8_t *p = buf; + uint8_t *ecc_calc = chip->buffers->ecccalc; + uint8_t *ecc_code = chip->buffers->ecccode; +- uint32_t *eccpos = chip->ecc.layout->eccpos; ++ uint32_t *eccpos = chip->cur_ecc->layout->eccpos; + unsigned int max_bitflips = 0; + +- chip->ecc.read_page_raw(mtd, chip, buf, 1, page); ++ chip->cur_ecc->read_page_raw(mtd, chip, buf, 1, page); + + for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) +- chip->ecc.calculate(mtd, p, &ecc_calc[i]); ++ chip->cur_ecc->calculate(mtd, p, &ecc_calc[i]); + +- for (i = 0; i < chip->ecc.total; i++) ++ for (i = 0; i < chip->cur_ecc->total; i++) + ecc_code[i] = chip->oob_poi[eccpos[i]]; + +- eccsteps = chip->ecc.steps; ++ eccsteps = chip->cur_ecc->steps; + p = buf; + + for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) { + int stat; + +- stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]); ++ stat = chip->cur_ecc->correct(mtd, p, &ecc_code[i], ++ &ecc_calc[i]); + if (stat < 0) { + mtd->ecc_stats.failed++; + } else { +@@ -1223,7 +1224,7 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip, + int page) + { + int start_step, end_step, num_steps; +- uint32_t *eccpos = chip->ecc.layout->eccpos; ++ uint32_t *eccpos = chip->cur_ecc->layout->eccpos; + uint8_t *p; + int data_col_addr, i, gaps = 0; + int datafrag_len, eccfrag_len, aligned_len, aligned_pos; +@@ -1232,16 +1233,16 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip, + unsigned int max_bitflips = 0; + + /* Column address within the page aligned to ECC size (256bytes) */ +- start_step = data_offs / chip->ecc.size; +- end_step = (data_offs + readlen - 1) / chip->ecc.size; ++ start_step = data_offs / chip->cur_ecc->size; ++ end_step = (data_offs + readlen - 1) / chip->cur_ecc->size; + num_steps = end_step - start_step + 1; +- index = start_step * chip->ecc.bytes; ++ index = start_step * chip->cur_ecc->bytes; + + /* Data size aligned to ECC ecc.size */ +- datafrag_len = num_steps * chip->ecc.size; +- eccfrag_len = num_steps * chip->ecc.bytes; ++ datafrag_len = num_steps * chip->cur_ecc->size; ++ eccfrag_len = num_steps * chip->cur_ecc->bytes; + +- data_col_addr = start_step * chip->ecc.size; ++ data_col_addr = start_step * chip->cur_ecc->size; + /* If we read not a page aligned data */ + if (data_col_addr != 0) + chip->cmdfunc(mtd, NAND_CMD_RNDOUT, data_col_addr, -1); +@@ -1250,8 +1251,9 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip, + chip->read_buf(mtd, p, datafrag_len); + + /* Calculate ECC */ +- for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) +- chip->ecc.calculate(mtd, p, &chip->buffers->ecccalc[i]); ++ for (i = 0; i < eccfrag_len; ++ i += chip->cur_ecc->bytes, p += chip->cur_ecc->size) ++ chip->cur_ecc->calculate(mtd, p, &chip->buffers->ecccalc[i]); + + /* + * The performance is faster if we position offsets according to +@@ -1275,7 +1277,8 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip, + aligned_len = eccfrag_len; + if (eccpos[index] & (busw - 1)) + aligned_len++; +- if (eccpos[index + (num_steps * chip->ecc.bytes)] & (busw - 1)) ++ if (eccpos[index + (num_steps * chip->cur_ecc->bytes)] & ++ (busw - 1)) + aligned_len++; + + chip->cmdfunc(mtd, NAND_CMD_RNDOUT, +@@ -1287,11 +1290,13 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip, + chip->buffers->ecccode[i] = chip->oob_poi[eccpos[i + index]]; + + p = bufpoi + data_col_addr; +- for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) { ++ for (i = 0; i < eccfrag_len; ++ i += chip->cur_ecc->bytes, p += chip->cur_ecc->size) { + int stat; + +- stat = chip->ecc.correct(mtd, p, +- &chip->buffers->ecccode[i], &chip->buffers->ecccalc[i]); ++ stat = chip->cur_ecc->correct(mtd, p, ++ &chip->buffers->ecccode[i], ++ &chip->buffers->ecccalc[i]); + if (stat < 0) { + mtd->ecc_stats.failed++; + } else { +@@ -1315,32 +1320,33 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip, + static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip, + uint8_t *buf, int oob_required, int page) + { +- int i, eccsize = chip->ecc.size; +- int eccbytes = chip->ecc.bytes; +- int eccsteps = chip->ecc.steps; ++ int i, eccsize = chip->cur_ecc->size; ++ int eccbytes = chip->cur_ecc->bytes; ++ int eccsteps = chip->cur_ecc->steps; + uint8_t *p = buf; + uint8_t *ecc_calc = chip->buffers->ecccalc; + uint8_t *ecc_code = chip->buffers->ecccode; +- uint32_t *eccpos = chip->ecc.layout->eccpos; ++ uint32_t *eccpos = chip->cur_ecc->layout->eccpos; + unsigned int max_bitflips = 0; + + for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) { +- chip->ecc.hwctl(mtd, NAND_ECC_READ); ++ chip->cur_ecc->hwctl(mtd, NAND_ECC_READ); + chip->read_buf(mtd, p, eccsize); +- chip->ecc.calculate(mtd, p, &ecc_calc[i]); ++ chip->cur_ecc->calculate(mtd, p, &ecc_calc[i]); + } + chip->read_buf(mtd, chip->oob_poi, mtd->oobsize); + +- for (i = 0; i < chip->ecc.total; i++) ++ for (i = 0; i < chip->cur_ecc->total; i++) + ecc_code[i] = chip->oob_poi[eccpos[i]]; + +- eccsteps = chip->ecc.steps; ++ eccsteps = chip->cur_ecc->steps; + p = buf; + + for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) { + int stat; + +- stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]); ++ stat = chip->cur_ecc->correct(mtd, p, &ecc_code[i], ++ &ecc_calc[i]); + if (stat < 0) { + mtd->ecc_stats.failed++; + } else { +@@ -1368,12 +1374,12 @@ static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip, + static int nand_read_page_hwecc_oob_first(struct mtd_info *mtd, + struct nand_chip *chip, uint8_t *buf, int oob_required, int page) + { +- int i, eccsize = chip->ecc.size; +- int eccbytes = chip->ecc.bytes; +- int eccsteps = chip->ecc.steps; ++ int i, eccsize = chip->cur_ecc->size; ++ int eccbytes = chip->cur_ecc->bytes; ++ int eccsteps = chip->cur_ecc->steps; + uint8_t *p = buf; + uint8_t *ecc_code = chip->buffers->ecccode; +- uint32_t *eccpos = chip->ecc.layout->eccpos; ++ uint32_t *eccpos = chip->cur_ecc->layout->eccpos; + uint8_t *ecc_calc = chip->buffers->ecccalc; + unsigned int max_bitflips = 0; + +@@ -1382,17 +1388,17 @@ static int nand_read_page_hwecc_oob_first(struct mtd_info *mtd, + chip->read_buf(mtd, chip->oob_poi, mtd->oobsize); + chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page); + +- for (i = 0; i < chip->ecc.total; i++) ++ for (i = 0; i < chip->cur_ecc->total; i++) + ecc_code[i] = chip->oob_poi[eccpos[i]]; + + for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) { + int stat; + +- chip->ecc.hwctl(mtd, NAND_ECC_READ); ++ chip->cur_ecc->hwctl(mtd, NAND_ECC_READ); + chip->read_buf(mtd, p, eccsize); +- chip->ecc.calculate(mtd, p, &ecc_calc[i]); ++ chip->cur_ecc->calculate(mtd, p, &ecc_calc[i]); + +- stat = chip->ecc.correct(mtd, p, &ecc_code[i], NULL); ++ stat = chip->cur_ecc->correct(mtd, p, &ecc_code[i], NULL); + if (stat < 0) { + mtd->ecc_stats.failed++; + } else { +@@ -1417,9 +1423,9 @@ static int nand_read_page_hwecc_oob_first(struct mtd_info *mtd, + static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip, + uint8_t *buf, int oob_required, int page) + { +- int i, eccsize = chip->ecc.size; +- int eccbytes = chip->ecc.bytes; +- int eccsteps = chip->ecc.steps; ++ int i, eccsize = chip->cur_ecc->size; ++ int eccbytes = chip->cur_ecc->bytes; ++ int eccsteps = chip->cur_ecc->steps; + uint8_t *p = buf; + uint8_t *oob = chip->oob_poi; + unsigned int max_bitflips = 0; +@@ -1427,17 +1433,17 @@ static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip, + for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) { + int stat; + +- chip->ecc.hwctl(mtd, NAND_ECC_READ); ++ chip->cur_ecc->hwctl(mtd, NAND_ECC_READ); + chip->read_buf(mtd, p, eccsize); + +- if (chip->ecc.prepad) { +- chip->read_buf(mtd, oob, chip->ecc.prepad); +- oob += chip->ecc.prepad; ++ if (chip->cur_ecc->prepad) { ++ chip->read_buf(mtd, oob, chip->cur_ecc->prepad); ++ oob += chip->cur_ecc->prepad; + } + +- chip->ecc.hwctl(mtd, NAND_ECC_READSYN); ++ chip->cur_ecc->hwctl(mtd, NAND_ECC_READSYN); + chip->read_buf(mtd, oob, eccbytes); +- stat = chip->ecc.correct(mtd, p, oob, NULL); ++ stat = chip->cur_ecc->correct(mtd, p, oob, NULL); + + if (stat < 0) { + mtd->ecc_stats.failed++; +@@ -1448,9 +1454,9 @@ static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip, + + oob += eccbytes; + +- if (chip->ecc.postpad) { +- chip->read_buf(mtd, oob, chip->ecc.postpad); +- oob += chip->ecc.postpad; ++ if (chip->cur_ecc->postpad) { ++ chip->read_buf(mtd, oob, chip->cur_ecc->postpad); ++ oob += chip->cur_ecc->postpad; + } + } + +@@ -1480,7 +1486,7 @@ static uint8_t *nand_transfer_oob(struct nand_chip *chip, uint8_t *oob, + return oob + len; + + case MTD_OPS_AUTO_OOB: { +- struct nand_oobfree *free = chip->ecc.layout->oobfree; ++ struct nand_oobfree *free = chip->cur_ecc->layout->oobfree; + uint32_t boffs = 0, roffs = ops->ooboffs; + size_t bytes = 0; + +@@ -1600,17 +1606,21 @@ static int nand_do_read_ops(struct mtd_info *mtd, loff_t from, + * the read methods return max bitflips per ecc step. + */ + if (unlikely(ops->mode == MTD_OPS_RAW)) +- ret = chip->ecc.read_page_raw(mtd, chip, bufpoi, +- oob_required, +- page); ++ ret = chip->cur_ecc->read_page_raw(mtd, chip, ++ bufpoi, ++ oob_required, ++ page); + else if (!aligned && NAND_HAS_SUBPAGE_READ(chip) && + !oob) +- ret = chip->ecc.read_subpage(mtd, chip, +- col, bytes, bufpoi, +- page); ++ ret = chip->cur_ecc->read_subpage(mtd, chip, ++ col, bytes, ++ bufpoi, ++ page); + else +- ret = chip->ecc.read_page(mtd, chip, bufpoi, +- oob_required, page); ++ ret = chip->cur_ecc->read_page(mtd, chip, ++ bufpoi, ++ oob_required, ++ page); + if (ret < 0) { + if (use_bufpoi) + /* Invalidate page cache */ +@@ -1746,6 +1756,39 @@ static int nand_read(struct mtd_info *mtd, loff_t from, size_t len, + } + + /** ++ * nand_part_read - [MTD Interface] MTD compatibility function for nand_do_read_ecc ++ * @mtd: MTD device structure ++ * @from: offset to read from ++ * @len: number of bytes to read ++ * @retlen: pointer to variable to store the number of read bytes ++ * @buf: the databuffer to put data ++ * ++ * Get hold of the chip and call nand_do_read. ++ */ ++static int nand_part_read(struct mtd_info *mtd, loff_t from, size_t len, ++ size_t *retlen, uint8_t *buf) ++{ ++ struct nand_chip *chip = mtd->priv; ++ struct nand_part *part = to_nand_part(mtd); ++ struct mtd_oob_ops ops; ++ int ret; ++ ++ from += part->offset; ++ nand_get_device(part->master, FL_READING); ++ if (part->ecc) ++ chip->cur_ecc = part->ecc; ++ ops.len = len; ++ ops.datbuf = buf; ++ ops.oobbuf = NULL; ++ ops.mode = MTD_OPS_PLACE_OOB; ++ ret = nand_do_read_ops(part->master, from, &ops); ++ *retlen = ops.retlen; ++ chip->cur_ecc = &chip->ecc; ++ nand_release_device(part->master); ++ return ret; ++} ++ ++/** + * nand_read_oob_std - [REPLACEABLE] the most common OOB data read function + * @mtd: mtd info structure + * @chip: nand chip info structure +@@ -1770,13 +1813,14 @@ static int nand_read_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip, + int page) + { + int length = mtd->oobsize; +- int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad; +- int eccsize = chip->ecc.size; ++ int chunk = chip->cur_ecc->bytes + chip->cur_ecc->prepad + ++ chip->cur_ecc->postpad; ++ int eccsize = chip->cur_ecc->size; + uint8_t *bufpoi = chip->oob_poi; + int i, toread, sndrnd = 0, pos; + +- chip->cmdfunc(mtd, NAND_CMD_READ0, chip->ecc.size, page); +- for (i = 0; i < chip->ecc.steps; i++) { ++ chip->cmdfunc(mtd, NAND_CMD_READ0, chip->cur_ecc->size, page); ++ for (i = 0; i < chip->cur_ecc->steps; i++) { + if (sndrnd) { + pos = eccsize + i * (eccsize + chunk); + if (mtd->writesize > 512) +@@ -1829,9 +1873,10 @@ static int nand_write_oob_std(struct mtd_info *mtd, struct nand_chip *chip, + static int nand_write_oob_syndrome(struct mtd_info *mtd, + struct nand_chip *chip, int page) + { +- int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad; +- int eccsize = chip->ecc.size, length = mtd->oobsize; +- int i, len, pos, status = 0, sndcmd = 0, steps = chip->ecc.steps; ++ int chunk = chip->cur_ecc->bytes + chip->cur_ecc->prepad + ++ chip->cur_ecc->postpad; ++ int eccsize = chip->cur_ecc->size, length = mtd->oobsize; ++ int i, len, pos, status = 0, sndcmd = 0, steps = chip->cur_ecc->steps; + const uint8_t *bufpoi = chip->oob_poi; + + /* +@@ -1839,7 +1884,7 @@ static int nand_write_oob_syndrome(struct mtd_info *mtd, + * or + * data-pad-ecc-pad-data-pad .... ecc-pad-oob + */ +- if (!chip->ecc.prepad && !chip->ecc.postpad) { ++ if (!chip->cur_ecc->prepad && !chip->cur_ecc->postpad) { + pos = steps * (eccsize + chunk); + steps = 0; + } else +@@ -1903,7 +1948,7 @@ static int nand_do_read_oob(struct mtd_info *mtd, loff_t from, + stats = mtd->ecc_stats; + + if (ops->mode == MTD_OPS_AUTO_OOB) +- len = chip->ecc.layout->oobavail; ++ len = chip->cur_ecc->layout->oobavail; + else + len = mtd->oobsize; + +@@ -1931,9 +1976,9 @@ static int nand_do_read_oob(struct mtd_info *mtd, loff_t from, + + while (1) { + if (ops->mode == MTD_OPS_RAW) +- ret = chip->ecc.read_oob_raw(mtd, chip, page); ++ ret = chip->cur_ecc->read_oob_raw(mtd, chip, page); + else +- ret = chip->ecc.read_oob(mtd, chip, page); ++ ret = chip->cur_ecc->read_oob(mtd, chip, page); + + if (ret < 0) + break; +@@ -2021,6 +2066,56 @@ static int nand_read_oob(struct mtd_info *mtd, loff_t from, + return ret; + } + ++/** ++ * nand_part_read_oob - [MTD Interface] NAND read data and/or out-of-band ++ * @mtd: MTD device structure ++ * @from: offset to read from ++ * @ops: oob operation description structure ++ * ++ * NAND read data and/or out-of-band data. ++ */ ++static int nand_part_read_oob(struct mtd_info *mtd, loff_t from, ++ struct mtd_oob_ops *ops) ++{ ++ struct nand_chip *chip = mtd->priv; ++ struct nand_part *part = to_nand_part(mtd); ++ int ret = -ENOTSUPP; ++ ++ ops->retlen = 0; ++ ++ /* Do not allow reads past end of device */ ++ if (ops->datbuf && (from + ops->len) > mtd->size) { ++ pr_debug("%s: attempt to read beyond end of device\n", ++ __func__); ++ return -EINVAL; ++ } ++ ++ from += part->offset; ++ nand_get_device(part->master, FL_READING); ++ if (part->ecc) ++ chip->cur_ecc = part->ecc; ++ ++ switch (ops->mode) { ++ case MTD_OPS_PLACE_OOB: ++ case MTD_OPS_AUTO_OOB: ++ case MTD_OPS_RAW: ++ break; ++ ++ default: ++ goto out; ++ } ++ ++ if (!ops->datbuf) ++ ret = nand_do_read_oob(part->master, from, ops); ++ else ++ ret = nand_do_read_ops(part->master, from, ops); ++ ++out: ++ chip->cur_ecc = &chip->ecc; ++ nand_release_device(part->master); ++ return ret; ++} ++ + + /** + * nand_write_page_raw - [INTERN] raw page write function +@@ -2054,26 +2149,26 @@ static int nand_write_page_raw_syndrome(struct mtd_info *mtd, + struct nand_chip *chip, + const uint8_t *buf, int oob_required) + { +- int eccsize = chip->ecc.size; +- int eccbytes = chip->ecc.bytes; ++ int eccsize = chip->cur_ecc->size; ++ int eccbytes = chip->cur_ecc->bytes; + uint8_t *oob = chip->oob_poi; + int steps, size; + +- for (steps = chip->ecc.steps; steps > 0; steps--) { ++ for (steps = chip->cur_ecc->steps; steps > 0; steps--) { + chip->write_buf(mtd, buf, eccsize); + buf += eccsize; + +- if (chip->ecc.prepad) { +- chip->write_buf(mtd, oob, chip->ecc.prepad); +- oob += chip->ecc.prepad; ++ if (chip->cur_ecc->prepad) { ++ chip->write_buf(mtd, oob, chip->cur_ecc->prepad); ++ oob += chip->cur_ecc->prepad; + } + + chip->write_buf(mtd, oob, eccbytes); + oob += eccbytes; + +- if (chip->ecc.postpad) { +- chip->write_buf(mtd, oob, chip->ecc.postpad); +- oob += chip->ecc.postpad; ++ if (chip->cur_ecc->postpad) { ++ chip->write_buf(mtd, oob, chip->cur_ecc->postpad); ++ oob += chip->cur_ecc->postpad; + } + } + +@@ -2093,21 +2188,21 @@ static int nand_write_page_raw_syndrome(struct mtd_info *mtd, + static int nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip, + const uint8_t *buf, int oob_required) + { +- int i, eccsize = chip->ecc.size; +- int eccbytes = chip->ecc.bytes; +- int eccsteps = chip->ecc.steps; ++ int i, eccsize = chip->cur_ecc->size; ++ int eccbytes = chip->cur_ecc->bytes; ++ int eccsteps = chip->cur_ecc->steps; + uint8_t *ecc_calc = chip->buffers->ecccalc; + const uint8_t *p = buf; +- uint32_t *eccpos = chip->ecc.layout->eccpos; ++ uint32_t *eccpos = chip->cur_ecc->layout->eccpos; + + /* Software ECC calculation */ + for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) +- chip->ecc.calculate(mtd, p, &ecc_calc[i]); ++ chip->cur_ecc->calculate(mtd, p, &ecc_calc[i]); + +- for (i = 0; i < chip->ecc.total; i++) ++ for (i = 0; i < chip->cur_ecc->total; i++) + chip->oob_poi[eccpos[i]] = ecc_calc[i]; + +- return chip->ecc.write_page_raw(mtd, chip, buf, 1); ++ return chip->cur_ecc->write_page_raw(mtd, chip, buf, 1); + } + + /** +@@ -2120,20 +2215,20 @@ static int nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip, + static int nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip, + const uint8_t *buf, int oob_required) + { +- int i, eccsize = chip->ecc.size; +- int eccbytes = chip->ecc.bytes; +- int eccsteps = chip->ecc.steps; ++ int i, eccsize = chip->cur_ecc->size; ++ int eccbytes = chip->cur_ecc->bytes; ++ int eccsteps = chip->cur_ecc->steps; + uint8_t *ecc_calc = chip->buffers->ecccalc; + const uint8_t *p = buf; +- uint32_t *eccpos = chip->ecc.layout->eccpos; ++ uint32_t *eccpos = chip->cur_ecc->layout->eccpos; + + for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) { +- chip->ecc.hwctl(mtd, NAND_ECC_WRITE); ++ chip->cur_ecc->hwctl(mtd, NAND_ECC_WRITE); + chip->write_buf(mtd, p, eccsize); +- chip->ecc.calculate(mtd, p, &ecc_calc[i]); ++ chip->cur_ecc->calculate(mtd, p, &ecc_calc[i]); + } + +- for (i = 0; i < chip->ecc.total; i++) ++ for (i = 0; i < chip->cur_ecc->total; i++) + chip->oob_poi[eccpos[i]] = ecc_calc[i]; + + chip->write_buf(mtd, chip->oob_poi, mtd->oobsize); +@@ -2158,10 +2253,10 @@ static int nand_write_subpage_hwecc(struct mtd_info *mtd, + { + uint8_t *oob_buf = chip->oob_poi; + uint8_t *ecc_calc = chip->buffers->ecccalc; +- int ecc_size = chip->ecc.size; +- int ecc_bytes = chip->ecc.bytes; +- int ecc_steps = chip->ecc.steps; +- uint32_t *eccpos = chip->ecc.layout->eccpos; ++ int ecc_size = chip->cur_ecc->size; ++ int ecc_bytes = chip->cur_ecc->bytes; ++ int ecc_steps = chip->cur_ecc->steps; ++ uint32_t *eccpos = chip->cur_ecc->layout->eccpos; + uint32_t start_step = offset / ecc_size; + uint32_t end_step = (offset + data_len - 1) / ecc_size; + int oob_bytes = mtd->oobsize / ecc_steps; +@@ -2169,7 +2264,7 @@ static int nand_write_subpage_hwecc(struct mtd_info *mtd, + + for (step = 0; step < ecc_steps; step++) { + /* configure controller for WRITE access */ +- chip->ecc.hwctl(mtd, NAND_ECC_WRITE); ++ chip->cur_ecc->hwctl(mtd, NAND_ECC_WRITE); + + /* write data (untouched subpages already masked by 0xFF) */ + chip->write_buf(mtd, buf, ecc_size); +@@ -2178,7 +2273,7 @@ static int nand_write_subpage_hwecc(struct mtd_info *mtd, + if ((step < start_step) || (step > end_step)) + memset(ecc_calc, 0xff, ecc_bytes); + else +- chip->ecc.calculate(mtd, buf, ecc_calc); ++ chip->cur_ecc->calculate(mtd, buf, ecc_calc); + + /* mask OOB of un-touched subpages by padding 0xFF */ + /* if oob_required, preserve OOB metadata of written subpage */ +@@ -2193,7 +2288,7 @@ static int nand_write_subpage_hwecc(struct mtd_info *mtd, + /* copy calculated ECC for whole page to chip->buffer->oob */ + /* this include masked-value(0xFF) for unwritten subpages */ + ecc_calc = chip->buffers->ecccalc; +- for (i = 0; i < chip->ecc.total; i++) ++ for (i = 0; i < chip->cur_ecc->total; i++) + chip->oob_poi[eccpos[i]] = ecc_calc[i]; + + /* write OOB buffer to NAND device */ +@@ -2217,29 +2312,29 @@ static int nand_write_page_syndrome(struct mtd_info *mtd, + struct nand_chip *chip, + const uint8_t *buf, int oob_required) + { +- int i, eccsize = chip->ecc.size; +- int eccbytes = chip->ecc.bytes; +- int eccsteps = chip->ecc.steps; ++ int i, eccsize = chip->cur_ecc->size; ++ int eccbytes = chip->cur_ecc->bytes; ++ int eccsteps = chip->cur_ecc->steps; + const uint8_t *p = buf; + uint8_t *oob = chip->oob_poi; + + for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) { + +- chip->ecc.hwctl(mtd, NAND_ECC_WRITE); ++ chip->cur_ecc->hwctl(mtd, NAND_ECC_WRITE); + chip->write_buf(mtd, p, eccsize); + +- if (chip->ecc.prepad) { +- chip->write_buf(mtd, oob, chip->ecc.prepad); +- oob += chip->ecc.prepad; ++ if (chip->cur_ecc->prepad) { ++ chip->write_buf(mtd, oob, chip->cur_ecc->prepad); ++ oob += chip->cur_ecc->prepad; + } + +- chip->ecc.calculate(mtd, p, oob); ++ chip->cur_ecc->calculate(mtd, p, oob); + chip->write_buf(mtd, oob, eccbytes); + oob += eccbytes; + +- if (chip->ecc.postpad) { +- chip->write_buf(mtd, oob, chip->ecc.postpad); +- oob += chip->ecc.postpad; ++ if (chip->cur_ecc->postpad) { ++ chip->write_buf(mtd, oob, chip->cur_ecc->postpad); ++ oob += chip->cur_ecc->postpad; + } + } + +@@ -2270,7 +2365,7 @@ static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip, + int status, subpage; + + if (!(chip->options & NAND_NO_SUBPAGE_WRITE) && +- chip->ecc.write_subpage) ++ chip->cur_ecc->write_subpage) + subpage = offset || (data_len < mtd->writesize); + else + subpage = 0; +@@ -2278,13 +2373,15 @@ static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip, + chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page); + + if (unlikely(raw)) +- status = chip->ecc.write_page_raw(mtd, chip, buf, +- oob_required); ++ status = chip->cur_ecc->write_page_raw(mtd, chip, buf, ++ oob_required); + else if (subpage) +- status = chip->ecc.write_subpage(mtd, chip, offset, data_len, +- buf, oob_required); ++ status = chip->cur_ecc->write_subpage(mtd, chip, offset, ++ data_len, buf, ++ oob_required); + else +- status = chip->ecc.write_page(mtd, chip, buf, oob_required); ++ status = chip->cur_ecc->write_page(mtd, chip, buf, ++ oob_required); + + if (status < 0) + return status; +@@ -2343,7 +2440,7 @@ static uint8_t *nand_fill_oob(struct mtd_info *mtd, uint8_t *oob, size_t len, + return oob + len; + + case MTD_OPS_AUTO_OOB: { +- struct nand_oobfree *free = chip->ecc.layout->oobfree; ++ struct nand_oobfree *free = chip->cur_ecc->layout->oobfree; + uint32_t boffs = 0, woffs = ops->ooboffs; + size_t bytes = 0; + +@@ -2539,6 +2636,46 @@ static int panic_nand_write(struct mtd_info *mtd, loff_t to, size_t len, + } + + /** ++ * panic_nand_part_write - [MTD Interface] NAND write with ECC ++ * @mtd: MTD device structure ++ * @to: offset to write to ++ * @len: number of bytes to write ++ * @retlen: pointer to variable to store the number of written bytes ++ * @buf: the data to write ++ * ++ * NAND write with ECC. Used when performing writes in interrupt context, this ++ * may for example be called by mtdoops when writing an oops while in panic. ++ */ ++static int panic_nand_part_write(struct mtd_info *mtd, loff_t to, size_t len, ++ size_t *retlen, const uint8_t *buf) ++{ ++ struct nand_chip *chip = mtd->priv; ++ struct nand_part *part = to_nand_part(mtd); ++ struct mtd_oob_ops ops; ++ int ret; ++ ++ to += part->offset; ++ /* Wait for the device to get ready */ ++ panic_nand_wait(part->master, chip, 400); ++ ++ /* Grab the device */ ++ panic_nand_get_device(chip, part->master, FL_WRITING); ++ if (part->ecc) ++ chip->cur_ecc = part->ecc; ++ ++ ops.len = len; ++ ops.datbuf = (uint8_t *)buf; ++ ops.oobbuf = NULL; ++ ops.mode = MTD_OPS_PLACE_OOB; ++ ++ ret = nand_do_write_ops(part->master, to, &ops); ++ ++ chip->cur_ecc = &chip->ecc; ++ *retlen = ops.retlen; ++ return ret; ++} ++ ++/** + * nand_write - [MTD Interface] NAND write with ECC + * @mtd: MTD device structure + * @to: offset to write to +@@ -2566,6 +2703,39 @@ static int nand_write(struct mtd_info *mtd, loff_t to, size_t len, + } + + /** ++ * nand_part_write - [MTD Interface] NAND write with ECC ++ * @mtd: MTD device structure ++ * @to: offset to write to ++ * @len: number of bytes to write ++ * @retlen: pointer to variable to store the number of written bytes ++ * @buf: the data to write ++ * ++ * NAND write with ECC. ++ */ ++static int nand_part_write(struct mtd_info *mtd, loff_t to, size_t len, ++ size_t *retlen, const uint8_t *buf) ++{ ++ struct nand_chip *chip = mtd->priv; ++ struct nand_part *part = to_nand_part(mtd); ++ struct mtd_oob_ops ops; ++ int ret; ++ ++ to += part->offset; ++ nand_get_device(part->master, FL_WRITING); ++ if (part->ecc) ++ chip->cur_ecc = part->ecc; ++ ops.len = len; ++ ops.datbuf = (uint8_t *)buf; ++ ops.oobbuf = NULL; ++ ops.mode = MTD_OPS_PLACE_OOB; ++ ret = nand_do_write_ops(part->master, to, &ops); ++ *retlen = ops.retlen; ++ chip->cur_ecc = &chip->ecc; ++ nand_release_device(part->master); ++ return ret; ++} ++ ++/** + * nand_do_write_oob - [MTD Interface] NAND write out-of-band + * @mtd: MTD device structure + * @to: offset to write to +@@ -2583,7 +2753,7 @@ static int nand_do_write_oob(struct mtd_info *mtd, loff_t to, + __func__, (unsigned int)to, (int)ops->ooblen); + + if (ops->mode == MTD_OPS_AUTO_OOB) +- len = chip->ecc.layout->oobavail; ++ len = chip->cur_ecc->layout->oobavail; + else + len = mtd->oobsize; + +@@ -2637,9 +2807,11 @@ static int nand_do_write_oob(struct mtd_info *mtd, loff_t to, + nand_fill_oob(mtd, ops->oobbuf, ops->ooblen, ops); + + if (ops->mode == MTD_OPS_RAW) +- status = chip->ecc.write_oob_raw(mtd, chip, page & chip->pagemask); ++ status = chip->cur_ecc->write_oob_raw(mtd, chip, ++ page & chip->pagemask); + else +- status = chip->ecc.write_oob(mtd, chip, page & chip->pagemask); ++ status = chip->cur_ecc->write_oob(mtd, chip, ++ page & chip->pagemask); + + chip->select_chip(mtd, -1); + +@@ -2694,6 +2866,54 @@ static int nand_write_oob(struct mtd_info *mtd, loff_t to, + } + + /** ++ * nand_write_oob - [MTD Interface] NAND write data and/or out-of-band ++ * @mtd: MTD device structure ++ * @to: offset to write to ++ * @ops: oob operation description structure ++ */ ++static int nand_part_write_oob(struct mtd_info *mtd, loff_t to, ++ struct mtd_oob_ops *ops) ++{ ++ struct nand_chip *chip = mtd->priv; ++ struct nand_part *part = to_nand_part(mtd); ++ int ret = -ENOTSUPP; ++ ++ ops->retlen = 0; ++ ++ /* Do not allow writes past end of device */ ++ if (ops->datbuf && (to + ops->len) > mtd->size) { ++ pr_debug("%s: attempt to write beyond end of device\n", ++ __func__); ++ return -EINVAL; ++ } ++ ++ to += part->offset; ++ nand_get_device(part->master, FL_WRITING); ++ if (part->ecc) ++ chip->cur_ecc = part->ecc; ++ ++ switch (ops->mode) { ++ case MTD_OPS_PLACE_OOB: ++ case MTD_OPS_AUTO_OOB: ++ case MTD_OPS_RAW: ++ break; ++ ++ default: ++ goto out; ++ } ++ ++ if (!ops->datbuf) ++ ret = nand_do_write_oob(part->master, to, ops); ++ else ++ ret = nand_do_write_ops(part->master, to, ops); ++ ++out: ++ chip->cur_ecc = &chip->ecc; ++ nand_release_device(part->master); ++ return ret; ++} ++ ++/** + * single_erase - [GENERIC] NAND standard block erase command function + * @mtd: MTD device structure + * @page: the page address of the block which will be erased +@@ -2723,6 +2943,29 @@ static int nand_erase(struct mtd_info *mtd, struct erase_info *instr) + } + + /** ++ * nand_part_erase - [MTD Interface] erase partition block(s) ++ * @mtd: MTD device structure ++ * @instr: erase instruction ++ * ++ * Erase one ore more blocks. ++ */ ++static int nand_part_erase(struct mtd_info *mtd, struct erase_info *instr) ++{ ++ struct nand_part *part = to_nand_part(mtd); ++ int ret; ++ ++ instr->addr += part->offset; ++ ret = nand_erase_nand(part->master, instr, 0); ++ if (ret) { ++ if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN) ++ instr->fail_addr -= part->offset; ++ instr->addr -= part->offset; ++ } ++ ++ return ret; ++} ++ ++/** + * nand_erase_nand - [INTERN] erase block(s) + * @mtd: MTD device structure + * @instr: erase instruction +@@ -2864,6 +3107,18 @@ static int nand_block_isbad(struct mtd_info *mtd, loff_t offs) + } + + /** ++ * nand_part_block_isbad - [MTD Interface] Check if block at offset is bad ++ * @mtd: MTD device structure ++ * @offs: offset relative to mtd start ++ */ ++static int nand_part_block_isbad(struct mtd_info *mtd, loff_t offs) ++{ ++ struct nand_part *part = to_nand_part(mtd); ++ ++ return nand_block_checkbad(part->master, part->offset + offs, 1, 0); ++} ++ ++/** + * nand_block_markbad - [MTD Interface] Mark block at the given offset as bad + * @mtd: MTD device structure + * @ofs: offset relative to mtd start +@@ -2884,6 +3139,33 @@ static int nand_block_markbad(struct mtd_info *mtd, loff_t ofs) + } + + /** ++ * nand_part_block_markbad - [MTD Interface] Mark block at the given offset as ++ * bad ++ * @mtd: MTD device structure ++ * @ofs: offset relative to mtd start ++ */ ++static int nand_part_block_markbad(struct mtd_info *mtd, loff_t ofs) ++{ ++ struct nand_part *part = to_nand_part(mtd); ++ int ret; ++ ++ ofs += part->offset; ++ ret = nand_block_isbad(part->master, ofs); ++ if (ret) { ++ /* If it was bad already, return success and do nothing */ ++ if (ret > 0) ++ return 0; ++ return ret; ++ } ++ ++ ret = nand_block_markbad_lowlevel(part->master, ofs); ++ if (!ret) ++ mtd->ecc_stats.badblocks++; ++ ++ return ret; ++} ++ ++/** + * nand_onfi_set_features- [REPLACEABLE] set features for ONFI nand + * @mtd: MTD device structure + * @chip: nand chip info structure +@@ -4099,6 +4381,169 @@ static int nand_ecc_ctrl_init(struct mtd_info *mtd, struct nand_ecc_ctrl *ecc) + } + + /** ++ * nand_add_partition - [NAND Interface] Add a NAND partition to a NAND device ++ * @master: MTD device structure representing the NAND device ++ * @part: NAND partition to add to the NAND device ++ * ++ * Adds a NAND partition to a NAND device. ++ * The NAND partition cannot overlap with another existing partition. ++ * ++ * Returns zero in case of success and a negative error code in case of failure. ++ */ ++int nand_add_partition(struct mtd_info *master, struct nand_part *part) ++{ ++ struct nand_chip *chip = master->priv; ++ struct mtd_info *mtd = &part->mtd; ++ struct nand_ecc_ctrl *ecc = part->ecc; ++ struct nand_part *pos; ++ bool inserted = false; ++ int ret; ++ ++ /* set up the MTD object for this partition */ ++ mtd->type = master->type; ++ mtd->flags = master->flags & ~mtd->flags; ++ mtd->writesize = master->writesize; ++ mtd->writebufsize = master->writebufsize; ++ mtd->oobsize = master->oobsize; ++ mtd->oobavail = master->oobavail; ++ mtd->subpage_sft = master->subpage_sft; ++ mtd->erasesize = master->erasesize; ++ ++ mtd->priv = chip; ++ mtd->owner = master->owner; ++ mtd->backing_dev_info = master->backing_dev_info; ++ ++ mtd->dev.parent = master->dev.parent; ++ ++ if (ecc) { ++ ret = nand_ecc_ctrl_init(mtd, ecc); ++ if (ret) ++ return ret; ++ } else { ++ ecc = &chip->ecc; ++ } ++ ++ mtd->_erase = nand_part_erase; ++ mtd->_point = NULL; ++ mtd->_unpoint = NULL; ++ mtd->_read = nand_part_read; ++ mtd->_write = nand_part_write; ++ mtd->_panic_write = panic_nand_part_write; ++ mtd->_read_oob = nand_part_read_oob; ++ mtd->_write_oob = nand_part_write_oob; ++ mtd->_sync = nand_sync; ++ mtd->_lock = NULL; ++ mtd->_unlock = NULL; ++ mtd->_suspend = nand_suspend; ++ mtd->_resume = nand_resume; ++ mtd->_block_isbad = nand_part_block_isbad; ++ mtd->_block_markbad = nand_part_block_markbad; ++ ++ /* propagate ecc info to mtd_info */ ++ mtd->ecclayout = ecc->layout; ++ mtd->ecc_strength = ecc->strength; ++ mtd->ecc_step_size = ecc->size; ++ /* ++ * Initialize bitflip_threshold to its default prior scan_bbt() call. ++ * scan_bbt() might invoke mtd_read(), thus bitflip_threshold must be ++ * properly set. ++ */ ++ if (!mtd->bitflip_threshold) ++ mtd->bitflip_threshold = mtd->ecc_strength; ++ ++ part->master = master; ++ ++ mutex_lock(&chip->part_lock); ++ list_for_each_entry(pos, &chip->partitions, node) { ++ if (part->offset >= pos->offset + pos->mtd.size) { ++ continue; ++ } else if (part->offset + mtd->size > pos->offset) { ++ ret = -EINVAL; ++ goto out; ++ } ++ ++ list_add(&part->node, pos->node.prev); ++ inserted = true; ++ break; ++ } ++ ++ if (!inserted) ++ list_add_tail(&part->node, &chip->partitions); ++ ++ ret = mtd_device_register(mtd, NULL, 0); ++ if (ret) { ++ list_del(&part->node); ++ goto out; ++ } ++ ++ if (master->_block_isbad) { ++ uint64_t offs = 0; ++ ++ while (offs < mtd->size) { ++ if (mtd_block_isreserved(master, offs + part->offset)) ++ mtd->ecc_stats.bbtblocks++; ++ else if (mtd_block_isbad(master, offs + part->offset)) ++ mtd->ecc_stats.badblocks++; ++ offs += mtd->erasesize; ++ } ++ } ++ ++out: ++ mutex_unlock(&chip->part_lock); ++ return ret; ++} ++EXPORT_SYMBOL(nand_add_partition); ++ ++/** ++ * nand_del_partition - [NAND Interface] Delete a NAND part from a NAND dev ++ * @part: NAND partition to delete ++ * ++ * Deletes a NAND partition from a NAND device. ++ */ ++void nand_del_partition(struct nand_part *part) ++{ ++ struct nand_chip *chip = part->mtd.priv; ++ ++ mutex_lock(&chip->part_lock); ++ mtd_device_unregister(&part->mtd); ++ list_del(&part->node); ++ mutex_unlock(&chip->part_lock); ++ ++ if (part->ecc && part->ecc->mode == NAND_ECC_SOFT_BCH) ++ nand_bch_free((struct nand_bch_control *)part->ecc->priv); ++ ++ if (part->release) ++ part->release(part); ++} ++EXPORT_SYMBOL(nand_del_partition); ++ ++/* ++ * NAND part release function. Used by nandpart_alloc as its release function. ++ */ ++static void nandpart_release(struct nand_part *part) ++{ ++ kfree(part); ++} ++ ++/** ++ * nandpart_alloc - [NAND Interface] Allocate a NAND part struct ++ * ++ * Allocate a NAND partition and assign the nandpart release function. ++ * This nand_part struct must be filled before passing it to the ++ * nand_add_partition function. ++ */ ++struct nand_part *nandpart_alloc(void) ++{ ++ struct nand_part *part = kzalloc(sizeof(*part), GFP_KERNEL); ++ if (!part) ++ return ERR_PTR(-ENOMEM); ++ part->release = nandpart_release; ++ ++ return part; ++} ++EXPORT_SYMBOL(nandpart_alloc); ++ ++/** + * nand_scan_tail - [NAND Interface] Scan for the NAND device + * @mtd: MTD device structure + * +@@ -4146,6 +4591,11 @@ int nand_scan_tail(struct mtd_info *mtd) + return ret; + } + ++ INIT_LIST_HEAD(&chip->partitions); ++ mutex_init(&chip->part_lock); ++ ++ chip->cur_ecc = &chip->ecc; ++ + /* Allow subpage writes up to ecc.steps. Not possible for MLC flash */ + if (!(chip->options & NAND_NO_SUBPAGE_WRITE) && nand_is_slc(chip)) { + switch (ecc->steps) { +diff --git a/drivers/mtd/nand/nand_bch.c b/drivers/mtd/nand/nand_bch.c +index 3803e0b..b82b976 100644 +--- a/drivers/mtd/nand/nand_bch.c ++++ b/drivers/mtd/nand/nand_bch.c +@@ -53,14 +53,14 @@ int nand_bch_calculate_ecc(struct mtd_info *mtd, const unsigned char *buf, + unsigned char *code) + { + const struct nand_chip *chip = mtd->priv; +- struct nand_bch_control *nbc = chip->ecc.priv; ++ struct nand_bch_control *nbc = chip->cur_ecc->priv; + unsigned int i; + +- memset(code, 0, chip->ecc.bytes); +- encode_bch(nbc->bch, buf, chip->ecc.size, code); ++ memset(code, 0, chip->cur_ecc->bytes); ++ encode_bch(nbc->bch, buf, chip->cur_ecc->size, code); + + /* apply mask so that an erased page is a valid codeword */ +- for (i = 0; i < chip->ecc.bytes; i++) ++ for (i = 0; i < chip->cur_ecc->bytes; i++) + code[i] ^= nbc->eccmask[i]; + + return 0; +@@ -80,15 +80,15 @@ int nand_bch_correct_data(struct mtd_info *mtd, unsigned char *buf, + unsigned char *read_ecc, unsigned char *calc_ecc) + { + const struct nand_chip *chip = mtd->priv; +- struct nand_bch_control *nbc = chip->ecc.priv; ++ struct nand_bch_control *nbc = chip->cur_ecc->priv; + unsigned int *errloc = nbc->errloc; + int i, count; + +- count = decode_bch(nbc->bch, NULL, chip->ecc.size, read_ecc, calc_ecc, +- NULL, errloc); ++ count = decode_bch(nbc->bch, NULL, chip->cur_ecc->size, read_ecc, ++ calc_ecc, NULL, errloc); + if (count > 0) { + for (i = 0; i < count; i++) { +- if (errloc[i] < (chip->ecc.size*8)) ++ if (errloc[i] < (chip->cur_ecc->size*8)) + /* error is located in data, correct it */ + buf[errloc[i] >> 3] ^= (1 << (errloc[i] & 7)); + /* else error in ecc, no action needed */ +diff --git a/drivers/mtd/nand/nand_ecc.c b/drivers/mtd/nand/nand_ecc.c +index 97c4c02..f35c418 100644 +--- a/drivers/mtd/nand/nand_ecc.c ++++ b/drivers/mtd/nand/nand_ecc.c +@@ -424,7 +424,7 @@ int nand_calculate_ecc(struct mtd_info *mtd, const unsigned char *buf, + unsigned char *code) + { + __nand_calculate_ecc(buf, +- ((struct nand_chip *)mtd->priv)->ecc.size, code); ++ ((struct nand_chip *)mtd->priv)->cur_ecc->size, code); + + return 0; + } +@@ -524,7 +524,7 @@ int nand_correct_data(struct mtd_info *mtd, unsigned char *buf, + unsigned char *read_ecc, unsigned char *calc_ecc) + { + return __nand_correct_data(buf, read_ecc, calc_ecc, +- ((struct nand_chip *)mtd->priv)->ecc.size); ++ ((struct nand_chip *)mtd->priv)->cur_ecc->size); + } + EXPORT_SYMBOL(nand_correct_data); + +diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h +index 3d4ea7e..510e09b 100644 +--- a/include/linux/mtd/nand.h ++++ b/include/linux/mtd/nand.h +@@ -708,6 +708,7 @@ struct nand_chip { + struct nand_hw_control *controller; + + struct nand_ecc_ctrl ecc; ++ struct nand_ecc_ctrl *cur_ecc; + struct nand_buffers *buffers; + struct nand_hw_control hwcontrol; + +@@ -717,9 +718,46 @@ struct nand_chip { + + struct nand_bbt_descr *badblock_pattern; + ++ struct list_head partitions; ++ struct mutex part_lock; ++ + void *priv; + }; + ++/** ++ * struct nand_part - NAND partition structure ++ * @node: list node used to attach the partition to its NAND dev ++ * @mtd: MTD partiton info ++ * @master: MTD device representing the NAND chip ++ * @offset: partition offset ++ * @ecc: partition specific ECC struct ++ * @release: function used to release this nand_part struct ++ * ++ * NAND partitions work as standard MTD partitions except it can override ++ * NAND chip ECC handling. ++ * This is particularly useful for SoCs that need specific ECC configs to boot ++ * from NAND while these ECC configs do not fit the NAND chip ECC requirements. ++ */ ++struct nand_part { ++ struct list_head node; ++ struct mtd_info mtd; ++ struct mtd_info *master; ++ uint64_t offset; ++ struct nand_ecc_ctrl *ecc; ++ void (*release)(struct nand_part *part); ++}; ++ ++static inline struct nand_part *to_nand_part(struct mtd_info *mtd) ++{ ++ return container_of(mtd, struct nand_part, mtd); ++} ++ ++int nand_add_partition(struct mtd_info *master, struct nand_part *part); ++ ++void nand_del_partition(struct nand_part *part); ++ ++struct nand_part *nandpart_alloc(void); ++ + /* + * NAND Flash Manufacturer ID Codes + */ -- cgit v1.2.3