1 // SPDX-License-Identifier: GPL-2.0+
3 * LPC32xx MLC NAND flash controller driver
5 * (C) Copyright 2014 3ADEV <http://3adev.com>
6 * Written by Albert ARIBAUD <albert.aribaud@3adev.fr>
10 * The MLC NAND flash controller provides hardware Reed-Solomon ECC
11 * covering in- and out-of-band data together. Therefore, in- and out-
12 * of-band data must be written together in order to have a valid ECC.
14 * Consequently, pages with meaningful in-band data are written with
15 * blank (all-ones) out-of-band data and a valid ECC, and any later
16 * out-of-band data write will void the ECC.
18 * Therefore, code which reads such late-written out-of-band data
19 * should not rely on the ECC validity.
24 #include <linux/delay.h>
25 #include <linux/errno.h>
28 #include <asm/arch/clk.h>
29 #include <asm/arch/sys_proto.h>
32 * MLC NAND controller registers.
34 struct lpc32xx_nand_mlc_registers {
35 u8 buff[32768]; /* controller's serial data buffer */
36 u8 data[32768]; /* NAND's raw data buffer */
58 /* LOCK_PR register defines */
59 #define LOCK_PR_UNLOCK_KEY 0x0000A25E /* Magic unlock value */
62 #define ICR_LARGE_BLOCKS 0x00000004 /* configure for 2KB blocks */
63 #define ICR_ADDR4 0x00000002 /* configure for 4-word addrs */
66 #define CEH_NORMAL_CE 0x00000001 /* do not force CE ON */
68 /* ISR register defines */
69 #define ISR_NAND_READY 0x00000001
70 #define ISR_CONTROLLER_READY 0x00000002
71 #define ISR_ECC_READY 0x00000004
72 #define ISR_DECODER_ERRORS(s) ((((s) >> 4) & 3)+1)
73 #define ISR_DECODER_FAILURE 0x00000040
74 #define ISR_DECODER_ERROR 0x00000008
76 /* time-out for NAND chip / controller loops, in us */
77 #define LPC32X_NAND_TIMEOUT 5000
80 * There is a single instance of the NAND MLC controller
83 static struct lpc32xx_nand_mlc_registers __iomem *lpc32xx_nand_mlc_registers
84 = (struct lpc32xx_nand_mlc_registers __iomem *)MLC_NAND_BASE;
86 #if !defined(CONFIG_SYS_MAX_NAND_CHIPS)
87 #define CONFIG_SYS_MAX_NAND_CHIPS 1
90 #define clkdiv(v, w, o) (((1+(clk/v)) & w) << o)
93 * OOB data in each small page are 6 'free' then 10 ECC bytes.
94 * To make things easier, when reading large pages, the four pages'
95 * 'free' OOB bytes are grouped in the first 24 bytes of the OOB buffer,
96 * while the the four ECC bytes are groupe in its last 40 bytes.
98 * The struct below represents how free vs ecc oob bytes are stored
101 * Note: the OOB bytes contain the bad block marker at offsets 0 and 1.
106 uint8_t free_oob_bytes[6];
109 uint8_t ecc_oob_bytes[10];
114 * Initialize the controller
117 static void lpc32xx_nand_init(void)
121 /* Configure controller for no software write protection, x8 bus
122 width, large block device, and 4 address words */
124 /* unlock controller registers with magic key */
125 writel(LOCK_PR_UNLOCK_KEY,
126 &lpc32xx_nand_mlc_registers->lock_pr);
128 /* enable large blocks and large NANDs */
129 writel(ICR_LARGE_BLOCKS | ICR_ADDR4,
130 &lpc32xx_nand_mlc_registers->icr);
132 /* Make sure MLC interrupts are disabled */
133 writel(0, &lpc32xx_nand_mlc_registers->irq_mr);
135 /* Normal chip enable operation */
136 writel(CEH_NORMAL_CE,
137 &lpc32xx_nand_mlc_registers->ceh);
139 /* Setup NAND timing */
140 clk = get_hclk_clk_rate();
143 clkdiv(CONFIG_LPC32XX_NAND_MLC_TCEA_DELAY, 0x03, 24) |
144 clkdiv(CONFIG_LPC32XX_NAND_MLC_BUSY_DELAY, 0x1F, 19) |
145 clkdiv(CONFIG_LPC32XX_NAND_MLC_NAND_TA, 0x07, 16) |
146 clkdiv(CONFIG_LPC32XX_NAND_MLC_RD_HIGH, 0x0F, 12) |
147 clkdiv(CONFIG_LPC32XX_NAND_MLC_RD_LOW, 0x0F, 8) |
148 clkdiv(CONFIG_LPC32XX_NAND_MLC_WR_HIGH, 0x0F, 4) |
149 clkdiv(CONFIG_LPC32XX_NAND_MLC_WR_LOW, 0x0F, 0),
150 &lpc32xx_nand_mlc_registers->time_reg);
153 #if !defined(CONFIG_SPL_BUILD)
156 * lpc32xx_cmd_ctrl - write command to either cmd or data register
159 static void lpc32xx_cmd_ctrl(struct mtd_info *mtd, int cmd,
162 if (cmd == NAND_CMD_NONE)
166 writeb(cmd & 0Xff, &lpc32xx_nand_mlc_registers->cmd);
167 else if (ctrl & NAND_ALE)
168 writeb(cmd & 0Xff, &lpc32xx_nand_mlc_registers->addr);
172 * lpc32xx_read_byte - read a byte from the NAND
173 * @mtd: MTD device structure
176 static uint8_t lpc32xx_read_byte(struct mtd_info *mtd)
178 return readb(&lpc32xx_nand_mlc_registers->data);
182 * lpc32xx_dev_ready - test if NAND device (actually controller) is ready
183 * @mtd: MTD device structure
184 * @mode: mode to set the ECC HW to.
187 static int lpc32xx_dev_ready(struct mtd_info *mtd)
189 /* means *controller* ready for us */
190 int status = readl(&lpc32xx_nand_mlc_registers->isr);
191 return status & ISR_CONTROLLER_READY;
195 * ECC layout -- this is needed whatever ECC mode we are using.
196 * In a 2KB (4*512B) page, R/S codes occupy 40 (4*10) bytes.
197 * To make U-Boot's life easier, we pack 'useable' OOB at the
198 * front and R/S ECC at the back.
201 static struct nand_ecclayout lpc32xx_largepage_ecclayout = {
203 .eccpos = {24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
204 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
205 44, 45, 46, 47, 48, 48, 50, 51, 52, 53,
206 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
209 /* bytes 0 and 1 are used for the bad block marker */
218 * lpc32xx_read_page_hwecc - read in- and out-of-band data with ECC
219 * @mtd: mtd info structure
220 * @chip: nand chip info structure
221 * @buf: buffer to store read data
222 * @oob_required: caller requires OOB data read to chip->oob_poi
223 * @page: page number to read
225 * Use large block Auto Decode Read Mode(1) as described in User Manual
228 * The initial Read Mode and Read Start commands are sent by the caller.
230 * ECC will be false if out-of-band data has been updated since in-band
231 * data was initially written.
234 static int lpc32xx_read_page_hwecc(struct mtd_info *mtd,
235 struct nand_chip *chip, uint8_t *buf, int oob_required,
238 unsigned int i, status, timeout, err, max_bitflips = 0;
239 struct lpc32xx_oob *oob = (struct lpc32xx_oob *)chip->oob_poi;
241 /* go through all four small pages */
242 for (i = 0; i < 4; i++) {
243 /* start auto decode (reads 528 NAND bytes) */
244 writel(0, &lpc32xx_nand_mlc_registers->ecc_auto_dec_reg);
245 /* wait for controller to return to ready state */
246 for (timeout = LPC32X_NAND_TIMEOUT; timeout; timeout--) {
247 status = readl(&lpc32xx_nand_mlc_registers->isr);
248 if (status & ISR_CONTROLLER_READY)
252 /* if decoder failed, return failure */
253 if (status & ISR_DECODER_FAILURE)
255 /* keep count of maximum bitflips performed */
256 if (status & ISR_DECODER_ERROR) {
257 err = ISR_DECODER_ERRORS(status);
258 if (err > max_bitflips)
261 /* copy first 512 bytes into buffer */
262 memcpy(buf+512*i, lpc32xx_nand_mlc_registers->buff, 512);
263 /* copy next 6 bytes at front of OOB buffer */
264 memcpy(&oob->free[i], lpc32xx_nand_mlc_registers->buff, 6);
265 /* copy last 10 bytes (R/S ECC) at back of OOB buffer */
266 memcpy(&oob->ecc[i], lpc32xx_nand_mlc_registers->buff, 10);
272 * lpc32xx_read_page_raw - read raw (in-band, out-of-band and ECC) data
273 * @mtd: mtd info structure
274 * @chip: nand chip info structure
275 * @buf: buffer to store read data
276 * @oob_required: caller requires OOB data read to chip->oob_poi
277 * @page: page number to read
279 * Read NAND directly; can read pages with invalid ECC.
282 static int lpc32xx_read_page_raw(struct mtd_info *mtd,
283 struct nand_chip *chip, uint8_t *buf, int oob_required,
286 unsigned int i, status, timeout;
287 struct lpc32xx_oob *oob = (struct lpc32xx_oob *)chip->oob_poi;
289 /* when we get here we've already had the Read Mode(1) */
291 /* go through all four small pages */
292 for (i = 0; i < 4; i++) {
293 /* wait for NAND to return to ready state */
294 for (timeout = LPC32X_NAND_TIMEOUT; timeout; timeout--) {
295 status = readl(&lpc32xx_nand_mlc_registers->isr);
296 if (status & ISR_NAND_READY)
300 /* if NAND stalled, return failure */
301 if (!(status & ISR_NAND_READY))
303 /* copy first 512 bytes into buffer */
304 memcpy(buf+512*i, lpc32xx_nand_mlc_registers->data, 512);
305 /* copy next 6 bytes at front of OOB buffer */
306 memcpy(&oob->free[i], lpc32xx_nand_mlc_registers->data, 6);
307 /* copy last 10 bytes (R/S ECC) at back of OOB buffer */
308 memcpy(&oob->ecc[i], lpc32xx_nand_mlc_registers->data, 10);
314 * lpc32xx_read_oob - read out-of-band data
315 * @mtd: mtd info structure
316 * @chip: nand chip info structure
317 * @page: page number to read
319 * Read out-of-band data. User Manual section 8.6.4 suggests using Read
320 * Mode(3) which the controller will turn into a Read Mode(1) internally
321 * but nand_base.c will turn Mode(3) into Mode(0), so let's use Mode(0)
324 * ECC covers in- and out-of-band data and was written when out-of-band
325 * data was blank. Therefore, if the out-of-band being read here is not
326 * blank, then the ECC will be false and the read will return bitflips,
327 * even in case of ECC failure where we will return 5 bitflips. The
328 * caller should be prepared to handle this.
331 static int lpc32xx_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
334 unsigned int i, status, timeout, err, max_bitflips = 0;
335 struct lpc32xx_oob *oob = (struct lpc32xx_oob *)chip->oob_poi;
337 /* No command was sent before calling read_oob() so send one */
339 chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
341 /* go through all four small pages */
342 for (i = 0; i < 4; i++) {
343 /* start auto decode (reads 528 NAND bytes) */
344 writel(0, &lpc32xx_nand_mlc_registers->ecc_auto_dec_reg);
345 /* wait for controller to return to ready state */
346 for (timeout = LPC32X_NAND_TIMEOUT; timeout; timeout--) {
347 status = readl(&lpc32xx_nand_mlc_registers->isr);
348 if (status & ISR_CONTROLLER_READY)
352 /* if decoder failure, count 'one too many' bitflips */
353 if (status & ISR_DECODER_FAILURE)
355 /* keep count of maximum bitflips performed */
356 if (status & ISR_DECODER_ERROR) {
357 err = ISR_DECODER_ERRORS(status);
358 if (err > max_bitflips)
361 /* set read pointer to OOB area */
362 writel(0, &lpc32xx_nand_mlc_registers->robp);
363 /* copy next 6 bytes at front of OOB buffer */
364 memcpy(&oob->free[i], lpc32xx_nand_mlc_registers->buff, 6);
365 /* copy next 10 bytes (R/S ECC) at back of OOB buffer */
366 memcpy(&oob->ecc[i], lpc32xx_nand_mlc_registers->buff, 10);
372 * lpc32xx_write_page_hwecc - write in- and out-of-band data with ECC
373 * @mtd: mtd info structure
374 * @chip: nand chip info structure
376 * @oob_required: must write chip->oob_poi to OOB
378 * Use large block Auto Encode as per User Manual section 8.6.4.
380 * The initial Write Serial Input and final Auto Program commands are
381 * sent by the caller.
384 static int lpc32xx_write_page_hwecc(struct mtd_info *mtd,
385 struct nand_chip *chip, const uint8_t *buf, int oob_required,
388 unsigned int i, status, timeout;
389 struct lpc32xx_oob *oob = (struct lpc32xx_oob *)chip->oob_poi;
391 /* when we get here we've already had the SEQIN */
392 for (i = 0; i < 4; i++) {
393 /* start encode (expects 518 writes to buff) */
394 writel(0, &lpc32xx_nand_mlc_registers->ecc_enc_reg);
395 /* copy first 512 bytes from buffer */
396 memcpy(&lpc32xx_nand_mlc_registers->buff, buf+512*i, 512);
397 /* copy next 6 bytes from OOB buffer -- excluding ECC */
398 memcpy(&lpc32xx_nand_mlc_registers->buff, &oob->free[i], 6);
399 /* wait for ECC to return to ready state */
400 for (timeout = LPC32X_NAND_TIMEOUT; timeout; timeout--) {
401 status = readl(&lpc32xx_nand_mlc_registers->isr);
402 if (status & ISR_ECC_READY)
406 /* if ECC stalled, return failure */
407 if (!(status & ISR_ECC_READY))
409 /* Trigger auto encode (writes 528 bytes to NAND) */
410 writel(0, &lpc32xx_nand_mlc_registers->ecc_auto_enc_reg);
411 /* wait for controller to return to ready state */
412 for (timeout = LPC32X_NAND_TIMEOUT; timeout; timeout--) {
413 status = readl(&lpc32xx_nand_mlc_registers->isr);
414 if (status & ISR_CONTROLLER_READY)
418 /* if controller stalled, return error */
419 if (!(status & ISR_CONTROLLER_READY))
426 * lpc32xx_write_page_raw - write raw (in-band, out-of-band and ECC) data
427 * @mtd: mtd info structure
428 * @chip: nand chip info structure
429 * @buf: buffer to store read data
430 * @oob_required: caller requires OOB data read to chip->oob_poi
431 * @page: page number to read
433 * Use large block write but without encode.
435 * The initial Write Serial Input and final Auto Program commands are
436 * sent by the caller.
438 * This function will write the full out-of-band data, including the
439 * ECC area. Therefore, it can write pages with valid *or* invalid ECC.
442 static int lpc32xx_write_page_raw(struct mtd_info *mtd,
443 struct nand_chip *chip, const uint8_t *buf, int oob_required,
447 struct lpc32xx_oob *oob = (struct lpc32xx_oob *)chip->oob_poi;
449 /* when we get here we've already had the Read Mode(1) */
450 for (i = 0; i < 4; i++) {
451 /* copy first 512 bytes from buffer */
452 memcpy(lpc32xx_nand_mlc_registers->buff, buf+512*i, 512);
453 /* copy next 6 bytes into OOB buffer -- excluding ECC */
454 memcpy(lpc32xx_nand_mlc_registers->buff, &oob->free[i], 6);
455 /* copy next 10 bytes into OOB buffer -- that is 'ECC' */
456 memcpy(lpc32xx_nand_mlc_registers->buff, &oob->ecc[i], 10);
462 * lpc32xx_write_oob - write out-of-band data
463 * @mtd: mtd info structure
464 * @chip: nand chip info structure
465 * @page: page number to read
467 * Since ECC covers in- and out-of-band data, writing out-of-band data
468 * with ECC will render the page ECC wrong -- or, if the page was blank,
469 * then it will produce a good ECC but a later in-band data write will
472 * Therefore, do not compute or write any ECC, and always return success.
474 * This implies that we do four writes, since non-ECC out-of-band data
475 * are not contiguous in a large page.
478 static int lpc32xx_write_oob(struct mtd_info *mtd, struct nand_chip *chip,
481 /* update oob on all 4 subpages in sequence */
482 unsigned int i, status, timeout;
483 struct lpc32xx_oob *oob = (struct lpc32xx_oob *)chip->oob_poi;
485 for (i = 0; i < 4; i++) {
486 /* start data input */
487 chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x200+0x210*i, page);
488 /* copy 6 non-ECC out-of-band bytes directly into NAND */
489 memcpy(lpc32xx_nand_mlc_registers->data, &oob->free[i], 6);
491 chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
492 /* wait for NAND to return to ready state */
493 for (timeout = LPC32X_NAND_TIMEOUT; timeout; timeout--) {
494 status = readl(&lpc32xx_nand_mlc_registers->isr);
495 if (status & ISR_NAND_READY)
499 /* if NAND stalled, return error */
500 if (!(status & ISR_NAND_READY))
507 * lpc32xx_waitfunc - wait until a command is done
508 * @mtd: MTD device structure
509 * @chip: NAND chip structure
511 * Wait for controller and FLASH to both be ready.
514 static int lpc32xx_waitfunc(struct mtd_info *mtd, struct nand_chip *chip)
517 unsigned int timeout;
518 /* wait until both controller and NAND are ready */
519 for (timeout = LPC32X_NAND_TIMEOUT; timeout; timeout--) {
520 status = readl(&lpc32xx_nand_mlc_registers->isr);
521 if ((status & (ISR_CONTROLLER_READY || ISR_NAND_READY))
522 == (ISR_CONTROLLER_READY || ISR_NAND_READY))
526 /* if controller or NAND stalled, return error */
527 if ((status & (ISR_CONTROLLER_READY || ISR_NAND_READY))
528 != (ISR_CONTROLLER_READY || ISR_NAND_READY))
530 /* write NAND status command */
531 writel(NAND_CMD_STATUS, &lpc32xx_nand_mlc_registers->cmd);
532 /* read back status and return it */
533 return readb(&lpc32xx_nand_mlc_registers->data);
537 * We are self-initializing, so we need our own chip struct
540 static struct nand_chip lpc32xx_chip;
543 * Initialize the controller
546 void board_nand_init(void)
548 struct mtd_info *mtd = nand_to_mtd(&lpc32xx_chip);
551 /* Set all BOARDSPECIFIC (actually core-specific) fields */
553 lpc32xx_chip.IO_ADDR_R = &lpc32xx_nand_mlc_registers->buff;
554 lpc32xx_chip.IO_ADDR_W = &lpc32xx_nand_mlc_registers->buff;
555 lpc32xx_chip.cmd_ctrl = lpc32xx_cmd_ctrl;
556 /* do not set init_size: nand_base.c will read sizes from chip */
557 lpc32xx_chip.dev_ready = lpc32xx_dev_ready;
558 /* do not set setup_read_retry: this is NAND-chip-specific */
559 /* do not set chip_delay: we have dev_ready defined. */
560 lpc32xx_chip.options |= NAND_NO_SUBPAGE_WRITE;
562 /* Set needed ECC fields */
564 lpc32xx_chip.ecc.mode = NAND_ECC_HW;
565 lpc32xx_chip.ecc.layout = &lpc32xx_largepage_ecclayout;
566 lpc32xx_chip.ecc.size = 512;
567 lpc32xx_chip.ecc.bytes = 10;
568 lpc32xx_chip.ecc.strength = 4;
569 lpc32xx_chip.ecc.read_page = lpc32xx_read_page_hwecc;
570 lpc32xx_chip.ecc.read_page_raw = lpc32xx_read_page_raw;
571 lpc32xx_chip.ecc.write_page = lpc32xx_write_page_hwecc;
572 lpc32xx_chip.ecc.write_page_raw = lpc32xx_write_page_raw;
573 lpc32xx_chip.ecc.read_oob = lpc32xx_read_oob;
574 lpc32xx_chip.ecc.write_oob = lpc32xx_write_oob;
575 lpc32xx_chip.waitfunc = lpc32xx_waitfunc;
577 lpc32xx_chip.read_byte = lpc32xx_read_byte; /* FIXME: NEEDED? */
579 /* BBT options: read from last two pages */
580 lpc32xx_chip.bbt_options |= NAND_BBT_USE_FLASH | NAND_BBT_LASTBLOCK
581 | NAND_BBT_SCANLASTPAGE | NAND_BBT_SCAN2NDPAGE
584 /* Initialize NAND interface */
588 ret = nand_scan_ident(mtd, CONFIG_SYS_MAX_NAND_CHIPS, NULL);
590 pr_err("nand_scan_ident returned %i", ret);
594 /* finish scanning the chip */
595 ret = nand_scan_tail(mtd);
597 pr_err("nand_scan_tail returned %i", ret);
601 /* chip is good, register it */
602 ret = nand_register(0, mtd);
604 pr_err("nand_register returned %i", ret);
607 #else /* defined(CONFIG_SPL_BUILD) */
611 /* enable NAND controller */
612 lpc32xx_mlc_nand_init();
613 /* initialize NAND controller */
617 void nand_deselect(void)
619 /* nothing to do, but SPL requires this function */
622 static int read_single_page(uint8_t *dest, int page,
623 struct lpc32xx_oob *oob)
625 int status, i, timeout, err, max_bitflips = 0;
627 /* enter read mode */
628 writel(NAND_CMD_READ0, &lpc32xx_nand_mlc_registers->cmd);
629 /* send column (lsb then MSB) and page (lsb to MSB) */
630 writel(0, &lpc32xx_nand_mlc_registers->addr);
631 writel(0, &lpc32xx_nand_mlc_registers->addr);
632 writel(page & 0xff, &lpc32xx_nand_mlc_registers->addr);
633 writel((page>>8) & 0xff, &lpc32xx_nand_mlc_registers->addr);
634 writel((page>>16) & 0xff, &lpc32xx_nand_mlc_registers->addr);
636 writel(NAND_CMD_READSTART, &lpc32xx_nand_mlc_registers->cmd);
638 /* large page auto decode read */
639 for (i = 0; i < 4; i++) {
640 /* start auto decode (reads 528 NAND bytes) */
641 writel(0, &lpc32xx_nand_mlc_registers->ecc_auto_dec_reg);
642 /* wait for controller to return to ready state */
643 for (timeout = LPC32X_NAND_TIMEOUT; timeout; timeout--) {
644 status = readl(&lpc32xx_nand_mlc_registers->isr);
645 if (status & ISR_CONTROLLER_READY)
649 /* if controller stalled, return error */
650 if (!(status & ISR_CONTROLLER_READY))
652 /* if decoder failure, return error */
653 if (status & ISR_DECODER_FAILURE)
655 /* keep count of maximum bitflips performed */
656 if (status & ISR_DECODER_ERROR) {
657 err = ISR_DECODER_ERRORS(status);
658 if (err > max_bitflips)
661 /* copy first 512 bytes into buffer */
662 memcpy(dest+i*512, lpc32xx_nand_mlc_registers->buff, 512);
663 /* copy next 6 bytes bytes into OOB buffer */
664 memcpy(&oob->free[i], lpc32xx_nand_mlc_registers->buff, 6);
670 * Load U-Boot signed image.
671 * This loads an image from NAND, skipping bad blocks.
672 * A block is declared bad if at least one of its readable pages has
673 * a bad block marker in its OOB at position 0.
674 * If all pages ion a block are unreadable, the block is considered
675 * bad (i.e., assumed not to be part of the image) and skipped.
679 * If the first block of the image is fully unreadable, it will be
680 * ignored and skipped as if it had been marked bad. If it was not
681 * actually marked bad at the time of writing the image, the resulting
682 * image loaded will lack a header and magic number. It could thus be
683 * considered as a raw, headerless, image and SPL might erroneously
686 * In order to avoid this risk, LPC32XX-based boards which use this
687 * driver MUST define CONFIG_SPL_PANIC_ON_RAW_IMAGE.
690 #define BYTES_PER_PAGE 2048
691 #define PAGES_PER_BLOCK 64
692 #define BYTES_PER_BLOCK (BYTES_PER_PAGE * PAGES_PER_BLOCK)
693 #define PAGES_PER_CHIP_MAX 524288
695 int nand_spl_load_image(uint32_t offs, unsigned int size, void *dst)
697 int bytes_left = size;
698 int pages_left = DIV_ROUND_UP(size, BYTES_PER_PAGE);
699 int blocks_left = DIV_ROUND_UP(size, BYTES_PER_BLOCK);
701 int page = offs / BYTES_PER_PAGE;
702 /* perform reads block by block */
703 while (blocks_left) {
704 /* compute first page number to read */
705 void *block_page_dst = dst;
706 /* read at most one block, possibly less */
707 int block_bytes_left = bytes_left;
708 if (block_bytes_left > BYTES_PER_BLOCK)
709 block_bytes_left = BYTES_PER_BLOCK;
710 /* keep track of good, failed, and "bad" pages */
711 int block_pages_good = 0;
712 int block_pages_bad = 0;
713 int block_pages_err = 0;
714 /* we shall read a full block of pages, maybe less */
715 int block_pages_left = pages_left;
716 if (block_pages_left > PAGES_PER_BLOCK)
717 block_pages_left = PAGES_PER_BLOCK;
718 int block_pages = block_pages_left;
719 int block_page = page;
720 /* while pages are left and the block is not known as bad */
721 while ((block_pages > 0) && (block_pages_bad == 0)) {
722 /* we will read OOB, too, for bad block markers */
723 struct lpc32xx_oob oob;
725 int res = read_single_page(block_page_dst, block_page,
727 /* count readable pages */
729 /* this page is good */
731 /* this page is bad */
732 if ((oob.free[0].free_oob_bytes[0] != 0xff)
733 | (oob.free[0].free_oob_bytes[1] != 0xff))
738 /* we're done with this page */
740 block_page_dst += BYTES_PER_PAGE;
744 /* a fully unreadable block is considered bad */
745 if (block_pages_good == 0)
746 block_pages_bad = block_pages_err;
747 /* errors are fatal only in good blocks */
748 if ((block_pages_err > 0) && (block_pages_bad == 0))
750 /* we keep reads only of good blocks */
751 if (block_pages_bad == 0) {
752 dst += block_bytes_left;
753 bytes_left -= block_bytes_left;
754 pages_left -= block_pages_left;
757 /* good or bad, we're done with this block */
759 page += PAGES_PER_BLOCK;
766 #endif /* CONFIG_SPL_BUILD */