]>
git.ipfire.org Git - thirdparty/u-boot.git/blob - drivers/mtd/nand/raw/mxs_nand_spl.c
ae50cc37b52fb145d99ea7a0df9f3b9709207532
1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2014 Gateworks Corporation
5 * Author: Tim Harvey <tharvey@gateworks.com>
11 #include <linux/err.h>
13 static struct mtd_info
*mtd
;
14 static struct nand_chip nand_chip
;
16 static void mxs_nand_command(struct mtd_info
*mtd
, unsigned int command
,
17 int column
, int page_addr
)
19 register struct nand_chip
*chip
= mtd_to_nand(mtd
);
20 u32 timeo
, time_start
;
22 /* write out the command to the device */
23 chip
->cmd_ctrl(mtd
, command
, NAND_CLE
);
25 /* Serially input address */
27 chip
->cmd_ctrl(mtd
, column
, NAND_ALE
);
28 chip
->cmd_ctrl(mtd
, column
>> 8, NAND_ALE
);
30 if (page_addr
!= -1) {
31 chip
->cmd_ctrl(mtd
, page_addr
, NAND_ALE
);
32 chip
->cmd_ctrl(mtd
, page_addr
>> 8, NAND_ALE
);
33 /* One more address cycle for devices > 128MiB */
34 if (chip
->chipsize
> (128 << 20))
35 chip
->cmd_ctrl(mtd
, page_addr
>> 16, NAND_ALE
);
37 chip
->cmd_ctrl(mtd
, NAND_CMD_NONE
, 0);
39 if (command
== NAND_CMD_READ0
) {
40 chip
->cmd_ctrl(mtd
, NAND_CMD_READSTART
, NAND_CLE
);
41 chip
->cmd_ctrl(mtd
, NAND_CMD_NONE
, 0);
42 } else if (command
== NAND_CMD_RNDOUT
) {
43 /* No ready / busy check necessary */
44 chip
->cmd_ctrl(mtd
, NAND_CMD_RNDOUTSTART
,
46 chip
->cmd_ctrl(mtd
, NAND_CMD_NONE
,
50 /* wait for nand ready */
52 timeo
= (CONFIG_SYS_HZ
* 20) / 1000;
53 time_start
= get_timer(0);
54 while (get_timer(time_start
) < timeo
) {
55 if (chip
->dev_ready(mtd
))
60 #if defined (CONFIG_SPL_NAND_IDENT)
62 /* Trying to detect the NAND flash using ONFi, JEDEC, and (extended) IDs */
63 static int mxs_flash_full_ident(struct mtd_info
*mtd
)
65 int nand_maf_id
, nand_dev_id
;
66 struct nand_chip
*chip
= mtd_to_nand(mtd
);
67 struct nand_flash_dev
*type
;
69 type
= nand_get_flash_type(mtd
, chip
, &nand_maf_id
, &nand_dev_id
, NULL
);
72 chip
->select_chip(mtd
, -1);
81 /* Trying to detect the NAND flash using ONFi only */
82 static int mxs_flash_onfi_ident(struct mtd_info
*mtd
)
84 register struct nand_chip
*chip
= mtd_to_nand(mtd
);
88 struct nand_onfi_params
*p
= &chip
->onfi_params
;
91 chip
->cmdfunc(mtd
, NAND_CMD_RESET
, -1, -1);
93 /* Send the command for reading device ID */
94 chip
->cmdfunc(mtd
, NAND_CMD_READID
, 0x00, -1);
96 /* Read manufacturer and device IDs */
97 mfg_id
= chip
->read_byte(mtd
);
98 dev_id
= chip
->read_byte(mtd
);
100 /* Try again to make sure */
101 chip
->cmdfunc(mtd
, NAND_CMD_READID
, 0x00, -1);
102 for (i
= 0; i
< 8; i
++)
103 id_data
[i
] = chip
->read_byte(mtd
);
104 if (id_data
[0] != mfg_id
|| id_data
[1] != dev_id
) {
105 printf("second ID read did not match");
108 debug("0x%02x:0x%02x ", mfg_id
, dev_id
);
111 chip
->onfi_version
= 0;
112 chip
->cmdfunc(mtd
, NAND_CMD_READID
, 0x20, -1);
113 if (chip
->read_byte(mtd
) != 'O' || chip
->read_byte(mtd
) != 'N' ||
114 chip
->read_byte(mtd
) != 'F' || chip
->read_byte(mtd
) != 'I') {
118 /* we have ONFI, probe it */
119 chip
->cmdfunc(mtd
, NAND_CMD_PARAM
, 0, -1);
120 chip
->read_buf(mtd
, (uint8_t *)p
, sizeof(*p
));
121 mtd
->name
= p
->model
;
122 mtd
->writesize
= le32_to_cpu(p
->byte_per_page
);
123 mtd
->erasesize
= le32_to_cpu(p
->pages_per_block
) * mtd
->writesize
;
124 mtd
->oobsize
= le16_to_cpu(p
->spare_bytes_per_page
);
125 chip
->chipsize
= le32_to_cpu(p
->blocks_per_lun
);
126 chip
->chipsize
*= (uint64_t)mtd
->erasesize
* p
->lun_count
;
127 /* Calculate the address shift from the page size */
128 chip
->page_shift
= ffs(mtd
->writesize
) - 1;
129 chip
->phys_erase_shift
= ffs(mtd
->erasesize
) - 1;
130 /* Convert chipsize to number of pages per chip -1 */
131 chip
->pagemask
= (chip
->chipsize
>> chip
->page_shift
) - 1;
132 chip
->badblockbits
= 8;
134 debug("erasesize=%d (>>%d)\n", mtd
->erasesize
, chip
->phys_erase_shift
);
135 debug("writesize=%d (>>%d)\n", mtd
->writesize
, chip
->page_shift
);
136 debug("oobsize=%d\n", mtd
->oobsize
);
137 debug("chipsize=%lld\n", chip
->chipsize
);
142 #endif /* CONFIG_SPL_NAND_IDENT */
144 static int mxs_flash_ident(struct mtd_info
*mtd
)
147 #if defined (CONFIG_SPL_NAND_IDENT)
148 ret
= mxs_flash_full_ident(mtd
);
150 ret
= mxs_flash_onfi_ident(mtd
);
155 static int mxs_read_page_ecc(struct mtd_info
*mtd
, void *buf
, unsigned int page
)
157 register struct nand_chip
*chip
= mtd_to_nand(mtd
);
160 chip
->cmdfunc(mtd
, NAND_CMD_READ0
, 0x0, page
);
161 ret
= nand_chip
.ecc
.read_page(mtd
, chip
, buf
, 1, page
);
163 printf("read_page failed %d\n", ret
);
169 static int is_badblock(struct mtd_info
*mtd
, loff_t offs
, int allowbbt
)
171 register struct nand_chip
*chip
= mtd_to_nand(mtd
);
172 unsigned int block
= offs
>> chip
->phys_erase_shift
;
173 unsigned int page
= offs
>> chip
->page_shift
;
175 debug("%s offs=0x%08x block:%d page:%d\n", __func__
, (int)offs
, block
,
177 chip
->cmdfunc(mtd
, NAND_CMD_READ0
, mtd
->writesize
, page
);
178 memset(chip
->oob_poi
, 0, mtd
->oobsize
);
179 chip
->read_buf(mtd
, chip
->oob_poi
, mtd
->oobsize
);
181 return chip
->oob_poi
[0] != 0xff;
184 /* setup mtd and nand structs and init mxs_nand driver */
187 /* return if already initalized */
188 if (nand_chip
.numchips
)
191 /* init mxs nand driver */
192 mxs_nand_init_spl(&nand_chip
);
193 mtd
= nand_to_mtd(&nand_chip
);
194 /* set mtd functions */
195 nand_chip
.cmdfunc
= mxs_nand_command
;
196 nand_chip
.scan_bbt
= nand_default_bbt
;
197 nand_chip
.numchips
= 1;
199 /* identify flash device */
200 if (mxs_flash_ident(mtd
)) {
201 printf("Failed to identify\n");
202 nand_chip
.numchips
= 0; /* If fail, don't use nand */
206 /* allocate and initialize buffers */
207 nand_chip
.buffers
= memalign(ARCH_DMA_MINALIGN
,
208 sizeof(*nand_chip
.buffers
));
209 nand_chip
.oob_poi
= nand_chip
.buffers
->databuf
+ mtd
->writesize
;
210 /* setup flash layout (does not scan as we override that) */
211 mtd
->size
= nand_chip
.chipsize
;
212 nand_chip
.scan_bbt(mtd
);
213 mxs_nand_setup_ecc(mtd
);
216 int nand_spl_load_image(uint32_t offs
, unsigned int size
, void *buf
)
218 struct nand_chip
*chip
;
220 unsigned int nand_page_per_block
;
225 chip
= mtd_to_nand(mtd
);
229 page_buf
= malloc(mtd
->writesize
);
233 page
= offs
>> chip
->page_shift
;
234 page_off
= offs
& (mtd
->writesize
- 1);
235 nand_page_per_block
= mtd
->erasesize
/ mtd
->writesize
;
237 debug("%s offset:0x%08x len:%d page:%x\n", __func__
, offs
, size
, page
);
240 if (mxs_read_page_ecc(mtd
, page_buf
, page
) < 0)
243 if (size
> (mtd
->writesize
- page_off
))
244 sz
= (mtd
->writesize
- page_off
);
248 memcpy(buf
, page_buf
+ page_off
, sz
);
250 offs
+= mtd
->writesize
;
252 buf
+= (mtd
->writesize
- page_off
);
257 * Check if we have crossed a block boundary, and if so
258 * check for bad block.
260 if (!(page
% nand_page_per_block
)) {
262 * Yes, new block. See if this block is good. If not,
263 * loop until we find a good block.
265 while (is_badblock(mtd
, offs
, 1)) {
266 page
= page
+ nand_page_per_block
;
267 /* Check i we've reached the end of flash. */
268 if (page
>= mtd
->size
>> chip
->page_shift
) {
281 int nand_default_bbt(struct mtd_info
*mtd
)
286 void nand_deselect(void)