denali_spl.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229
  1. /*
  2. * Copyright (C) 2014 Panasonic Corporation
  3. * Copyright (C) 2014-2015 Masahiro Yamada <yamada.masahiro@socionext.com>
  4. *
  5. * SPDX-License-Identifier: GPL-2.0+
  6. */
  7. #include <common.h>
  8. #include <asm/io.h>
  9. #include <asm/unaligned.h>
  10. #include <linux/mtd/rawnand.h>
  11. #include "denali.h"
  12. #define DENALI_MAP01 (1 << 26) /* read/write pages in PIO */
  13. #define DENALI_MAP10 (2 << 26) /* high-level control plane */
  14. #define INDEX_CTRL_REG 0x0
  15. #define INDEX_DATA_REG 0x10
  16. #define SPARE_ACCESS 0x41
  17. #define MAIN_ACCESS 0x42
  18. #define PIPELINE_ACCESS 0x2000
  19. #define BANK(x) ((x) << 24)
  20. static void __iomem *denali_flash_mem =
  21. (void __iomem *)CONFIG_SYS_NAND_DATA_BASE;
  22. static void __iomem *denali_flash_reg =
  23. (void __iomem *)CONFIG_SYS_NAND_REGS_BASE;
  24. static const int flash_bank;
  25. static int page_size, oob_size, pages_per_block;
  26. static void index_addr(uint32_t address, uint32_t data)
  27. {
  28. writel(address, denali_flash_mem + INDEX_CTRL_REG);
  29. writel(data, denali_flash_mem + INDEX_DATA_REG);
  30. }
  31. static int wait_for_irq(uint32_t irq_mask)
  32. {
  33. unsigned long timeout = 1000000;
  34. uint32_t intr_status;
  35. do {
  36. intr_status = readl(denali_flash_reg + INTR_STATUS(flash_bank));
  37. if (intr_status & INTR__ECC_UNCOR_ERR) {
  38. debug("Uncorrected ECC detected\n");
  39. return -EBADMSG;
  40. }
  41. if (intr_status & irq_mask)
  42. break;
  43. udelay(1);
  44. timeout--;
  45. } while (timeout);
  46. if (!timeout) {
  47. debug("Timeout with interrupt status %08x\n", intr_status);
  48. return -EIO;
  49. }
  50. return 0;
  51. }
  52. static void read_data_from_flash_mem(uint8_t *buf, int len)
  53. {
  54. int i;
  55. uint32_t *buf32;
  56. /* transfer the data from the flash */
  57. buf32 = (uint32_t *)buf;
  58. /*
  59. * Let's take care of unaligned access although it rarely happens.
  60. * Avoid put_unaligned() for the normal use cases since it leads to
  61. * a bit performance regression.
  62. */
  63. if ((unsigned long)buf32 % 4) {
  64. for (i = 0; i < len / 4; i++)
  65. put_unaligned(readl(denali_flash_mem + INDEX_DATA_REG),
  66. buf32++);
  67. } else {
  68. for (i = 0; i < len / 4; i++)
  69. *buf32++ = readl(denali_flash_mem + INDEX_DATA_REG);
  70. }
  71. if (len % 4) {
  72. u32 tmp;
  73. tmp = cpu_to_le32(readl(denali_flash_mem + INDEX_DATA_REG));
  74. buf = (uint8_t *)buf32;
  75. for (i = 0; i < len % 4; i++) {
  76. *buf++ = tmp;
  77. tmp >>= 8;
  78. }
  79. }
  80. }
  81. int denali_send_pipeline_cmd(int page, int ecc_en, int access_type)
  82. {
  83. uint32_t addr, cmd;
  84. static uint32_t page_count = 1;
  85. writel(ecc_en, denali_flash_reg + ECC_ENABLE);
  86. /* clear all bits of intr_status. */
  87. writel(0xffff, denali_flash_reg + INTR_STATUS(flash_bank));
  88. addr = BANK(flash_bank) | page;
  89. /* setup the acccess type */
  90. cmd = DENALI_MAP10 | addr;
  91. index_addr(cmd, access_type);
  92. /* setup the pipeline command */
  93. index_addr(cmd, PIPELINE_ACCESS | page_count);
  94. cmd = DENALI_MAP01 | addr;
  95. writel(cmd, denali_flash_mem + INDEX_CTRL_REG);
  96. return wait_for_irq(INTR__LOAD_COMP);
  97. }
  98. static int nand_read_oob(void *buf, int page)
  99. {
  100. int ret;
  101. ret = denali_send_pipeline_cmd(page, 0, SPARE_ACCESS);
  102. if (ret < 0)
  103. return ret;
  104. read_data_from_flash_mem(buf, oob_size);
  105. return 0;
  106. }
  107. static int nand_read_page(void *buf, int page)
  108. {
  109. int ret;
  110. ret = denali_send_pipeline_cmd(page, 1, MAIN_ACCESS);
  111. if (ret < 0)
  112. return ret;
  113. read_data_from_flash_mem(buf, page_size);
  114. return 0;
  115. }
  116. static int nand_block_isbad(void *buf, int block)
  117. {
  118. int ret;
  119. ret = nand_read_oob(buf, block * pages_per_block);
  120. if (ret < 0)
  121. return ret;
  122. return *((uint8_t *)buf + CONFIG_SYS_NAND_BAD_BLOCK_POS) != 0xff;
  123. }
  124. /* nand_init() - initialize data to make nand usable by SPL */
  125. void nand_init(void)
  126. {
  127. /* access to main area */
  128. writel(0, denali_flash_reg + TRANSFER_SPARE_REG);
  129. /*
  130. * These registers are expected to be already set by the hardware
  131. * or earlier boot code. So we read these values out.
  132. */
  133. page_size = readl(denali_flash_reg + DEVICE_MAIN_AREA_SIZE);
  134. oob_size = readl(denali_flash_reg + DEVICE_SPARE_AREA_SIZE);
  135. pages_per_block = readl(denali_flash_reg + PAGES_PER_BLOCK);
  136. }
  137. int nand_spl_load_image(uint32_t offs, unsigned int size, void *dst)
  138. {
  139. int block, page, column, readlen;
  140. int ret;
  141. int force_bad_block_check = 1;
  142. page = offs / page_size;
  143. column = offs % page_size;
  144. block = page / pages_per_block;
  145. page = page % pages_per_block;
  146. while (size) {
  147. if (force_bad_block_check || page == 0) {
  148. ret = nand_block_isbad(dst, block);
  149. if (ret < 0)
  150. return ret;
  151. if (ret) {
  152. block++;
  153. continue;
  154. }
  155. }
  156. force_bad_block_check = 0;
  157. ret = nand_read_page(dst, block * pages_per_block + page);
  158. if (ret < 0)
  159. return ret;
  160. readlen = min(page_size - column, (int)size);
  161. if (unlikely(column)) {
  162. /* Partial page read */
  163. memmove(dst, dst + column, readlen);
  164. column = 0;
  165. }
  166. size -= readlen;
  167. dst += readlen;
  168. page++;
  169. if (page == pages_per_block) {
  170. block++;
  171. page = 0;
  172. }
  173. }
  174. return 0;
  175. }
  176. void nand_deselect(void) {}