Merge branch 'master' of git://git.denx.de/u-boot-x86

[u-boot] / drivers / mtd / nand / sunxi_nand_spl.c

diff --git a/drivers/mtd/nand/sunxi_nand_spl.c b/drivers/mtd/nand/sunxi_nand_spl.c
index 3206a502027ed4fb2b037e13b0146bcc522a1737..b0e07aa2d088a27977ddbb380d263b4a10e4a2be 100644 (file)
--- a/drivers/mtd/nand/sunxi_nand_spl.c
+++ b/drivers/mtd/nand/sunxi_nand_spl.c
@@ -67,7 +67,8 @@
 #define NFC_SEND_CMD3              (1 << 28)
 #define NFC_SEND_CMD4              (1 << 29)
 
-#define NFC_CMD_INT_FLAG           (1 << 1)
+#define NFC_ST_CMD_INT_FLAG        (1 << 1)
+#define NFC_ST_DMA_INT_FLAG        (1 << 2)
 
 #define NFC_READ_CMD_OFFSET         0
 #define NFC_RANDOM_READ_CMD0_OFFSET 8
@@ -169,14 +170,16 @@ void nand_init(void)
        }
 
        /* reset NAND */
+       writel(NFC_ST_CMD_INT_FLAG, SUNXI_NFC_BASE + NFC_ST);
        writel(NFC_SEND_CMD1 | NFC_WAIT_FLAG | NAND_CMD_RESET,
               SUNXI_NFC_BASE + NFC_CMD);
 
-       if (!check_value(SUNXI_NFC_BASE + NFC_ST, NFC_CMD_INT_FLAG,
+       if (!check_value(SUNXI_NFC_BASE + NFC_ST, NFC_ST_CMD_INT_FLAG,
                         MAX_RETRIES)) {
                printf("Error timeout waiting for nand reset\n");
                return;
        }
+       writel(NFC_ST_CMD_INT_FLAG, SUNXI_NFC_BASE + NFC_ST);
 }
 
 static int nand_read_page(int page_size, int ecc_strength, int ecc_page_size,
@@ -259,17 +262,19 @@ static int nand_read_page(int page_size, int ecc_strength, int ecc_page_size,
        writel(((page & 0xFFFF) << 16) | column,
               SUNXI_NFC_BASE + NFC_ADDR_LOW);
        writel((page >> 16) & 0xFF, SUNXI_NFC_BASE + NFC_ADDR_HIGH);
+       writel(NFC_ST_DMA_INT_FLAG, SUNXI_NFC_BASE + NFC_ST);
        writel(NFC_SEND_CMD1 | NFC_SEND_CMD2 | NFC_DATA_TRANS |
                NFC_PAGE_CMD | NFC_WAIT_FLAG |
                ((addr_cycles - 1) << NFC_ADDR_NUM_OFFSET) |
                NFC_SEND_ADR | NFC_DATA_SWAP_METHOD | (syndrome ? NFC_SEQ : 0),
                SUNXI_NFC_BASE + NFC_CMD);
 
-       if (!check_value(SUNXI_NFC_BASE + NFC_ST, (1 << 2),
+       if (!check_value(SUNXI_NFC_BASE + NFC_ST, NFC_ST_DMA_INT_FLAG,
                         MAX_RETRIES)) {
                printf("Error while initializing dma interrupt\n");
                return -1;
        }
+       writel(NFC_ST_DMA_INT_FLAG, SUNXI_NFC_BASE + NFC_ST);
 
        if (!check_value_negated(SUNXI_DMA_BASE + SUNXI_DMA_CFG_REG0,
                                 SUNXI_DMA_DDMA_CFG_REG_LOADING, MAX_RETRIES)) {
@@ -307,15 +312,85 @@ static int nand_read_ecc(int page_size, int ecc_strength, int ecc_page_size,
 static int nand_read_buffer(uint32_t offs, unsigned int size, void *dest,
                            int syndrome)
 {
-       return nand_read_ecc(CONFIG_NAND_SUNXI_SPL_PAGE_SIZE,
-                            CONFIG_NAND_SUNXI_SPL_ECC_STRENGTH,
-                            CONFIG_NAND_SUNXI_SPL_ECC_PAGE_SIZE,
-                            5, offs, size, dest, syndrome);
+       const struct {
+               int page_size;
+               int ecc_strength;
+               int ecc_page_size;
+               int addr_cycles;
+       } nand_configs[] = {
+               {  8192, 40, 1024, 5 },
+               { 16384, 56, 1024, 5 },
+               {  8192, 24, 1024, 5 },
+               {  4096, 24, 1024, 5 },
+       };
+       static int nand_config = -1;
+       int i;
+
+       if (nand_config == -1) {
+               for (i = 0; i < ARRAY_SIZE(nand_configs); i++) {
+                       debug("nand: trying page %d ecc %d / %d addr %d: ",
+                             nand_configs[i].page_size,
+                             nand_configs[i].ecc_strength,
+                             nand_configs[i].ecc_page_size,
+                             nand_configs[i].addr_cycles);
+                       if (nand_read_ecc(nand_configs[i].page_size,
+                                         nand_configs[i].ecc_strength,
+                                         nand_configs[i].ecc_page_size,
+                                         nand_configs[i].addr_cycles,
+                                         offs, size, dest, syndrome) == 0) {
+                               debug("success\n");
+                               nand_config = i;
+                               return 0;
+                       }
+                       debug("failed\n");
+               }
+               return -1;
+       }
+
+       return nand_read_ecc(nand_configs[nand_config].page_size,
+                            nand_configs[nand_config].ecc_strength,
+                            nand_configs[nand_config].ecc_page_size,
+                            nand_configs[nand_config].addr_cycles,
+                            offs, size, dest, syndrome);
 }
 
 int nand_spl_load_image(uint32_t offs, unsigned int size, void *dest)
 {
-       int syndrome = offs < CONFIG_NAND_SUNXI_SPL_SYNDROME_PARTITIONS_END;
+#if CONFIG_SYS_NAND_U_BOOT_OFFS == CONFIG_SPL_PAD_TO
+       /*
+        * u-boot-dtb.bin appended to SPL, use syndrome (like the BROM does)
+        * and try different erase block sizes to find the backup.
+        */
+       const uint32_t boot_offsets[] = {
+               0 * 1024 * 1024 + CONFIG_SYS_NAND_U_BOOT_OFFS,
+               1 * 1024 * 1024 + CONFIG_SYS_NAND_U_BOOT_OFFS,
+               2 * 1024 * 1024 + CONFIG_SYS_NAND_U_BOOT_OFFS,
+               4 * 1024 * 1024 + CONFIG_SYS_NAND_U_BOOT_OFFS,
+       };
+       const int syndrome = 1;
+#else
+       /*
+        * u-boot-dtb.bin on its own partition, do not use syndrome, u-boot
+        * partition sits after 2 eraseblocks (spl, spl-backup), look for
+        * backup u-boot 1 erase block further.
+        */
+       const uint32_t eraseblock_size = CONFIG_SYS_NAND_U_BOOT_OFFS / 2;
+       const uint32_t boot_offsets[] = {
+               CONFIG_SYS_NAND_U_BOOT_OFFS,
+               CONFIG_SYS_NAND_U_BOOT_OFFS + eraseblock_size,
+       };
+       const int syndrome = 0;
+#endif
+       int i;
+
+       if (offs == CONFIG_SYS_NAND_U_BOOT_OFFS) {
+               for (i = 0; i < ARRAY_SIZE(boot_offsets); i++) {
+                       if (nand_read_buffer(boot_offsets[i], size,
+                                            dest, syndrome) == 0)
+                               return 0;
+               }
+               return -1;
+       }
 
        return nand_read_buffer(offs, size, dest, syndrome);
 }