git.sur5r.net Git - u-boot/blob - drivers/mtd/onenand/onenand_spl.c

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