]>
git.ipfire.org Git - people/ms/u-boot.git/blob - drivers/mtd/nand/mxs_nand_spl.c
2 * Copyright (C) 2014 Gateworks Corporation
3 * Author: Tim Harvey <tharvey@gateworks.com>
5 * SPDX-License-Identifier: GPL-2.0+
11 static struct mtd_info
*mtd
;
12 static struct nand_chip nand_chip
;
14 static void mxs_nand_command(struct mtd_info
*mtd
, unsigned int command
,
15 int column
, int page_addr
)
17 register struct nand_chip
*chip
= mtd_to_nand(mtd
);
18 u32 timeo
, time_start
;
20 /* write out the command to the device */
21 chip
->cmd_ctrl(mtd
, command
, NAND_CLE
);
23 /* Serially input address */
25 chip
->cmd_ctrl(mtd
, column
, NAND_ALE
);
26 chip
->cmd_ctrl(mtd
, column
>> 8, NAND_ALE
);
28 if (page_addr
!= -1) {
29 chip
->cmd_ctrl(mtd
, page_addr
, NAND_ALE
);
30 chip
->cmd_ctrl(mtd
, page_addr
>> 8, NAND_ALE
);
31 /* One more address cycle for devices > 128MiB */
32 if (chip
->chipsize
> (128 << 20))
33 chip
->cmd_ctrl(mtd
, page_addr
>> 16, NAND_ALE
);
35 chip
->cmd_ctrl(mtd
, NAND_CMD_NONE
, 0);
37 if (command
== NAND_CMD_READ0
) {
38 chip
->cmd_ctrl(mtd
, NAND_CMD_READSTART
, NAND_CLE
);
39 chip
->cmd_ctrl(mtd
, NAND_CMD_NONE
, 0);
42 /* wait for nand ready */
44 timeo
= (CONFIG_SYS_HZ
* 20) / 1000;
45 time_start
= get_timer(0);
46 while (get_timer(time_start
) < timeo
) {
47 if (chip
->dev_ready(mtd
))
52 static int mxs_flash_ident(struct mtd_info
*mtd
)
54 register struct nand_chip
*chip
= mtd_to_nand(mtd
);
58 struct nand_onfi_params
*p
= &chip
->onfi_params
;
61 chip
->cmdfunc(mtd
, NAND_CMD_RESET
, -1, -1);
63 /* Send the command for reading device ID */
64 chip
->cmdfunc(mtd
, NAND_CMD_READID
, 0x00, -1);
66 /* Read manufacturer and device IDs */
67 mfg_id
= chip
->read_byte(mtd
);
68 dev_id
= chip
->read_byte(mtd
);
70 /* Try again to make sure */
71 chip
->cmdfunc(mtd
, NAND_CMD_READID
, 0x00, -1);
72 for (i
= 0; i
< 8; i
++)
73 id_data
[i
] = chip
->read_byte(mtd
);
74 if (id_data
[0] != mfg_id
|| id_data
[1] != dev_id
) {
75 printf("second ID read did not match");
78 debug("0x%02x:0x%02x ", mfg_id
, dev_id
);
81 chip
->onfi_version
= 0;
82 chip
->cmdfunc(mtd
, NAND_CMD_READID
, 0x20, -1);
83 if (chip
->read_byte(mtd
) != 'O' || chip
->read_byte(mtd
) != 'N' ||
84 chip
->read_byte(mtd
) != 'F' || chip
->read_byte(mtd
) != 'I') {
88 /* we have ONFI, probe it */
89 chip
->cmdfunc(mtd
, NAND_CMD_PARAM
, 0, -1);
90 chip
->read_buf(mtd
, (uint8_t *)p
, sizeof(*p
));
92 mtd
->writesize
= le32_to_cpu(p
->byte_per_page
);
93 mtd
->erasesize
= le32_to_cpu(p
->pages_per_block
) * mtd
->writesize
;
94 mtd
->oobsize
= le16_to_cpu(p
->spare_bytes_per_page
);
95 chip
->chipsize
= le32_to_cpu(p
->blocks_per_lun
);
96 chip
->chipsize
*= (uint64_t)mtd
->erasesize
* p
->lun_count
;
97 /* Calculate the address shift from the page size */
98 chip
->page_shift
= ffs(mtd
->writesize
) - 1;
99 chip
->phys_erase_shift
= ffs(mtd
->erasesize
) - 1;
100 /* Convert chipsize to number of pages per chip -1 */
101 chip
->pagemask
= (chip
->chipsize
>> chip
->page_shift
) - 1;
102 chip
->badblockbits
= 8;
104 debug("erasesize=%d (>>%d)\n", mtd
->erasesize
, chip
->phys_erase_shift
);
105 debug("writesize=%d (>>%d)\n", mtd
->writesize
, chip
->page_shift
);
106 debug("oobsize=%d\n", mtd
->oobsize
);
107 debug("chipsize=%lld\n", chip
->chipsize
);
112 static int mxs_read_page_ecc(struct mtd_info
*mtd
, void *buf
, unsigned int page
)
114 register struct nand_chip
*chip
= mtd_to_nand(mtd
);
117 chip
->cmdfunc(mtd
, NAND_CMD_READ0
, 0x0, page
);
118 ret
= nand_chip
.ecc
.read_page(mtd
, chip
, buf
, 1, page
);
120 printf("read_page failed %d\n", ret
);
126 static int is_badblock(struct mtd_info
*mtd
, loff_t offs
, int allowbbt
)
128 register struct nand_chip
*chip
= mtd_to_nand(mtd
);
129 unsigned int block
= offs
>> chip
->phys_erase_shift
;
130 unsigned int page
= offs
>> chip
->page_shift
;
132 debug("%s offs=0x%08x block:%d page:%d\n", __func__
, (int)offs
, block
,
134 chip
->cmdfunc(mtd
, NAND_CMD_READ0
, mtd
->writesize
, page
);
135 memset(chip
->oob_poi
, 0, mtd
->oobsize
);
136 chip
->read_buf(mtd
, chip
->oob_poi
, mtd
->oobsize
);
138 return chip
->oob_poi
[0] != 0xff;
141 /* setup mtd and nand structs and init mxs_nand driver */
142 static int mxs_nand_init(void)
144 /* return if already initalized */
145 if (nand_chip
.numchips
)
148 /* init mxs nand driver */
149 board_nand_init(&nand_chip
);
150 mtd
= nand_to_mtd(&nand_chip
);
151 /* set mtd functions */
152 nand_chip
.cmdfunc
= mxs_nand_command
;
153 nand_chip
.numchips
= 1;
155 /* identify flash device */
157 if (mxs_flash_ident(mtd
)) {
158 printf("Failed to identify\n");
162 /* allocate and initialize buffers */
163 nand_chip
.buffers
= memalign(ARCH_DMA_MINALIGN
,
164 sizeof(*nand_chip
.buffers
));
165 nand_chip
.oob_poi
= nand_chip
.buffers
->databuf
+ mtd
->writesize
;
166 /* setup flash layout (does not scan as we override that) */
167 mtd
->size
= nand_chip
.chipsize
;
168 nand_chip
.scan_bbt(mtd
);
170 printf("%llu MiB\n", (mtd
->size
/ (1024 * 1024)));
174 int nand_spl_load_image(uint32_t offs
, unsigned int size
, void *buf
)
176 struct nand_chip
*chip
;
178 unsigned int nand_page_per_block
;
183 chip
= mtd_to_nand(mtd
);
184 page
= offs
>> chip
->page_shift
;
185 nand_page_per_block
= mtd
->erasesize
/ mtd
->writesize
;
187 debug("%s offset:0x%08x len:%d page:%d\n", __func__
, offs
, size
, page
);
189 size
= roundup(size
, mtd
->writesize
);
191 if (mxs_read_page_ecc(mtd
, buf
, page
) < 0)
193 sz
+= mtd
->writesize
;
194 offs
+= mtd
->writesize
;
196 buf
+= mtd
->writesize
;
199 * Check if we have crossed a block boundary, and if so
200 * check for bad block.
202 if (!(page
% nand_page_per_block
)) {
204 * Yes, new block. See if this block is good. If not,
205 * loop until we find a good block.
207 while (is_badblock(mtd
, offs
, 1)) {
208 page
= page
+ nand_page_per_block
;
209 /* Check i we've reached the end of flash. */
210 if (page
>= mtd
->size
>> chip
->page_shift
)
219 int nand_default_bbt(struct mtd_info
*mtd
)
228 void nand_deselect(void)