sunxi: add support for 4.1
[openwrt/openwrt.git] / target / linux / sunxi / patches-4.1 / 111-mtd-add-support-for-nand-partitions.patch
1 From a95cc309cf74eed3fc457dec3dcc44d9bf79e0e6 Mon Sep 17 00:00:00 2001
2 From: Boris BREZILLON <boris.brezillon@free-electrons.com>
3 Date: Mon, 28 Jul 2014 15:01:15 +0200
4 Subject: [PATCH] mtd: nand: Add support for NAND partitions
5
6 Add support for NAND partitions, and indirectly for per partition ECC
7 config, and also per partiton random seed support for the upcoming
8 randomizer support.
9
10 This is necessary to be able to use different ECC / randomizer settings for
11 the parts of the NAND which are read directly by a bootrom (which has a
12 fixed ECC / random seed setting) and the generic data part of the NAND for
13 which we often want a stronger ECC and / or random seed.
14
15 Provide helper functions to add/delete/allocate nand partitions.
16 NAND core code now make use of the partition specific nand_ecc_ctrl struct
17 (if available) when doing read/write operations.
18
19 Signed-off-by: Boris BREZILLON <boris.brezillon@free-electrons.com>
20 Signed-off-by: Hans de Goede <hdegoede@redhat.com>
21 ---
22 drivers/mtd/nand/Kconfig | 4 +
23 drivers/mtd/nand/Makefile | 2 +
24 drivers/mtd/nand/nand_base.c | 712 +++++++++++++++++++++++++++++++++++--------
25 drivers/mtd/nand/nand_bch.c | 16 +-
26 drivers/mtd/nand/nand_ecc.c | 4 +-
27 include/linux/mtd/nand.h | 38 +++
28 6 files changed, 635 insertions(+), 141 deletions(-)
29
30 diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
31 index 5897d8d..8242470 100644
32 --- a/drivers/mtd/nand/Kconfig
33 +++ b/drivers/mtd/nand/Kconfig
34 @@ -22,6 +22,10 @@ menuconfig MTD_NAND
35
36 if MTD_NAND
37
38 +config MTD_OF_NAND_PARTS
39 + tristate
40 + default n
41 +
42 config MTD_NAND_BCH
43 tristate
44 select BCH
45 diff --git a/drivers/mtd/nand/Makefile b/drivers/mtd/nand/Makefile
46 index 582bbd05..fcbe032 100644
47 --- a/drivers/mtd/nand/Makefile
48 +++ b/drivers/mtd/nand/Makefile
49 @@ -53,4 +53,6 @@ obj-$(CONFIG_MTD_NAND_BCM47XXNFLASH) += bcm47xxnflash/
50 obj-$(CONFIG_MTD_NAND_SUNXI) += sunxi_nand.o
51 obj-$(CONFIG_MTD_NAND_HISI504) += hisi504_nand.o
52
53 +obj-$(CONFIG_MTD_OF_NAND_PARTS) += ofnandpart.o
54 +
55 nand-objs := nand_base.o nand_bbt.o nand_timings.o
56 diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
57 index f580ed1..a30b67f 100644
58 --- a/drivers/mtd/nand/nand_base.c
59 +++ b/drivers/mtd/nand/nand_base.c
60 @@ -1134,26 +1134,26 @@ static int nand_read_page_raw_syndrome(struct mtd_info *mtd,
61 struct nand_chip *chip, uint8_t *buf,
62 int oob_required, int page)
63 {
64 - int eccsize = chip->ecc.size;
65 - int eccbytes = chip->ecc.bytes;
66 + int eccsize = chip->cur_ecc->size;
67 + int eccbytes = chip->cur_ecc->bytes;
68 uint8_t *oob = chip->oob_poi;
69 int steps, size;
70
71 - for (steps = chip->ecc.steps; steps > 0; steps--) {
72 + for (steps = chip->cur_ecc->steps; steps > 0; steps--) {
73 chip->read_buf(mtd, buf, eccsize);
74 buf += eccsize;
75
76 - if (chip->ecc.prepad) {
77 - chip->read_buf(mtd, oob, chip->ecc.prepad);
78 - oob += chip->ecc.prepad;
79 + if (chip->cur_ecc->prepad) {
80 + chip->read_buf(mtd, oob, chip->cur_ecc->prepad);
81 + oob += chip->cur_ecc->prepad;
82 }
83
84 chip->read_buf(mtd, oob, eccbytes);
85 oob += eccbytes;
86
87 - if (chip->ecc.postpad) {
88 - chip->read_buf(mtd, oob, chip->ecc.postpad);
89 - oob += chip->ecc.postpad;
90 + if (chip->cur_ecc->postpad) {
91 + chip->read_buf(mtd, oob, chip->cur_ecc->postpad);
92 + oob += chip->cur_ecc->postpad;
93 }
94 }
95
96 @@ -1175,30 +1175,31 @@ static int nand_read_page_raw_syndrome(struct mtd_info *mtd,
97 static int nand_read_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
98 uint8_t *buf, int oob_required, int page)
99 {
100 - int i, eccsize = chip->ecc.size;
101 - int eccbytes = chip->ecc.bytes;
102 - int eccsteps = chip->ecc.steps;
103 + int i, eccsize = chip->cur_ecc->size;
104 + int eccbytes = chip->cur_ecc->bytes;
105 + int eccsteps = chip->cur_ecc->steps;
106 uint8_t *p = buf;
107 uint8_t *ecc_calc = chip->buffers->ecccalc;
108 uint8_t *ecc_code = chip->buffers->ecccode;
109 - uint32_t *eccpos = chip->ecc.layout->eccpos;
110 + uint32_t *eccpos = chip->cur_ecc->layout->eccpos;
111 unsigned int max_bitflips = 0;
112
113 - chip->ecc.read_page_raw(mtd, chip, buf, 1, page);
114 + chip->cur_ecc->read_page_raw(mtd, chip, buf, 1, page);
115
116 for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
117 - chip->ecc.calculate(mtd, p, &ecc_calc[i]);
118 + chip->cur_ecc->calculate(mtd, p, &ecc_calc[i]);
119
120 - for (i = 0; i < chip->ecc.total; i++)
121 + for (i = 0; i < chip->cur_ecc->total; i++)
122 ecc_code[i] = chip->oob_poi[eccpos[i]];
123
124 - eccsteps = chip->ecc.steps;
125 + eccsteps = chip->cur_ecc->steps;
126 p = buf;
127
128 for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
129 int stat;
130
131 - stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);
132 + stat = chip->cur_ecc->correct(mtd, p, &ecc_code[i],
133 + &ecc_calc[i]);
134 if (stat < 0) {
135 mtd->ecc_stats.failed++;
136 } else {
137 @@ -1223,7 +1224,7 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
138 int page)
139 {
140 int start_step, end_step, num_steps;
141 - uint32_t *eccpos = chip->ecc.layout->eccpos;
142 + uint32_t *eccpos = chip->cur_ecc->layout->eccpos;
143 uint8_t *p;
144 int data_col_addr, i, gaps = 0;
145 int datafrag_len, eccfrag_len, aligned_len, aligned_pos;
146 @@ -1232,16 +1233,16 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
147 unsigned int max_bitflips = 0;
148
149 /* Column address within the page aligned to ECC size (256bytes) */
150 - start_step = data_offs / chip->ecc.size;
151 - end_step = (data_offs + readlen - 1) / chip->ecc.size;
152 + start_step = data_offs / chip->cur_ecc->size;
153 + end_step = (data_offs + readlen - 1) / chip->cur_ecc->size;
154 num_steps = end_step - start_step + 1;
155 - index = start_step * chip->ecc.bytes;
156 + index = start_step * chip->cur_ecc->bytes;
157
158 /* Data size aligned to ECC ecc.size */
159 - datafrag_len = num_steps * chip->ecc.size;
160 - eccfrag_len = num_steps * chip->ecc.bytes;
161 + datafrag_len = num_steps * chip->cur_ecc->size;
162 + eccfrag_len = num_steps * chip->cur_ecc->bytes;
163
164 - data_col_addr = start_step * chip->ecc.size;
165 + data_col_addr = start_step * chip->cur_ecc->size;
166 /* If we read not a page aligned data */
167 if (data_col_addr != 0)
168 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, data_col_addr, -1);
169 @@ -1250,8 +1251,9 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
170 chip->read_buf(mtd, p, datafrag_len);
171
172 /* Calculate ECC */
173 - for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size)
174 - chip->ecc.calculate(mtd, p, &chip->buffers->ecccalc[i]);
175 + for (i = 0; i < eccfrag_len;
176 + i += chip->cur_ecc->bytes, p += chip->cur_ecc->size)
177 + chip->cur_ecc->calculate(mtd, p, &chip->buffers->ecccalc[i]);
178
179 /*
180 * The performance is faster if we position offsets according to
181 @@ -1275,7 +1277,8 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
182 aligned_len = eccfrag_len;
183 if (eccpos[index] & (busw - 1))
184 aligned_len++;
185 - if (eccpos[index + (num_steps * chip->ecc.bytes)] & (busw - 1))
186 + if (eccpos[index + (num_steps * chip->cur_ecc->bytes)] &
187 + (busw - 1))
188 aligned_len++;
189
190 chip->cmdfunc(mtd, NAND_CMD_RNDOUT,
191 @@ -1287,11 +1290,13 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
192 chip->buffers->ecccode[i] = chip->oob_poi[eccpos[i + index]];
193
194 p = bufpoi + data_col_addr;
195 - for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) {
196 + for (i = 0; i < eccfrag_len;
197 + i += chip->cur_ecc->bytes, p += chip->cur_ecc->size) {
198 int stat;
199
200 - stat = chip->ecc.correct(mtd, p,
201 - &chip->buffers->ecccode[i], &chip->buffers->ecccalc[i]);
202 + stat = chip->cur_ecc->correct(mtd, p,
203 + &chip->buffers->ecccode[i],
204 + &chip->buffers->ecccalc[i]);
205 if (stat < 0) {
206 mtd->ecc_stats.failed++;
207 } else {
208 @@ -1315,32 +1320,33 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
209 static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
210 uint8_t *buf, int oob_required, int page)
211 {
212 - int i, eccsize = chip->ecc.size;
213 - int eccbytes = chip->ecc.bytes;
214 - int eccsteps = chip->ecc.steps;
215 + int i, eccsize = chip->cur_ecc->size;
216 + int eccbytes = chip->cur_ecc->bytes;
217 + int eccsteps = chip->cur_ecc->steps;
218 uint8_t *p = buf;
219 uint8_t *ecc_calc = chip->buffers->ecccalc;
220 uint8_t *ecc_code = chip->buffers->ecccode;
221 - uint32_t *eccpos = chip->ecc.layout->eccpos;
222 + uint32_t *eccpos = chip->cur_ecc->layout->eccpos;
223 unsigned int max_bitflips = 0;
224
225 for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
226 - chip->ecc.hwctl(mtd, NAND_ECC_READ);
227 + chip->cur_ecc->hwctl(mtd, NAND_ECC_READ);
228 chip->read_buf(mtd, p, eccsize);
229 - chip->ecc.calculate(mtd, p, &ecc_calc[i]);
230 + chip->cur_ecc->calculate(mtd, p, &ecc_calc[i]);
231 }
232 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
233
234 - for (i = 0; i < chip->ecc.total; i++)
235 + for (i = 0; i < chip->cur_ecc->total; i++)
236 ecc_code[i] = chip->oob_poi[eccpos[i]];
237
238 - eccsteps = chip->ecc.steps;
239 + eccsteps = chip->cur_ecc->steps;
240 p = buf;
241
242 for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
243 int stat;
244
245 - stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);
246 + stat = chip->cur_ecc->correct(mtd, p, &ecc_code[i],
247 + &ecc_calc[i]);
248 if (stat < 0) {
249 mtd->ecc_stats.failed++;
250 } else {
251 @@ -1368,12 +1374,12 @@ static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
252 static int nand_read_page_hwecc_oob_first(struct mtd_info *mtd,
253 struct nand_chip *chip, uint8_t *buf, int oob_required, int page)
254 {
255 - int i, eccsize = chip->ecc.size;
256 - int eccbytes = chip->ecc.bytes;
257 - int eccsteps = chip->ecc.steps;
258 + int i, eccsize = chip->cur_ecc->size;
259 + int eccbytes = chip->cur_ecc->bytes;
260 + int eccsteps = chip->cur_ecc->steps;
261 uint8_t *p = buf;
262 uint8_t *ecc_code = chip->buffers->ecccode;
263 - uint32_t *eccpos = chip->ecc.layout->eccpos;
264 + uint32_t *eccpos = chip->cur_ecc->layout->eccpos;
265 uint8_t *ecc_calc = chip->buffers->ecccalc;
266 unsigned int max_bitflips = 0;
267
268 @@ -1382,17 +1388,17 @@ static int nand_read_page_hwecc_oob_first(struct mtd_info *mtd,
269 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
270 chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
271
272 - for (i = 0; i < chip->ecc.total; i++)
273 + for (i = 0; i < chip->cur_ecc->total; i++)
274 ecc_code[i] = chip->oob_poi[eccpos[i]];
275
276 for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
277 int stat;
278
279 - chip->ecc.hwctl(mtd, NAND_ECC_READ);
280 + chip->cur_ecc->hwctl(mtd, NAND_ECC_READ);
281 chip->read_buf(mtd, p, eccsize);
282 - chip->ecc.calculate(mtd, p, &ecc_calc[i]);
283 + chip->cur_ecc->calculate(mtd, p, &ecc_calc[i]);
284
285 - stat = chip->ecc.correct(mtd, p, &ecc_code[i], NULL);
286 + stat = chip->cur_ecc->correct(mtd, p, &ecc_code[i], NULL);
287 if (stat < 0) {
288 mtd->ecc_stats.failed++;
289 } else {
290 @@ -1417,9 +1423,9 @@ static int nand_read_page_hwecc_oob_first(struct mtd_info *mtd,
291 static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
292 uint8_t *buf, int oob_required, int page)
293 {
294 - int i, eccsize = chip->ecc.size;
295 - int eccbytes = chip->ecc.bytes;
296 - int eccsteps = chip->ecc.steps;
297 + int i, eccsize = chip->cur_ecc->size;
298 + int eccbytes = chip->cur_ecc->bytes;
299 + int eccsteps = chip->cur_ecc->steps;
300 uint8_t *p = buf;
301 uint8_t *oob = chip->oob_poi;
302 unsigned int max_bitflips = 0;
303 @@ -1427,17 +1433,17 @@ static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
304 for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
305 int stat;
306
307 - chip->ecc.hwctl(mtd, NAND_ECC_READ);
308 + chip->cur_ecc->hwctl(mtd, NAND_ECC_READ);
309 chip->read_buf(mtd, p, eccsize);
310
311 - if (chip->ecc.prepad) {
312 - chip->read_buf(mtd, oob, chip->ecc.prepad);
313 - oob += chip->ecc.prepad;
314 + if (chip->cur_ecc->prepad) {
315 + chip->read_buf(mtd, oob, chip->cur_ecc->prepad);
316 + oob += chip->cur_ecc->prepad;
317 }
318
319 - chip->ecc.hwctl(mtd, NAND_ECC_READSYN);
320 + chip->cur_ecc->hwctl(mtd, NAND_ECC_READSYN);
321 chip->read_buf(mtd, oob, eccbytes);
322 - stat = chip->ecc.correct(mtd, p, oob, NULL);
323 + stat = chip->cur_ecc->correct(mtd, p, oob, NULL);
324
325 if (stat < 0) {
326 mtd->ecc_stats.failed++;
327 @@ -1448,9 +1454,9 @@ static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
328
329 oob += eccbytes;
330
331 - if (chip->ecc.postpad) {
332 - chip->read_buf(mtd, oob, chip->ecc.postpad);
333 - oob += chip->ecc.postpad;
334 + if (chip->cur_ecc->postpad) {
335 + chip->read_buf(mtd, oob, chip->cur_ecc->postpad);
336 + oob += chip->cur_ecc->postpad;
337 }
338 }
339
340 @@ -1480,7 +1486,7 @@ static uint8_t *nand_transfer_oob(struct nand_chip *chip, uint8_t *oob,
341 return oob + len;
342
343 case MTD_OPS_AUTO_OOB: {
344 - struct nand_oobfree *free = chip->ecc.layout->oobfree;
345 + struct nand_oobfree *free = chip->cur_ecc->layout->oobfree;
346 uint32_t boffs = 0, roffs = ops->ooboffs;
347 size_t bytes = 0;
348
349 @@ -1600,17 +1606,21 @@ static int nand_do_read_ops(struct mtd_info *mtd, loff_t from,
350 * the read methods return max bitflips per ecc step.
351 */
352 if (unlikely(ops->mode == MTD_OPS_RAW))
353 - ret = chip->ecc.read_page_raw(mtd, chip, bufpoi,
354 - oob_required,
355 - page);
356 + ret = chip->cur_ecc->read_page_raw(mtd, chip,
357 + bufpoi,
358 + oob_required,
359 + page);
360 else if (!aligned && NAND_HAS_SUBPAGE_READ(chip) &&
361 !oob)
362 - ret = chip->ecc.read_subpage(mtd, chip,
363 - col, bytes, bufpoi,
364 - page);
365 + ret = chip->cur_ecc->read_subpage(mtd, chip,
366 + col, bytes,
367 + bufpoi,
368 + page);
369 else
370 - ret = chip->ecc.read_page(mtd, chip, bufpoi,
371 - oob_required, page);
372 + ret = chip->cur_ecc->read_page(mtd, chip,
373 + bufpoi,
374 + oob_required,
375 + page);
376 if (ret < 0) {
377 if (use_bufpoi)
378 /* Invalidate page cache */
379 @@ -1746,6 +1756,39 @@ static int nand_read(struct mtd_info *mtd, loff_t from, size_t len,
380 }
381
382 /**
383 + * nand_part_read - [MTD Interface] MTD compatibility function for nand_do_read_ecc
384 + * @mtd: MTD device structure
385 + * @from: offset to read from
386 + * @len: number of bytes to read
387 + * @retlen: pointer to variable to store the number of read bytes
388 + * @buf: the databuffer to put data
389 + *
390 + * Get hold of the chip and call nand_do_read.
391 + */
392 +static int nand_part_read(struct mtd_info *mtd, loff_t from, size_t len,
393 + size_t *retlen, uint8_t *buf)
394 +{
395 + struct nand_chip *chip = mtd->priv;
396 + struct nand_part *part = to_nand_part(mtd);
397 + struct mtd_oob_ops ops;
398 + int ret;
399 +
400 + from += part->offset;
401 + nand_get_device(part->master, FL_READING);
402 + if (part->ecc)
403 + chip->cur_ecc = part->ecc;
404 + ops.len = len;
405 + ops.datbuf = buf;
406 + ops.oobbuf = NULL;
407 + ops.mode = MTD_OPS_PLACE_OOB;
408 + ret = nand_do_read_ops(part->master, from, &ops);
409 + *retlen = ops.retlen;
410 + chip->cur_ecc = &chip->ecc;
411 + nand_release_device(part->master);
412 + return ret;
413 +}
414 +
415 +/**
416 * nand_read_oob_std - [REPLACEABLE] the most common OOB data read function
417 * @mtd: mtd info structure
418 * @chip: nand chip info structure
419 @@ -1770,13 +1813,14 @@ static int nand_read_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
420 int page)
421 {
422 int length = mtd->oobsize;
423 - int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
424 - int eccsize = chip->ecc.size;
425 + int chunk = chip->cur_ecc->bytes + chip->cur_ecc->prepad +
426 + chip->cur_ecc->postpad;
427 + int eccsize = chip->cur_ecc->size;
428 uint8_t *bufpoi = chip->oob_poi;
429 int i, toread, sndrnd = 0, pos;
430
431 - chip->cmdfunc(mtd, NAND_CMD_READ0, chip->ecc.size, page);
432 - for (i = 0; i < chip->ecc.steps; i++) {
433 + chip->cmdfunc(mtd, NAND_CMD_READ0, chip->cur_ecc->size, page);
434 + for (i = 0; i < chip->cur_ecc->steps; i++) {
435 if (sndrnd) {
436 pos = eccsize + i * (eccsize + chunk);
437 if (mtd->writesize > 512)
438 @@ -1829,9 +1873,10 @@ static int nand_write_oob_std(struct mtd_info *mtd, struct nand_chip *chip,
439 static int nand_write_oob_syndrome(struct mtd_info *mtd,
440 struct nand_chip *chip, int page)
441 {
442 - int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
443 - int eccsize = chip->ecc.size, length = mtd->oobsize;
444 - int i, len, pos, status = 0, sndcmd = 0, steps = chip->ecc.steps;
445 + int chunk = chip->cur_ecc->bytes + chip->cur_ecc->prepad +
446 + chip->cur_ecc->postpad;
447 + int eccsize = chip->cur_ecc->size, length = mtd->oobsize;
448 + int i, len, pos, status = 0, sndcmd = 0, steps = chip->cur_ecc->steps;
449 const uint8_t *bufpoi = chip->oob_poi;
450
451 /*
452 @@ -1839,7 +1884,7 @@ static int nand_write_oob_syndrome(struct mtd_info *mtd,
453 * or
454 * data-pad-ecc-pad-data-pad .... ecc-pad-oob
455 */
456 - if (!chip->ecc.prepad && !chip->ecc.postpad) {
457 + if (!chip->cur_ecc->prepad && !chip->cur_ecc->postpad) {
458 pos = steps * (eccsize + chunk);
459 steps = 0;
460 } else
461 @@ -1903,7 +1948,7 @@ static int nand_do_read_oob(struct mtd_info *mtd, loff_t from,
462 stats = mtd->ecc_stats;
463
464 if (ops->mode == MTD_OPS_AUTO_OOB)
465 - len = chip->ecc.layout->oobavail;
466 + len = chip->cur_ecc->layout->oobavail;
467 else
468 len = mtd->oobsize;
469
470 @@ -1931,9 +1976,9 @@ static int nand_do_read_oob(struct mtd_info *mtd, loff_t from,
471
472 while (1) {
473 if (ops->mode == MTD_OPS_RAW)
474 - ret = chip->ecc.read_oob_raw(mtd, chip, page);
475 + ret = chip->cur_ecc->read_oob_raw(mtd, chip, page);
476 else
477 - ret = chip->ecc.read_oob(mtd, chip, page);
478 + ret = chip->cur_ecc->read_oob(mtd, chip, page);
479
480 if (ret < 0)
481 break;
482 @@ -2021,6 +2066,56 @@ static int nand_read_oob(struct mtd_info *mtd, loff_t from,
483 return ret;
484 }
485
486 +/**
487 + * nand_part_read_oob - [MTD Interface] NAND read data and/or out-of-band
488 + * @mtd: MTD device structure
489 + * @from: offset to read from
490 + * @ops: oob operation description structure
491 + *
492 + * NAND read data and/or out-of-band data.
493 + */
494 +static int nand_part_read_oob(struct mtd_info *mtd, loff_t from,
495 + struct mtd_oob_ops *ops)
496 +{
497 + struct nand_chip *chip = mtd->priv;
498 + struct nand_part *part = to_nand_part(mtd);
499 + int ret = -ENOTSUPP;
500 +
501 + ops->retlen = 0;
502 +
503 + /* Do not allow reads past end of device */
504 + if (ops->datbuf && (from + ops->len) > mtd->size) {
505 + pr_debug("%s: attempt to read beyond end of device\n",
506 + __func__);
507 + return -EINVAL;
508 + }
509 +
510 + from += part->offset;
511 + nand_get_device(part->master, FL_READING);
512 + if (part->ecc)
513 + chip->cur_ecc = part->ecc;
514 +
515 + switch (ops->mode) {
516 + case MTD_OPS_PLACE_OOB:
517 + case MTD_OPS_AUTO_OOB:
518 + case MTD_OPS_RAW:
519 + break;
520 +
521 + default:
522 + goto out;
523 + }
524 +
525 + if (!ops->datbuf)
526 + ret = nand_do_read_oob(part->master, from, ops);
527 + else
528 + ret = nand_do_read_ops(part->master, from, ops);
529 +
530 +out:
531 + chip->cur_ecc = &chip->ecc;
532 + nand_release_device(part->master);
533 + return ret;
534 +}
535 +
536
537 /**
538 * nand_write_page_raw - [INTERN] raw page write function
539 @@ -2054,26 +2149,26 @@ static int nand_write_page_raw_syndrome(struct mtd_info *mtd,
540 struct nand_chip *chip,
541 const uint8_t *buf, int oob_required)
542 {
543 - int eccsize = chip->ecc.size;
544 - int eccbytes = chip->ecc.bytes;
545 + int eccsize = chip->cur_ecc->size;
546 + int eccbytes = chip->cur_ecc->bytes;
547 uint8_t *oob = chip->oob_poi;
548 int steps, size;
549
550 - for (steps = chip->ecc.steps; steps > 0; steps--) {
551 + for (steps = chip->cur_ecc->steps; steps > 0; steps--) {
552 chip->write_buf(mtd, buf, eccsize);
553 buf += eccsize;
554
555 - if (chip->ecc.prepad) {
556 - chip->write_buf(mtd, oob, chip->ecc.prepad);
557 - oob += chip->ecc.prepad;
558 + if (chip->cur_ecc->prepad) {
559 + chip->write_buf(mtd, oob, chip->cur_ecc->prepad);
560 + oob += chip->cur_ecc->prepad;
561 }
562
563 chip->write_buf(mtd, oob, eccbytes);
564 oob += eccbytes;
565
566 - if (chip->ecc.postpad) {
567 - chip->write_buf(mtd, oob, chip->ecc.postpad);
568 - oob += chip->ecc.postpad;
569 + if (chip->cur_ecc->postpad) {
570 + chip->write_buf(mtd, oob, chip->cur_ecc->postpad);
571 + oob += chip->cur_ecc->postpad;
572 }
573 }
574
575 @@ -2093,21 +2188,21 @@ static int nand_write_page_raw_syndrome(struct mtd_info *mtd,
576 static int nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
577 const uint8_t *buf, int oob_required)
578 {
579 - int i, eccsize = chip->ecc.size;
580 - int eccbytes = chip->ecc.bytes;
581 - int eccsteps = chip->ecc.steps;
582 + int i, eccsize = chip->cur_ecc->size;
583 + int eccbytes = chip->cur_ecc->bytes;
584 + int eccsteps = chip->cur_ecc->steps;
585 uint8_t *ecc_calc = chip->buffers->ecccalc;
586 const uint8_t *p = buf;
587 - uint32_t *eccpos = chip->ecc.layout->eccpos;
588 + uint32_t *eccpos = chip->cur_ecc->layout->eccpos;
589
590 /* Software ECC calculation */
591 for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
592 - chip->ecc.calculate(mtd, p, &ecc_calc[i]);
593 + chip->cur_ecc->calculate(mtd, p, &ecc_calc[i]);
594
595 - for (i = 0; i < chip->ecc.total; i++)
596 + for (i = 0; i < chip->cur_ecc->total; i++)
597 chip->oob_poi[eccpos[i]] = ecc_calc[i];
598
599 - return chip->ecc.write_page_raw(mtd, chip, buf, 1);
600 + return chip->cur_ecc->write_page_raw(mtd, chip, buf, 1);
601 }
602
603 /**
604 @@ -2120,20 +2215,20 @@ static int nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
605 static int nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
606 const uint8_t *buf, int oob_required)
607 {
608 - int i, eccsize = chip->ecc.size;
609 - int eccbytes = chip->ecc.bytes;
610 - int eccsteps = chip->ecc.steps;
611 + int i, eccsize = chip->cur_ecc->size;
612 + int eccbytes = chip->cur_ecc->bytes;
613 + int eccsteps = chip->cur_ecc->steps;
614 uint8_t *ecc_calc = chip->buffers->ecccalc;
615 const uint8_t *p = buf;
616 - uint32_t *eccpos = chip->ecc.layout->eccpos;
617 + uint32_t *eccpos = chip->cur_ecc->layout->eccpos;
618
619 for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
620 - chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
621 + chip->cur_ecc->hwctl(mtd, NAND_ECC_WRITE);
622 chip->write_buf(mtd, p, eccsize);
623 - chip->ecc.calculate(mtd, p, &ecc_calc[i]);
624 + chip->cur_ecc->calculate(mtd, p, &ecc_calc[i]);
625 }
626
627 - for (i = 0; i < chip->ecc.total; i++)
628 + for (i = 0; i < chip->cur_ecc->total; i++)
629 chip->oob_poi[eccpos[i]] = ecc_calc[i];
630
631 chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
632 @@ -2158,10 +2253,10 @@ static int nand_write_subpage_hwecc(struct mtd_info *mtd,
633 {
634 uint8_t *oob_buf = chip->oob_poi;
635 uint8_t *ecc_calc = chip->buffers->ecccalc;
636 - int ecc_size = chip->ecc.size;
637 - int ecc_bytes = chip->ecc.bytes;
638 - int ecc_steps = chip->ecc.steps;
639 - uint32_t *eccpos = chip->ecc.layout->eccpos;
640 + int ecc_size = chip->cur_ecc->size;
641 + int ecc_bytes = chip->cur_ecc->bytes;
642 + int ecc_steps = chip->cur_ecc->steps;
643 + uint32_t *eccpos = chip->cur_ecc->layout->eccpos;
644 uint32_t start_step = offset / ecc_size;
645 uint32_t end_step = (offset + data_len - 1) / ecc_size;
646 int oob_bytes = mtd->oobsize / ecc_steps;
647 @@ -2169,7 +2264,7 @@ static int nand_write_subpage_hwecc(struct mtd_info *mtd,
648
649 for (step = 0; step < ecc_steps; step++) {
650 /* configure controller for WRITE access */
651 - chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
652 + chip->cur_ecc->hwctl(mtd, NAND_ECC_WRITE);
653
654 /* write data (untouched subpages already masked by 0xFF) */
655 chip->write_buf(mtd, buf, ecc_size);
656 @@ -2178,7 +2273,7 @@ static int nand_write_subpage_hwecc(struct mtd_info *mtd,
657 if ((step < start_step) || (step > end_step))
658 memset(ecc_calc, 0xff, ecc_bytes);
659 else
660 - chip->ecc.calculate(mtd, buf, ecc_calc);
661 + chip->cur_ecc->calculate(mtd, buf, ecc_calc);
662
663 /* mask OOB of un-touched subpages by padding 0xFF */
664 /* if oob_required, preserve OOB metadata of written subpage */
665 @@ -2193,7 +2288,7 @@ static int nand_write_subpage_hwecc(struct mtd_info *mtd,
666 /* copy calculated ECC for whole page to chip->buffer->oob */
667 /* this include masked-value(0xFF) for unwritten subpages */
668 ecc_calc = chip->buffers->ecccalc;
669 - for (i = 0; i < chip->ecc.total; i++)
670 + for (i = 0; i < chip->cur_ecc->total; i++)
671 chip->oob_poi[eccpos[i]] = ecc_calc[i];
672
673 /* write OOB buffer to NAND device */
674 @@ -2217,29 +2312,29 @@ static int nand_write_page_syndrome(struct mtd_info *mtd,
675 struct nand_chip *chip,
676 const uint8_t *buf, int oob_required)
677 {
678 - int i, eccsize = chip->ecc.size;
679 - int eccbytes = chip->ecc.bytes;
680 - int eccsteps = chip->ecc.steps;
681 + int i, eccsize = chip->cur_ecc->size;
682 + int eccbytes = chip->cur_ecc->bytes;
683 + int eccsteps = chip->cur_ecc->steps;
684 const uint8_t *p = buf;
685 uint8_t *oob = chip->oob_poi;
686
687 for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
688
689 - chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
690 + chip->cur_ecc->hwctl(mtd, NAND_ECC_WRITE);
691 chip->write_buf(mtd, p, eccsize);
692
693 - if (chip->ecc.prepad) {
694 - chip->write_buf(mtd, oob, chip->ecc.prepad);
695 - oob += chip->ecc.prepad;
696 + if (chip->cur_ecc->prepad) {
697 + chip->write_buf(mtd, oob, chip->cur_ecc->prepad);
698 + oob += chip->cur_ecc->prepad;
699 }
700
701 - chip->ecc.calculate(mtd, p, oob);
702 + chip->cur_ecc->calculate(mtd, p, oob);
703 chip->write_buf(mtd, oob, eccbytes);
704 oob += eccbytes;
705
706 - if (chip->ecc.postpad) {
707 - chip->write_buf(mtd, oob, chip->ecc.postpad);
708 - oob += chip->ecc.postpad;
709 + if (chip->cur_ecc->postpad) {
710 + chip->write_buf(mtd, oob, chip->cur_ecc->postpad);
711 + oob += chip->cur_ecc->postpad;
712 }
713 }
714
715 @@ -2270,7 +2365,7 @@ static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
716 int status, subpage;
717
718 if (!(chip->options & NAND_NO_SUBPAGE_WRITE) &&
719 - chip->ecc.write_subpage)
720 + chip->cur_ecc->write_subpage)
721 subpage = offset || (data_len < mtd->writesize);
722 else
723 subpage = 0;
724 @@ -2278,13 +2373,15 @@ static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
725 chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
726
727 if (unlikely(raw))
728 - status = chip->ecc.write_page_raw(mtd, chip, buf,
729 - oob_required);
730 + status = chip->cur_ecc->write_page_raw(mtd, chip, buf,
731 + oob_required);
732 else if (subpage)
733 - status = chip->ecc.write_subpage(mtd, chip, offset, data_len,
734 - buf, oob_required);
735 + status = chip->cur_ecc->write_subpage(mtd, chip, offset,
736 + data_len, buf,
737 + oob_required);
738 else
739 - status = chip->ecc.write_page(mtd, chip, buf, oob_required);
740 + status = chip->cur_ecc->write_page(mtd, chip, buf,
741 + oob_required);
742
743 if (status < 0)
744 return status;
745 @@ -2343,7 +2440,7 @@ static uint8_t *nand_fill_oob(struct mtd_info *mtd, uint8_t *oob, size_t len,
746 return oob + len;
747
748 case MTD_OPS_AUTO_OOB: {
749 - struct nand_oobfree *free = chip->ecc.layout->oobfree;
750 + struct nand_oobfree *free = chip->cur_ecc->layout->oobfree;
751 uint32_t boffs = 0, woffs = ops->ooboffs;
752 size_t bytes = 0;
753
754 @@ -2539,6 +2636,46 @@ static int panic_nand_write(struct mtd_info *mtd, loff_t to, size_t len,
755 }
756
757 /**
758 + * panic_nand_part_write - [MTD Interface] NAND write with ECC
759 + * @mtd: MTD device structure
760 + * @to: offset to write to
761 + * @len: number of bytes to write
762 + * @retlen: pointer to variable to store the number of written bytes
763 + * @buf: the data to write
764 + *
765 + * NAND write with ECC. Used when performing writes in interrupt context, this
766 + * may for example be called by mtdoops when writing an oops while in panic.
767 + */
768 +static int panic_nand_part_write(struct mtd_info *mtd, loff_t to, size_t len,
769 + size_t *retlen, const uint8_t *buf)
770 +{
771 + struct nand_chip *chip = mtd->priv;
772 + struct nand_part *part = to_nand_part(mtd);
773 + struct mtd_oob_ops ops;
774 + int ret;
775 +
776 + to += part->offset;
777 + /* Wait for the device to get ready */
778 + panic_nand_wait(part->master, chip, 400);
779 +
780 + /* Grab the device */
781 + panic_nand_get_device(chip, part->master, FL_WRITING);
782 + if (part->ecc)
783 + chip->cur_ecc = part->ecc;
784 +
785 + ops.len = len;
786 + ops.datbuf = (uint8_t *)buf;
787 + ops.oobbuf = NULL;
788 + ops.mode = MTD_OPS_PLACE_OOB;
789 +
790 + ret = nand_do_write_ops(part->master, to, &ops);
791 +
792 + chip->cur_ecc = &chip->ecc;
793 + *retlen = ops.retlen;
794 + return ret;
795 +}
796 +
797 +/**
798 * nand_write - [MTD Interface] NAND write with ECC
799 * @mtd: MTD device structure
800 * @to: offset to write to
801 @@ -2566,6 +2703,39 @@ static int nand_write(struct mtd_info *mtd, loff_t to, size_t len,
802 }
803
804 /**
805 + * nand_part_write - [MTD Interface] NAND write with ECC
806 + * @mtd: MTD device structure
807 + * @to: offset to write to
808 + * @len: number of bytes to write
809 + * @retlen: pointer to variable to store the number of written bytes
810 + * @buf: the data to write
811 + *
812 + * NAND write with ECC.
813 + */
814 +static int nand_part_write(struct mtd_info *mtd, loff_t to, size_t len,
815 + size_t *retlen, const uint8_t *buf)
816 +{
817 + struct nand_chip *chip = mtd->priv;
818 + struct nand_part *part = to_nand_part(mtd);
819 + struct mtd_oob_ops ops;
820 + int ret;
821 +
822 + to += part->offset;
823 + nand_get_device(part->master, FL_WRITING);
824 + if (part->ecc)
825 + chip->cur_ecc = part->ecc;
826 + ops.len = len;
827 + ops.datbuf = (uint8_t *)buf;
828 + ops.oobbuf = NULL;
829 + ops.mode = MTD_OPS_PLACE_OOB;
830 + ret = nand_do_write_ops(part->master, to, &ops);
831 + *retlen = ops.retlen;
832 + chip->cur_ecc = &chip->ecc;
833 + nand_release_device(part->master);
834 + return ret;
835 +}
836 +
837 +/**
838 * nand_do_write_oob - [MTD Interface] NAND write out-of-band
839 * @mtd: MTD device structure
840 * @to: offset to write to
841 @@ -2583,7 +2753,7 @@ static int nand_do_write_oob(struct mtd_info *mtd, loff_t to,
842 __func__, (unsigned int)to, (int)ops->ooblen);
843
844 if (ops->mode == MTD_OPS_AUTO_OOB)
845 - len = chip->ecc.layout->oobavail;
846 + len = chip->cur_ecc->layout->oobavail;
847 else
848 len = mtd->oobsize;
849
850 @@ -2637,9 +2807,11 @@ static int nand_do_write_oob(struct mtd_info *mtd, loff_t to,
851 nand_fill_oob(mtd, ops->oobbuf, ops->ooblen, ops);
852
853 if (ops->mode == MTD_OPS_RAW)
854 - status = chip->ecc.write_oob_raw(mtd, chip, page & chip->pagemask);
855 + status = chip->cur_ecc->write_oob_raw(mtd, chip,
856 + page & chip->pagemask);
857 else
858 - status = chip->ecc.write_oob(mtd, chip, page & chip->pagemask);
859 + status = chip->cur_ecc->write_oob(mtd, chip,
860 + page & chip->pagemask);
861
862 chip->select_chip(mtd, -1);
863
864 @@ -2694,6 +2866,54 @@ static int nand_write_oob(struct mtd_info *mtd, loff_t to,
865 }
866
867 /**
868 + * nand_write_oob - [MTD Interface] NAND write data and/or out-of-band
869 + * @mtd: MTD device structure
870 + * @to: offset to write to
871 + * @ops: oob operation description structure
872 + */
873 +static int nand_part_write_oob(struct mtd_info *mtd, loff_t to,
874 + struct mtd_oob_ops *ops)
875 +{
876 + struct nand_chip *chip = mtd->priv;
877 + struct nand_part *part = to_nand_part(mtd);
878 + int ret = -ENOTSUPP;
879 +
880 + ops->retlen = 0;
881 +
882 + /* Do not allow writes past end of device */
883 + if (ops->datbuf && (to + ops->len) > mtd->size) {
884 + pr_debug("%s: attempt to write beyond end of device\n",
885 + __func__);
886 + return -EINVAL;
887 + }
888 +
889 + to += part->offset;
890 + nand_get_device(part->master, FL_WRITING);
891 + if (part->ecc)
892 + chip->cur_ecc = part->ecc;
893 +
894 + switch (ops->mode) {
895 + case MTD_OPS_PLACE_OOB:
896 + case MTD_OPS_AUTO_OOB:
897 + case MTD_OPS_RAW:
898 + break;
899 +
900 + default:
901 + goto out;
902 + }
903 +
904 + if (!ops->datbuf)
905 + ret = nand_do_write_oob(part->master, to, ops);
906 + else
907 + ret = nand_do_write_ops(part->master, to, ops);
908 +
909 +out:
910 + chip->cur_ecc = &chip->ecc;
911 + nand_release_device(part->master);
912 + return ret;
913 +}
914 +
915 +/**
916 * single_erase - [GENERIC] NAND standard block erase command function
917 * @mtd: MTD device structure
918 * @page: the page address of the block which will be erased
919 @@ -2723,6 +2943,29 @@ static int nand_erase(struct mtd_info *mtd, struct erase_info *instr)
920 }
921
922 /**
923 + * nand_part_erase - [MTD Interface] erase partition block(s)
924 + * @mtd: MTD device structure
925 + * @instr: erase instruction
926 + *
927 + * Erase one ore more blocks.
928 + */
929 +static int nand_part_erase(struct mtd_info *mtd, struct erase_info *instr)
930 +{
931 + struct nand_part *part = to_nand_part(mtd);
932 + int ret;
933 +
934 + instr->addr += part->offset;
935 + ret = nand_erase_nand(part->master, instr, 0);
936 + if (ret) {
937 + if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
938 + instr->fail_addr -= part->offset;
939 + instr->addr -= part->offset;
940 + }
941 +
942 + return ret;
943 +}
944 +
945 +/**
946 * nand_erase_nand - [INTERN] erase block(s)
947 * @mtd: MTD device structure
948 * @instr: erase instruction
949 @@ -2864,6 +3107,18 @@ static int nand_block_isbad(struct mtd_info *mtd, loff_t offs)
950 }
951
952 /**
953 + * nand_part_block_isbad - [MTD Interface] Check if block at offset is bad
954 + * @mtd: MTD device structure
955 + * @offs: offset relative to mtd start
956 + */
957 +static int nand_part_block_isbad(struct mtd_info *mtd, loff_t offs)
958 +{
959 + struct nand_part *part = to_nand_part(mtd);
960 +
961 + return nand_block_checkbad(part->master, part->offset + offs, 1, 0);
962 +}
963 +
964 +/**
965 * nand_block_markbad - [MTD Interface] Mark block at the given offset as bad
966 * @mtd: MTD device structure
967 * @ofs: offset relative to mtd start
968 @@ -2884,6 +3139,33 @@ static int nand_block_markbad(struct mtd_info *mtd, loff_t ofs)
969 }
970
971 /**
972 + * nand_part_block_markbad - [MTD Interface] Mark block at the given offset as
973 + * bad
974 + * @mtd: MTD device structure
975 + * @ofs: offset relative to mtd start
976 + */
977 +static int nand_part_block_markbad(struct mtd_info *mtd, loff_t ofs)
978 +{
979 + struct nand_part *part = to_nand_part(mtd);
980 + int ret;
981 +
982 + ofs += part->offset;
983 + ret = nand_block_isbad(part->master, ofs);
984 + if (ret) {
985 + /* If it was bad already, return success and do nothing */
986 + if (ret > 0)
987 + return 0;
988 + return ret;
989 + }
990 +
991 + ret = nand_block_markbad_lowlevel(part->master, ofs);
992 + if (!ret)
993 + mtd->ecc_stats.badblocks++;
994 +
995 + return ret;
996 +}
997 +
998 +/**
999 * nand_onfi_set_features- [REPLACEABLE] set features for ONFI nand
1000 * @mtd: MTD device structure
1001 * @chip: nand chip info structure
1002 @@ -4099,6 +4381,169 @@ static int nand_ecc_ctrl_init(struct mtd_info *mtd, struct nand_ecc_ctrl *ecc)
1003 }
1004
1005 /**
1006 + * nand_add_partition - [NAND Interface] Add a NAND partition to a NAND device
1007 + * @master: MTD device structure representing the NAND device
1008 + * @part: NAND partition to add to the NAND device
1009 + *
1010 + * Adds a NAND partition to a NAND device.
1011 + * The NAND partition cannot overlap with another existing partition.
1012 + *
1013 + * Returns zero in case of success and a negative error code in case of failure.
1014 + */
1015 +int nand_add_partition(struct mtd_info *master, struct nand_part *part)
1016 +{
1017 + struct nand_chip *chip = master->priv;
1018 + struct mtd_info *mtd = &part->mtd;
1019 + struct nand_ecc_ctrl *ecc = part->ecc;
1020 + struct nand_part *pos;
1021 + bool inserted = false;
1022 + int ret;
1023 +
1024 + /* set up the MTD object for this partition */
1025 + mtd->type = master->type;
1026 + mtd->flags = master->flags & ~mtd->flags;
1027 + mtd->writesize = master->writesize;
1028 + mtd->writebufsize = master->writebufsize;
1029 + mtd->oobsize = master->oobsize;
1030 + mtd->oobavail = master->oobavail;
1031 + mtd->subpage_sft = master->subpage_sft;
1032 + mtd->erasesize = master->erasesize;
1033 +
1034 + mtd->priv = chip;
1035 + mtd->owner = master->owner;
1036 + mtd->backing_dev_info = master->backing_dev_info;
1037 +
1038 + mtd->dev.parent = master->dev.parent;
1039 +
1040 + if (ecc) {
1041 + ret = nand_ecc_ctrl_init(mtd, ecc);
1042 + if (ret)
1043 + return ret;
1044 + } else {
1045 + ecc = &chip->ecc;
1046 + }
1047 +
1048 + mtd->_erase = nand_part_erase;
1049 + mtd->_point = NULL;
1050 + mtd->_unpoint = NULL;
1051 + mtd->_read = nand_part_read;
1052 + mtd->_write = nand_part_write;
1053 + mtd->_panic_write = panic_nand_part_write;
1054 + mtd->_read_oob = nand_part_read_oob;
1055 + mtd->_write_oob = nand_part_write_oob;
1056 + mtd->_sync = nand_sync;
1057 + mtd->_lock = NULL;
1058 + mtd->_unlock = NULL;
1059 + mtd->_suspend = nand_suspend;
1060 + mtd->_resume = nand_resume;
1061 + mtd->_block_isbad = nand_part_block_isbad;
1062 + mtd->_block_markbad = nand_part_block_markbad;
1063 +
1064 + /* propagate ecc info to mtd_info */
1065 + mtd->ecclayout = ecc->layout;
1066 + mtd->ecc_strength = ecc->strength;
1067 + mtd->ecc_step_size = ecc->size;
1068 + /*
1069 + * Initialize bitflip_threshold to its default prior scan_bbt() call.
1070 + * scan_bbt() might invoke mtd_read(), thus bitflip_threshold must be
1071 + * properly set.
1072 + */
1073 + if (!mtd->bitflip_threshold)
1074 + mtd->bitflip_threshold = mtd->ecc_strength;
1075 +
1076 + part->master = master;
1077 +
1078 + mutex_lock(&chip->part_lock);
1079 + list_for_each_entry(pos, &chip->partitions, node) {
1080 + if (part->offset >= pos->offset + pos->mtd.size) {
1081 + continue;
1082 + } else if (part->offset + mtd->size > pos->offset) {
1083 + ret = -EINVAL;
1084 + goto out;
1085 + }
1086 +
1087 + list_add(&part->node, pos->node.prev);
1088 + inserted = true;
1089 + break;
1090 + }
1091 +
1092 + if (!inserted)
1093 + list_add_tail(&part->node, &chip->partitions);
1094 +
1095 + ret = mtd_device_register(mtd, NULL, 0);
1096 + if (ret) {
1097 + list_del(&part->node);
1098 + goto out;
1099 + }
1100 +
1101 + if (master->_block_isbad) {
1102 + uint64_t offs = 0;
1103 +
1104 + while (offs < mtd->size) {
1105 + if (mtd_block_isreserved(master, offs + part->offset))
1106 + mtd->ecc_stats.bbtblocks++;
1107 + else if (mtd_block_isbad(master, offs + part->offset))
1108 + mtd->ecc_stats.badblocks++;
1109 + offs += mtd->erasesize;
1110 + }
1111 + }
1112 +
1113 +out:
1114 + mutex_unlock(&chip->part_lock);
1115 + return ret;
1116 +}
1117 +EXPORT_SYMBOL(nand_add_partition);
1118 +
1119 +/**
1120 + * nand_del_partition - [NAND Interface] Delete a NAND part from a NAND dev
1121 + * @part: NAND partition to delete
1122 + *
1123 + * Deletes a NAND partition from a NAND device.
1124 + */
1125 +void nand_del_partition(struct nand_part *part)
1126 +{
1127 + struct nand_chip *chip = part->mtd.priv;
1128 +
1129 + mutex_lock(&chip->part_lock);
1130 + mtd_device_unregister(&part->mtd);
1131 + list_del(&part->node);
1132 + mutex_unlock(&chip->part_lock);
1133 +
1134 + if (part->ecc && part->ecc->mode == NAND_ECC_SOFT_BCH)
1135 + nand_bch_free((struct nand_bch_control *)part->ecc->priv);
1136 +
1137 + if (part->release)
1138 + part->release(part);
1139 +}
1140 +EXPORT_SYMBOL(nand_del_partition);
1141 +
1142 +/*
1143 + * NAND part release function. Used by nandpart_alloc as its release function.
1144 + */
1145 +static void nandpart_release(struct nand_part *part)
1146 +{
1147 + kfree(part);
1148 +}
1149 +
1150 +/**
1151 + * nandpart_alloc - [NAND Interface] Allocate a NAND part struct
1152 + *
1153 + * Allocate a NAND partition and assign the nandpart release function.
1154 + * This nand_part struct must be filled before passing it to the
1155 + * nand_add_partition function.
1156 + */
1157 +struct nand_part *nandpart_alloc(void)
1158 +{
1159 + struct nand_part *part = kzalloc(sizeof(*part), GFP_KERNEL);
1160 + if (!part)
1161 + return ERR_PTR(-ENOMEM);
1162 + part->release = nandpart_release;
1163 +
1164 + return part;
1165 +}
1166 +EXPORT_SYMBOL(nandpart_alloc);
1167 +
1168 +/**
1169 * nand_scan_tail - [NAND Interface] Scan for the NAND device
1170 * @mtd: MTD device structure
1171 *
1172 @@ -4146,6 +4591,11 @@ int nand_scan_tail(struct mtd_info *mtd)
1173 return ret;
1174 }
1175
1176 + INIT_LIST_HEAD(&chip->partitions);
1177 + mutex_init(&chip->part_lock);
1178 +
1179 + chip->cur_ecc = &chip->ecc;
1180 +
1181 /* Allow subpage writes up to ecc.steps. Not possible for MLC flash */
1182 if (!(chip->options & NAND_NO_SUBPAGE_WRITE) && nand_is_slc(chip)) {
1183 switch (ecc->steps) {
1184 diff --git a/drivers/mtd/nand/nand_bch.c b/drivers/mtd/nand/nand_bch.c
1185 index 3803e0b..b82b976 100644
1186 --- a/drivers/mtd/nand/nand_bch.c
1187 +++ b/drivers/mtd/nand/nand_bch.c
1188 @@ -53,14 +53,14 @@ int nand_bch_calculate_ecc(struct mtd_info *mtd, const unsigned char *buf,
1189 unsigned char *code)
1190 {
1191 const struct nand_chip *chip = mtd->priv;
1192 - struct nand_bch_control *nbc = chip->ecc.priv;
1193 + struct nand_bch_control *nbc = chip->cur_ecc->priv;
1194 unsigned int i;
1195
1196 - memset(code, 0, chip->ecc.bytes);
1197 - encode_bch(nbc->bch, buf, chip->ecc.size, code);
1198 + memset(code, 0, chip->cur_ecc->bytes);
1199 + encode_bch(nbc->bch, buf, chip->cur_ecc->size, code);
1200
1201 /* apply mask so that an erased page is a valid codeword */
1202 - for (i = 0; i < chip->ecc.bytes; i++)
1203 + for (i = 0; i < chip->cur_ecc->bytes; i++)
1204 code[i] ^= nbc->eccmask[i];
1205
1206 return 0;
1207 @@ -80,15 +80,15 @@ int nand_bch_correct_data(struct mtd_info *mtd, unsigned char *buf,
1208 unsigned char *read_ecc, unsigned char *calc_ecc)
1209 {
1210 const struct nand_chip *chip = mtd->priv;
1211 - struct nand_bch_control *nbc = chip->ecc.priv;
1212 + struct nand_bch_control *nbc = chip->cur_ecc->priv;
1213 unsigned int *errloc = nbc->errloc;
1214 int i, count;
1215
1216 - count = decode_bch(nbc->bch, NULL, chip->ecc.size, read_ecc, calc_ecc,
1217 - NULL, errloc);
1218 + count = decode_bch(nbc->bch, NULL, chip->cur_ecc->size, read_ecc,
1219 + calc_ecc, NULL, errloc);
1220 if (count > 0) {
1221 for (i = 0; i < count; i++) {
1222 - if (errloc[i] < (chip->ecc.size*8))
1223 + if (errloc[i] < (chip->cur_ecc->size*8))
1224 /* error is located in data, correct it */
1225 buf[errloc[i] >> 3] ^= (1 << (errloc[i] & 7));
1226 /* else error in ecc, no action needed */
1227 diff --git a/drivers/mtd/nand/nand_ecc.c b/drivers/mtd/nand/nand_ecc.c
1228 index 97c4c02..f35c418 100644
1229 --- a/drivers/mtd/nand/nand_ecc.c
1230 +++ b/drivers/mtd/nand/nand_ecc.c
1231 @@ -424,7 +424,7 @@ int nand_calculate_ecc(struct mtd_info *mtd, const unsigned char *buf,
1232 unsigned char *code)
1233 {
1234 __nand_calculate_ecc(buf,
1235 - ((struct nand_chip *)mtd->priv)->ecc.size, code);
1236 + ((struct nand_chip *)mtd->priv)->cur_ecc->size, code);
1237
1238 return 0;
1239 }
1240 @@ -524,7 +524,7 @@ int nand_correct_data(struct mtd_info *mtd, unsigned char *buf,
1241 unsigned char *read_ecc, unsigned char *calc_ecc)
1242 {
1243 return __nand_correct_data(buf, read_ecc, calc_ecc,
1244 - ((struct nand_chip *)mtd->priv)->ecc.size);
1245 + ((struct nand_chip *)mtd->priv)->cur_ecc->size);
1246 }
1247 EXPORT_SYMBOL(nand_correct_data);
1248
1249 diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
1250 index 3d4ea7e..510e09b 100644
1251 --- a/include/linux/mtd/nand.h
1252 +++ b/include/linux/mtd/nand.h
1253 @@ -708,6 +708,7 @@ struct nand_chip {
1254 struct nand_hw_control *controller;
1255
1256 struct nand_ecc_ctrl ecc;
1257 + struct nand_ecc_ctrl *cur_ecc;
1258 struct nand_buffers *buffers;
1259 struct nand_hw_control hwcontrol;
1260
1261 @@ -717,9 +718,46 @@ struct nand_chip {
1262
1263 struct nand_bbt_descr *badblock_pattern;
1264
1265 + struct list_head partitions;
1266 + struct mutex part_lock;
1267 +
1268 void *priv;
1269 };
1270
1271 +/**
1272 + * struct nand_part - NAND partition structure
1273 + * @node: list node used to attach the partition to its NAND dev
1274 + * @mtd: MTD partiton info
1275 + * @master: MTD device representing the NAND chip
1276 + * @offset: partition offset
1277 + * @ecc: partition specific ECC struct
1278 + * @release: function used to release this nand_part struct
1279 + *
1280 + * NAND partitions work as standard MTD partitions except it can override
1281 + * NAND chip ECC handling.
1282 + * This is particularly useful for SoCs that need specific ECC configs to boot
1283 + * from NAND while these ECC configs do not fit the NAND chip ECC requirements.
1284 + */
1285 +struct nand_part {
1286 + struct list_head node;
1287 + struct mtd_info mtd;
1288 + struct mtd_info *master;
1289 + uint64_t offset;
1290 + struct nand_ecc_ctrl *ecc;
1291 + void (*release)(struct nand_part *part);
1292 +};
1293 +
1294 +static inline struct nand_part *to_nand_part(struct mtd_info *mtd)
1295 +{
1296 + return container_of(mtd, struct nand_part, mtd);
1297 +}
1298 +
1299 +int nand_add_partition(struct mtd_info *master, struct nand_part *part);
1300 +
1301 +void nand_del_partition(struct nand_part *part);
1302 +
1303 +struct nand_part *nandpart_alloc(void);
1304 +
1305 /*
1306 * NAND Flash Manufacturer ID Codes
1307 */