onenand_spl.c 4.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2011 Marek Vasut <marek.vasut@gmail.com>
  4. *
  5. * Based on code:
  6. * Copyright (C) 2005-2009 Samsung Electronics
  7. * Kyungmin Park <kyungmin.park@samsung.com>
  8. */
  9. #include <common.h>
  10. #include <asm/io.h>
  11. #include <linux/bitops.h>
  12. #include <linux/mtd/onenand_regs.h>
  13. #include <onenand_uboot.h>
  14. /*
  15. * Device geometry:
  16. * - 2048b page, 128k erase block.
  17. * - 4096b page, 256k erase block.
  18. */
  19. enum onenand_spl_pagesize {
  20. PAGE_2K = 2048,
  21. PAGE_4K = 4096,
  22. };
  23. static unsigned int density_mask;
  24. #define ONENAND_PAGES_PER_BLOCK 64
  25. #define onenand_sector_address(page) (page << 2)
  26. #define onenand_buffer_address() ((1 << 3) << 8)
  27. static inline int onenand_block_address(int block)
  28. {
  29. /* Device Flash Core select, NAND Flash Block Address */
  30. if (block & density_mask)
  31. return ONENAND_DDP_CHIP1 | (block ^ density_mask);
  32. return block;
  33. }
  34. static inline int onenand_bufferram_address(int block)
  35. {
  36. /* Device BufferRAM Select */
  37. if (block & density_mask)
  38. return ONENAND_DDP_CHIP1;
  39. return ONENAND_DDP_CHIP0;
  40. }
  41. static inline uint16_t onenand_readw(uint32_t addr)
  42. {
  43. return readw(CONFIG_SYS_ONENAND_BASE + addr);
  44. }
  45. static inline void onenand_writew(uint16_t value, uint32_t addr)
  46. {
  47. writew(value, CONFIG_SYS_ONENAND_BASE + addr);
  48. }
  49. static enum onenand_spl_pagesize onenand_spl_get_geometry(void)
  50. {
  51. unsigned int dev_id, density, size;
  52. if (!onenand_readw(ONENAND_REG_TECHNOLOGY)) {
  53. dev_id = onenand_readw(ONENAND_REG_DEVICE_ID);
  54. density = dev_id >> ONENAND_DEVICE_DENSITY_SHIFT;
  55. density &= ONENAND_DEVICE_DENSITY_MASK;
  56. if (density < ONENAND_DEVICE_DENSITY_4Gb)
  57. return PAGE_2K;
  58. if (dev_id & ONENAND_DEVICE_IS_DDP) {
  59. size = onenand_readw(ONENAND_REG_DATA_BUFFER_SIZE);
  60. density_mask = 1 << (18 + density - ffs(size));
  61. return PAGE_2K;
  62. }
  63. }
  64. return PAGE_4K;
  65. }
  66. static int onenand_spl_read_page(uint32_t block, uint32_t page, uint32_t *buf,
  67. enum onenand_spl_pagesize pagesize)
  68. {
  69. const uint32_t addr = CONFIG_SYS_ONENAND_BASE + ONENAND_DATARAM;
  70. uint32_t offset;
  71. onenand_writew(onenand_block_address(block),
  72. ONENAND_REG_START_ADDRESS1);
  73. onenand_writew(onenand_bufferram_address(block),
  74. ONENAND_REG_START_ADDRESS2);
  75. onenand_writew(onenand_sector_address(page),
  76. ONENAND_REG_START_ADDRESS8);
  77. onenand_writew(onenand_buffer_address(),
  78. ONENAND_REG_START_BUFFER);
  79. onenand_writew(ONENAND_INT_CLEAR, ONENAND_REG_INTERRUPT);
  80. onenand_writew(ONENAND_CMD_READ, ONENAND_REG_COMMAND);
  81. while (!(onenand_readw(ONENAND_REG_INTERRUPT) & ONENAND_INT_READ))
  82. continue;
  83. /* Check for invalid block mark */
  84. if (page < 2 && (onenand_readw(ONENAND_SPARERAM) != 0xffff))
  85. return 1;
  86. for (offset = 0; offset < pagesize; offset += 4)
  87. buf[offset / 4] = readl(addr + offset);
  88. return 0;
  89. }
  90. #ifdef CONFIG_SPL_UBI
  91. /* Temporary storage for non page aligned and non page sized reads. */
  92. static u8 scratch_buf[PAGE_4K];
  93. /**
  94. * onenand_spl_read_block - Read data from physical eraseblock into a buffer
  95. * @block: Number of the physical eraseblock
  96. * @offset: Data offset from the start of @peb
  97. * @len: Data size to read
  98. * @dst: Address of the destination buffer
  99. *
  100. * Notes:
  101. * @offset + @len are not allowed to be larger than a physical
  102. * erase block. No sanity check done for simplicity reasons.
  103. */
  104. int onenand_spl_read_block(int block, int offset, int len, void *dst)
  105. {
  106. int page, read;
  107. static int psize;
  108. if (!psize)
  109. psize = onenand_spl_get_geometry();
  110. /* Calculate the page number */
  111. page = offset / psize;
  112. /* Offset to the start of a flash page */
  113. offset = offset % psize;
  114. while (len) {
  115. /*
  116. * Non page aligned reads go to the scratch buffer.
  117. * Page aligned reads go directly to the destination.
  118. */
  119. if (offset || len < psize) {
  120. onenand_spl_read_page(block, page,
  121. (uint32_t *)scratch_buf, psize);
  122. read = min(len, psize - offset);
  123. memcpy(dst, scratch_buf + offset, read);
  124. offset = 0;
  125. } else {
  126. onenand_spl_read_page(block, page, dst, psize);
  127. read = psize;
  128. }
  129. page++;
  130. len -= read;
  131. dst += read;
  132. }
  133. return 0;
  134. }
  135. #endif
  136. void onenand_spl_load_image(uint32_t offs, uint32_t size, void *dst)
  137. {
  138. uint32_t *addr = (uint32_t *)dst;
  139. uint32_t to_page;
  140. uint32_t block;
  141. uint32_t page, rpage;
  142. enum onenand_spl_pagesize pagesize;
  143. int ret;
  144. pagesize = onenand_spl_get_geometry();
  145. /*
  146. * The page can be either 2k or 4k, avoid using DIV_ROUND_UP to avoid
  147. * pulling further unwanted functions into the SPL.
  148. */
  149. if (pagesize == 2048) {
  150. page = offs / 2048;
  151. to_page = page + DIV_ROUND_UP(size, 2048);
  152. } else {
  153. page = offs / 4096;
  154. to_page = page + DIV_ROUND_UP(size, 4096);
  155. }
  156. for (; page <= to_page; page++) {
  157. block = page / ONENAND_PAGES_PER_BLOCK;
  158. rpage = page & (ONENAND_PAGES_PER_BLOCK - 1);
  159. ret = onenand_spl_read_page(block, rpage, addr, pagesize);
  160. if (ret)
  161. page += ONENAND_PAGES_PER_BLOCK - 1;
  162. else
  163. addr += pagesize / 4;
  164. }
  165. }