1 /***************************************************************************
2 * Copyright (C) 2007 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Partially based on drivers/mtd/nand_ids.c from Linux. *
6 * Copyright (C) 2002 Thomas Gleixner <tglx@linutronix.de> *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
27 #include "replacements.h"
38 #include "time_support.h"
42 int nand_register_commands(struct command_context_s
*cmd_ctx
);
43 int handle_nand_list_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
44 int handle_nand_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
45 int handle_nand_check_bad_blocks_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
46 int handle_nand_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
47 int handle_nand_copy_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
48 int handle_nand_write_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
49 int handle_nand_dump_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
50 int handle_nand_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_nand_raw_access_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int nand_read_page_raw(struct nand_device_s
*device
, u32 page
, u8
*data
, u32 data_size
, u8
*oob
, u32 oob_size
);
55 int nand_read_page(struct nand_device_s
*device
, u32 page
, u8
*data
, u32 data_size
, u8
*oob
, u32 oob_size
);
56 int nand_read_plain(struct nand_device_s
*device
, u32 address
, u8
*data
, u32 data_size
);
58 int nand_write_page_raw(struct nand_device_s
*device
, u32 page
, u8
*data
, u32 data_size
, u8
*oob
, u32 oob_size
);
59 int nand_write_page(struct nand_device_s
*device
, u32 page
, u8
*data
, u32 data_size
, u8
*oob
, u32 oob_size
);
61 /* NAND flash controller
63 extern nand_flash_controller_t lpc3180_nand_controller
;
64 extern nand_flash_controller_t orion_nand_controller
;
65 extern nand_flash_controller_t s3c2410_nand_controller
;
66 extern nand_flash_controller_t s3c2412_nand_controller
;
67 extern nand_flash_controller_t s3c2440_nand_controller
;
68 extern nand_flash_controller_t s3c2443_nand_controller
;
70 /* extern nand_flash_controller_t boundary_scan_nand_controller; */
72 nand_flash_controller_t
*nand_flash_controllers
[] =
74 &lpc3180_nand_controller
,
75 &orion_nand_controller
,
76 &s3c2410_nand_controller
,
77 &s3c2412_nand_controller
,
78 &s3c2440_nand_controller
,
79 &s3c2443_nand_controller
,
80 /* &boundary_scan_nand_controller, */
84 /* configured NAND devices and NAND Flash command handler */
85 nand_device_t
*nand_devices
= NULL
;
86 static command_t
*nand_cmd
;
90 * Name, ID code, pagesize, chipsize in MegaByte, eraseblock size,
93 * Pagesize; 0, 256, 512
94 * 0 get this information from the extended chip ID
95 * 256 256 Byte page size
96 * 512 512 Byte page size
98 nand_info_t nand_flash_ids
[] =
100 {"NAND 1MiB 5V 8-bit", 0x6e, 256, 1, 0x1000, 0},
101 {"NAND 2MiB 5V 8-bit", 0x64, 256, 2, 0x1000, 0},
102 {"NAND 4MiB 5V 8-bit", 0x6b, 512, 4, 0x2000, 0},
103 {"NAND 1MiB 3,3V 8-bit", 0xe8, 256, 1, 0x1000, 0},
104 {"NAND 1MiB 3,3V 8-bit", 0xec, 256, 1, 0x1000, 0},
105 {"NAND 2MiB 3,3V 8-bit", 0xea, 256, 2, 0x1000, 0},
106 {"NAND 4MiB 3,3V 8-bit", 0xd5, 512, 4, 0x2000, 0},
107 {"NAND 4MiB 3,3V 8-bit", 0xe3, 512, 4, 0x2000, 0},
108 {"NAND 4MiB 3,3V 8-bit", 0xe5, 512, 4, 0x2000, 0},
109 {"NAND 8MiB 3,3V 8-bit", 0xd6, 512, 8, 0x2000, 0},
111 {"NAND 8MiB 1,8V 8-bit", 0x39, 512, 8, 0x2000, 0},
112 {"NAND 8MiB 3,3V 8-bit", 0xe6, 512, 8, 0x2000, 0},
113 {"NAND 8MiB 1,8V 16-bit", 0x49, 512, 8, 0x2000, NAND_BUSWIDTH_16
},
114 {"NAND 8MiB 3,3V 16-bit", 0x59, 512, 8, 0x2000, NAND_BUSWIDTH_16
},
116 {"NAND 16MiB 1,8V 8-bit", 0x33, 512, 16, 0x4000, 0},
117 {"NAND 16MiB 3,3V 8-bit", 0x73, 512, 16, 0x4000, 0},
118 {"NAND 16MiB 1,8V 16-bit", 0x43, 512, 16, 0x4000, NAND_BUSWIDTH_16
},
119 {"NAND 16MiB 3,3V 16-bit", 0x53, 512, 16, 0x4000, NAND_BUSWIDTH_16
},
121 {"NAND 32MiB 1,8V 8-bit", 0x35, 512, 32, 0x4000, 0},
122 {"NAND 32MiB 3,3V 8-bit", 0x75, 512, 32, 0x4000, 0},
123 {"NAND 32MiB 1,8V 16-bit", 0x45, 512, 32, 0x4000, NAND_BUSWIDTH_16
},
124 {"NAND 32MiB 3,3V 16-bit", 0x55, 512, 32, 0x4000, NAND_BUSWIDTH_16
},
126 {"NAND 64MiB 1,8V 8-bit", 0x36, 512, 64, 0x4000, 0},
127 {"NAND 64MiB 3,3V 8-bit", 0x76, 512, 64, 0x4000, 0},
128 {"NAND 64MiB 1,8V 16-bit", 0x46, 512, 64, 0x4000, NAND_BUSWIDTH_16
},
129 {"NAND 64MiB 3,3V 16-bit", 0x56, 512, 64, 0x4000, NAND_BUSWIDTH_16
},
131 {"NAND 128MiB 1,8V 8-bit", 0x78, 512, 128, 0x4000, 0},
132 {"NAND 128MiB 1,8V 8-bit", 0x39, 512, 128, 0x4000, 0},
133 {"NAND 128MiB 3,3V 8-bit", 0x79, 512, 128, 0x4000, 0},
134 {"NAND 128MiB 1,8V 16-bit", 0x72, 512, 128, 0x4000, NAND_BUSWIDTH_16
},
135 {"NAND 128MiB 1,8V 16-bit", 0x49, 512, 128, 0x4000, NAND_BUSWIDTH_16
},
136 {"NAND 128MiB 3,3V 16-bit", 0x74, 512, 128, 0x4000, NAND_BUSWIDTH_16
},
137 {"NAND 128MiB 3,3V 16-bit", 0x59, 512, 128, 0x4000, NAND_BUSWIDTH_16
},
139 {"NAND 256MiB 3,3V 8-bit", 0x71, 512, 256, 0x4000, 0},
141 {"NAND 64MiB 1,8V 8-bit", 0xA2, 0, 64, 0, LP_OPTIONS
},
142 {"NAND 64MiB 3,3V 8-bit", 0xF2, 0, 64, 0, LP_OPTIONS
},
143 {"NAND 64MiB 1,8V 16-bit", 0xB2, 0, 64, 0, LP_OPTIONS16
},
144 {"NAND 64MiB 3,3V 16-bit", 0xC2, 0, 64, 0, LP_OPTIONS16
},
146 {"NAND 128MiB 1,8V 8-bit", 0xA1, 0, 128, 0, LP_OPTIONS
},
147 {"NAND 128MiB 3,3V 8-bit", 0xF1, 0, 128, 0, LP_OPTIONS
},
148 {"NAND 128MiB 1,8V 16-bit", 0xB1, 0, 128, 0, LP_OPTIONS16
},
149 {"NAND 128MiB 3,3V 16-bit", 0xC1, 0, 128, 0, LP_OPTIONS16
},
151 {"NAND 256MiB 1,8V 8-bit", 0xAA, 0, 256, 0, LP_OPTIONS
},
152 {"NAND 256MiB 3,3V 8-bit", 0xDA, 0, 256, 0, LP_OPTIONS
},
153 {"NAND 256MiB 1,8V 16-bit", 0xBA, 0, 256, 0, LP_OPTIONS16
},
154 {"NAND 256MiB 3,3V 16-bit", 0xCA, 0, 256, 0, LP_OPTIONS16
},
156 {"NAND 512MiB 1,8V 8-bit", 0xAC, 0, 512, 0, LP_OPTIONS
},
157 {"NAND 512MiB 3,3V 8-bit", 0xDC, 0, 512, 0, LP_OPTIONS
},
158 {"NAND 512MiB 1,8V 16-bit", 0xBC, 0, 512, 0, LP_OPTIONS16
},
159 {"NAND 512MiB 3,3V 16-bit", 0xCC, 0, 512, 0, LP_OPTIONS16
},
161 {"NAND 1GiB 1,8V 8-bit", 0xA3, 0, 1024, 0, LP_OPTIONS
},
162 {"NAND 1GiB 3,3V 8-bit", 0xD3, 0, 1024, 0, LP_OPTIONS
},
163 {"NAND 1GiB 1,8V 16-bit", 0xB3, 0, 1024, 0, LP_OPTIONS16
},
164 {"NAND 1GiB 3,3V 16-bit", 0xC3, 0, 1024, 0, LP_OPTIONS16
},
166 {"NAND 2GiB 1,8V 8-bit", 0xA5, 0, 2048, 0, LP_OPTIONS
},
167 {"NAND 2GiB 3,3V 8-bit", 0xD5, 0, 2048, 0, LP_OPTIONS
},
168 {"NAND 2GiB 1,8V 16-bit", 0xB5, 0, 2048, 0, LP_OPTIONS16
},
169 {"NAND 2GiB 3,3V 16-bit", 0xC5, 0, 2048, 0, LP_OPTIONS16
},
174 /* Manufacturer ID list
176 nand_manufacturer_t nand_manuf_ids
[] =
179 {NAND_MFR_TOSHIBA
, "Toshiba"},
180 {NAND_MFR_SAMSUNG
, "Samsung"},
181 {NAND_MFR_FUJITSU
, "Fujitsu"},
182 {NAND_MFR_NATIONAL
, "National"},
183 {NAND_MFR_RENESAS
, "Renesas"},
184 {NAND_MFR_STMICRO
, "ST Micro"},
185 {NAND_MFR_HYNIX
, "Hynix"},
189 /* nand device <nand_controller> [controller options]
191 int handle_nand_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
198 LOG_WARNING("incomplete flash device nand configuration");
199 return ERROR_FLASH_BANK_INVALID
;
202 for (i
= 0; nand_flash_controllers
[i
]; i
++)
204 nand_device_t
*p
, *c
;
206 if (strcmp(args
[0], nand_flash_controllers
[i
]->name
) == 0)
208 /* register flash specific commands */
209 if ((retval
= nand_flash_controllers
[i
]->register_commands(cmd_ctx
)) != ERROR_OK
)
211 LOG_ERROR("couldn't register '%s' commands", args
[0]);
215 c
= malloc(sizeof(nand_device_t
));
217 c
->controller
= nand_flash_controllers
[i
];
218 c
->controller_priv
= NULL
;
219 c
->manufacturer
= NULL
;
222 c
->address_cycles
= 0;
227 if ((retval
= nand_flash_controllers
[i
]->nand_device_command(cmd_ctx
, cmd
, args
, argc
, c
)) != ERROR_OK
)
229 LOG_ERROR("'%s' driver rejected nand flash", c
->controller
->name
);
234 /* put NAND device in linked list */
237 /* find last flash device */
238 for (p
= nand_devices
; p
&& p
->next
; p
= p
->next
);
251 /* no valid NAND controller was found (i.e. the configuration option,
252 * didn't match one of the compiled-in controllers)
254 LOG_ERROR("No valid NAND flash controller found (%s)", args
[0]);
255 LOG_ERROR("compiled-in NAND flash controllers:");
256 for (i
= 0; nand_flash_controllers
[i
]; i
++)
258 LOG_ERROR("%i: %s", i
, nand_flash_controllers
[i
]->name
);
264 int nand_register_commands(struct command_context_s
*cmd_ctx
)
266 nand_cmd
= register_command(cmd_ctx
, NULL
, "nand", NULL
, COMMAND_ANY
, "NAND specific commands");
268 register_command(cmd_ctx
, nand_cmd
, "device", handle_nand_device_command
, COMMAND_CONFIG
, NULL
);
273 int nand_init(struct command_context_s
*cmd_ctx
)
277 register_command(cmd_ctx
, nand_cmd
, "list", handle_nand_list_command
, COMMAND_EXEC
,
278 "list configured NAND flash devices");
279 register_command(cmd_ctx
, nand_cmd
, "info", handle_nand_info_command
, COMMAND_EXEC
,
280 "print info about NAND flash device <num>");
281 register_command(cmd_ctx
, nand_cmd
, "probe", handle_nand_probe_command
, COMMAND_EXEC
,
282 "identify NAND flash device <num>");
283 register_command(cmd_ctx
, nand_cmd
, "check_bad_blocks", handle_nand_check_bad_blocks_command
, COMMAND_EXEC
,
284 "check NAND flash device <num> for bad blocks [<first> <last>]");
285 register_command(cmd_ctx
, nand_cmd
, "erase", handle_nand_erase_command
, COMMAND_EXEC
,
286 "erase blocks on NAND flash device <num> <first> <last>");
287 register_command(cmd_ctx
, nand_cmd
, "copy", handle_nand_copy_command
, COMMAND_EXEC
,
288 "copy from NAND flash device <num> <offset> <length> <ram-address>");
289 register_command(cmd_ctx
, nand_cmd
, "dump", handle_nand_dump_command
, COMMAND_EXEC
,
290 "dump from NAND flash device <num> <filename> <offset> <size> [options]");
291 register_command(cmd_ctx
, nand_cmd
, "write", handle_nand_write_command
, COMMAND_EXEC
,
292 "write to NAND flash device <num> <filename> <offset> [oob_raw|oob_only]");
293 register_command(cmd_ctx
, nand_cmd
, "raw_access", handle_nand_raw_access_command
, COMMAND_EXEC
,
294 "raw access to NAND flash device <num> ['enable'|'disable']");
300 nand_device_t
*get_nand_device_by_num(int num
)
305 for (p
= nand_devices
; p
; p
= p
->next
)
316 int nand_build_bbt(struct nand_device_s
*device
, int first
, int last
)
322 if ((first
< 0) || (first
>= device
->num_blocks
))
325 if ((last
>= device
->num_blocks
) || (last
== -1))
326 last
= device
->num_blocks
- 1;
328 for (i
= first
; i
< last
; i
++)
330 nand_read_page(device
, page
, NULL
, 0, oob
, 6);
332 if (((device
->device
->options
& NAND_BUSWIDTH_16
) && ((oob
[0] & oob
[1]) != 0xff))
333 || (((device
->page_size
== 512) && (oob
[5] != 0xff)) ||
334 ((device
->page_size
== 2048) && (oob
[0] != 0xff))))
336 LOG_WARNING("invalid block: %i", i
);
337 device
->blocks
[i
].is_bad
= 1;
341 device
->blocks
[i
].is_bad
= 0;
344 page
+= (device
->erase_size
/ device
->page_size
);
350 int nand_read_status(struct nand_device_s
*device
, u8
*status
)
353 return ERROR_NAND_DEVICE_NOT_PROBED
;
355 /* Send read status command */
356 device
->controller
->command(device
, NAND_CMD_STATUS
);
361 if (device
->device
->options
& NAND_BUSWIDTH_16
)
364 device
->controller
->read_data(device
, &data
);
365 *status
= data
& 0xff;
369 device
->controller
->read_data(device
, status
);
375 int nand_poll_ready(struct nand_device_s
*device
, int timeout
)
379 device
->controller
->command(device
, NAND_CMD_STATUS
);
381 if (device
->device
->options
& NAND_BUSWIDTH_16
) {
383 device
->controller
->read_data(device
, &data
);
384 status
= data
& 0xff;
386 device
->controller
->read_data(device
, &status
);
388 if (status
& NAND_STATUS_READY
)
393 return (status
& NAND_STATUS_READY
) != 0;
396 int nand_probe(struct nand_device_s
*device
)
398 u8 manufacturer_id
, device_id
;
403 /* clear device data */
404 device
->device
= NULL
;
405 device
->manufacturer
= NULL
;
407 /* clear device parameters */
408 device
->bus_width
= 0;
409 device
->address_cycles
= 0;
410 device
->page_size
= 0;
411 device
->erase_size
= 0;
413 /* initialize controller (device parameters are zero, use controller default) */
414 if ((retval
= device
->controller
->init(device
) != ERROR_OK
))
418 case ERROR_NAND_OPERATION_FAILED
:
419 LOG_DEBUG("controller initialization failed");
420 return ERROR_NAND_OPERATION_FAILED
;
421 case ERROR_NAND_OPERATION_NOT_SUPPORTED
:
422 LOG_ERROR("BUG: controller reported that it doesn't support default parameters");
423 return ERROR_NAND_OPERATION_FAILED
;
425 LOG_ERROR("BUG: unknown controller initialization failure");
426 return ERROR_NAND_OPERATION_FAILED
;
430 device
->controller
->command(device
, NAND_CMD_RESET
);
431 device
->controller
->reset(device
);
433 device
->controller
->command(device
, NAND_CMD_READID
);
434 device
->controller
->address(device
, 0x0);
436 if (device
->bus_width
== 8)
438 device
->controller
->read_data(device
, &manufacturer_id
);
439 device
->controller
->read_data(device
, &device_id
);
444 device
->controller
->read_data(device
, &data_buf
);
445 manufacturer_id
= data_buf
& 0xff;
446 device
->controller
->read_data(device
, &data_buf
);
447 device_id
= data_buf
& 0xff;
450 for (i
= 0; nand_flash_ids
[i
].name
; i
++)
452 if (nand_flash_ids
[i
].id
== device_id
)
454 device
->device
= &nand_flash_ids
[i
];
459 for (i
= 0; nand_manuf_ids
[i
].name
; i
++)
461 if (nand_manuf_ids
[i
].id
== manufacturer_id
)
463 device
->manufacturer
= &nand_manuf_ids
[i
];
468 if (!device
->manufacturer
)
470 device
->manufacturer
= &nand_manuf_ids
[0];
471 device
->manufacturer
->id
= manufacturer_id
;
476 LOG_ERROR("unknown NAND flash device found, manufacturer id: 0x%2.2x device id: 0x%2.2x",
477 manufacturer_id
, device_id
);
478 return ERROR_NAND_OPERATION_FAILED
;
481 LOG_DEBUG("found %s (%s)", device
->device
->name
, device
->manufacturer
->name
);
483 /* initialize device parameters */
486 if (device
->device
->options
& NAND_BUSWIDTH_16
)
487 device
->bus_width
= 16;
489 device
->bus_width
= 8;
491 /* Do we need extended device probe information? */
492 if (device
->device
->page_size
== 0 ||
493 device
->device
->erase_size
== 0)
495 if (device
->bus_width
== 8)
497 device
->controller
->read_data(device
, id_buff
+3);
498 device
->controller
->read_data(device
, id_buff
+4);
499 device
->controller
->read_data(device
, id_buff
+5);
505 device
->controller
->read_data(device
, &data_buf
);
506 id_buff
[3] = data_buf
;
508 device
->controller
->read_data(device
, &data_buf
);
509 id_buff
[4] = data_buf
;
511 device
->controller
->read_data(device
, &data_buf
);
512 id_buff
[5] = data_buf
>> 8;
517 if (device
->device
->page_size
== 0)
519 device
->page_size
= 1 << (10 + (id_buff
[4] & 3));
521 else if (device
->device
->page_size
== 256)
523 LOG_ERROR("NAND flashes with 256 byte pagesize are not supported");
524 return ERROR_NAND_OPERATION_FAILED
;
528 device
->page_size
= device
->device
->page_size
;
531 /* number of address cycles */
532 if (device
->page_size
<= 512)
534 /* small page devices */
535 if (device
->device
->chip_size
<= 32)
536 device
->address_cycles
= 3;
537 else if (device
->device
->chip_size
<= 8*1024)
538 device
->address_cycles
= 4;
541 LOG_ERROR("BUG: small page NAND device with more than 8 GiB encountered");
542 device
->address_cycles
= 5;
547 /* large page devices */
548 if (device
->device
->chip_size
<= 128)
549 device
->address_cycles
= 4;
550 else if (device
->device
->chip_size
<= 32*1024)
551 device
->address_cycles
= 5;
554 LOG_ERROR("BUG: large page NAND device with more than 32 GiB encountered");
555 device
->address_cycles
= 6;
560 if (device
->device
->erase_size
== 0)
562 switch ((id_buff
[4] >> 4) & 3) {
564 device
->erase_size
= 64 << 10;
567 device
->erase_size
= 128 << 10;
570 device
->erase_size
= 256 << 10;
573 device
->erase_size
=512 << 10;
579 device
->erase_size
= device
->device
->erase_size
;
582 /* initialize controller, but leave parameters at the controllers default */
583 if ((retval
= device
->controller
->init(device
) != ERROR_OK
))
587 case ERROR_NAND_OPERATION_FAILED
:
588 LOG_DEBUG("controller initialization failed");
589 return ERROR_NAND_OPERATION_FAILED
;
590 case ERROR_NAND_OPERATION_NOT_SUPPORTED
:
591 LOG_ERROR("controller doesn't support requested parameters (buswidth: %i, address cycles: %i, page size: %i)",
592 device
->bus_width
, device
->address_cycles
, device
->page_size
);
593 return ERROR_NAND_OPERATION_FAILED
;
595 LOG_ERROR("BUG: unknown controller initialization failure");
596 return ERROR_NAND_OPERATION_FAILED
;
600 device
->num_blocks
= (device
->device
->chip_size
* 1024) / (device
->erase_size
/ 1024);
601 device
->blocks
= malloc(sizeof(nand_block_t
) * device
->num_blocks
);
603 for (i
= 0; i
< device
->num_blocks
; i
++)
605 device
->blocks
[i
].size
= device
->erase_size
;
606 device
->blocks
[i
].offset
= i
* device
->erase_size
;
607 device
->blocks
[i
].is_erased
= -1;
608 device
->blocks
[i
].is_bad
= -1;
614 int nand_erase(struct nand_device_s
*device
, int first_block
, int last_block
)
622 return ERROR_NAND_DEVICE_NOT_PROBED
;
624 if ((first_block
< 0) || (last_block
> device
->num_blocks
))
625 return ERROR_INVALID_ARGUMENTS
;
627 /* make sure we know if a block is bad before erasing it */
628 for (i
= first_block
; i
<= last_block
; i
++)
630 if (device
->blocks
[i
].is_bad
== -1)
632 nand_build_bbt(device
, i
, last_block
);
637 for (i
= first_block
; i
<= last_block
; i
++)
639 /* Send erase setup command */
640 device
->controller
->command(device
, NAND_CMD_ERASE1
);
642 page
= i
* (device
->erase_size
/ device
->page_size
);
644 /* Send page address */
645 if (device
->page_size
<= 512)
648 device
->controller
->address(device
, page
& 0xff);
649 device
->controller
->address(device
, (page
>> 8) & 0xff);
651 /* 3rd cycle only on devices with more than 32 MiB */
652 if (device
->address_cycles
>= 4)
653 device
->controller
->address(device
, (page
>> 16) & 0xff);
655 /* 4th cycle only on devices with more than 8 GiB */
656 if (device
->address_cycles
>= 5)
657 device
->controller
->address(device
, (page
>> 24) & 0xff);
662 device
->controller
->address(device
, page
& 0xff);
663 device
->controller
->address(device
, (page
>> 8) & 0xff);
665 /* 3rd cycle only on devices with more than 128 MiB */
666 if (device
->address_cycles
>= 5)
667 device
->controller
->address(device
, (page
>> 16) & 0xff);
670 /* Send erase confirm command */
671 device
->controller
->command(device
, NAND_CMD_ERASE2
);
673 retval
= device
->controller
->nand_ready
?
674 device
->controller
->nand_ready(device
, 1000) :
675 nand_poll_ready(device
, 1000);
677 LOG_ERROR("timeout waiting for NAND flash block erase to complete");
678 return ERROR_NAND_OPERATION_TIMEOUT
;
681 if ((retval
= nand_read_status(device
, &status
)) != ERROR_OK
)
683 LOG_ERROR("couldn't read status");
684 return ERROR_NAND_OPERATION_FAILED
;
689 LOG_ERROR("erase operation didn't pass, status: 0x%2.2x", status
);
690 return ERROR_NAND_OPERATION_FAILED
;
697 int nand_read_plain(struct nand_device_s
*device
, u32 address
, u8
*data
, u32 data_size
)
702 return ERROR_NAND_DEVICE_NOT_PROBED
;
704 if (address
% device
->page_size
)
706 LOG_ERROR("reads need to be page aligned");
707 return ERROR_NAND_OPERATION_FAILED
;
710 page
= malloc(device
->page_size
);
712 while (data_size
> 0 )
714 u32 thisrun_size
= (data_size
> device
->page_size
) ? device
->page_size
: data_size
;
718 page_address
= address
/ device
->page_size
;
720 nand_read_page(device
, page_address
, page
, device
->page_size
, NULL
, 0);
722 memcpy(data
, page
, thisrun_size
);
724 address
+= thisrun_size
;
725 data
+= thisrun_size
;
726 data_size
-= thisrun_size
;
734 int nand_write_plain(struct nand_device_s
*device
, u32 address
, u8
*data
, u32 data_size
)
739 return ERROR_NAND_DEVICE_NOT_PROBED
;
741 if (address
% device
->page_size
)
743 LOG_ERROR("writes need to be page aligned");
744 return ERROR_NAND_OPERATION_FAILED
;
747 page
= malloc(device
->page_size
);
749 while (data_size
> 0 )
751 u32 thisrun_size
= (data_size
> device
->page_size
) ? device
->page_size
: data_size
;
754 memset(page
, 0xff, device
->page_size
);
755 memcpy(page
, data
, thisrun_size
);
757 page_address
= address
/ device
->page_size
;
759 nand_write_page(device
, page_address
, page
, device
->page_size
, NULL
, 0);
761 address
+= thisrun_size
;
762 data
+= thisrun_size
;
763 data_size
-= thisrun_size
;
771 int nand_write_page(struct nand_device_s
*device
, u32 page
, u8
*data
, u32 data_size
, u8
*oob
, u32 oob_size
)
774 return ERROR_NAND_DEVICE_NOT_PROBED
;
776 if (device
->use_raw
|| device
->controller
->write_page
== NULL
)
777 return nand_write_page_raw(device
, page
, data
, data_size
, oob
, oob_size
);
779 return device
->controller
->write_page(device
, page
, data
, data_size
, oob
, oob_size
);
782 int nand_read_page(struct nand_device_s
*device
, u32 page
, u8
*data
, u32 data_size
, u8
*oob
, u32 oob_size
)
785 return ERROR_NAND_DEVICE_NOT_PROBED
;
787 if (device
->use_raw
|| device
->controller
->read_page
== NULL
)
788 return nand_read_page_raw(device
, page
, data
, data_size
, oob
, oob_size
);
790 return device
->controller
->read_page(device
, page
, data
, data_size
, oob
, oob_size
);
793 int nand_read_page_raw(struct nand_device_s
*device
, u32 page
, u8
*data
, u32 data_size
, u8
*oob
, u32 oob_size
)
798 return ERROR_NAND_DEVICE_NOT_PROBED
;
800 if (device
->page_size
<= 512)
802 /* small page device */
804 device
->controller
->command(device
, NAND_CMD_READ0
);
806 device
->controller
->command(device
, NAND_CMD_READOOB
);
808 /* column (always 0, we start at the beginning of a page/OOB area) */
809 device
->controller
->address(device
, 0x0);
812 device
->controller
->address(device
, page
& 0xff);
813 device
->controller
->address(device
, (page
>> 8) & 0xff);
815 /* 4th cycle only on devices with more than 32 MiB */
816 if (device
->address_cycles
>= 4)
817 device
->controller
->address(device
, (page
>> 16) & 0xff);
819 /* 5th cycle only on devices with more than 8 GiB */
820 if (device
->address_cycles
>= 5)
821 device
->controller
->address(device
, (page
>> 24) & 0xff);
825 /* large page device */
826 device
->controller
->command(device
, NAND_CMD_READ0
);
828 /* column (0 when we start at the beginning of a page,
829 * or 2048 for the beginning of OOB area)
831 device
->controller
->address(device
, 0x0);
833 device
->controller
->address(device
, 0x0);
835 device
->controller
->address(device
, 0x8);
838 device
->controller
->address(device
, page
& 0xff);
839 device
->controller
->address(device
, (page
>> 8) & 0xff);
841 /* 5th cycle only on devices with more than 128 MiB */
842 if (device
->address_cycles
>= 5)
843 device
->controller
->address(device
, (page
>> 16) & 0xff);
845 /* large page devices need a start command */
846 device
->controller
->command(device
, NAND_CMD_READSTART
);
849 if (device
->controller
->nand_ready
) {
850 if (!device
->controller
->nand_ready(device
, 100))
851 return ERROR_NAND_OPERATION_TIMEOUT
;
858 if (device
->controller
->read_block_data
!= NULL
)
859 (device
->controller
->read_block_data
)(device
, data
, data_size
);
862 for (i
= 0; i
< data_size
;)
864 if (device
->device
->options
& NAND_BUSWIDTH_16
)
866 device
->controller
->read_data(device
, data
);
872 device
->controller
->read_data(device
, data
);
882 if (device
->controller
->read_block_data
!= NULL
)
883 (device
->controller
->read_block_data
)(device
, oob
, oob_size
);
886 for (i
= 0; i
< oob_size
;)
888 if (device
->device
->options
& NAND_BUSWIDTH_16
)
890 device
->controller
->read_data(device
, oob
);
896 device
->controller
->read_data(device
, oob
);
907 int nand_write_page_raw(struct nand_device_s
*device
, u32 page
, u8
*data
, u32 data_size
, u8
*oob
, u32 oob_size
)
914 return ERROR_NAND_DEVICE_NOT_PROBED
;
916 device
->controller
->command(device
, NAND_CMD_SEQIN
);
918 if (device
->page_size
<= 512)
920 /* column (always 0, we start at the beginning of a page/OOB area) */
921 device
->controller
->address(device
, 0x0);
924 device
->controller
->address(device
, page
& 0xff);
925 device
->controller
->address(device
, (page
>> 8) & 0xff);
927 /* 4th cycle only on devices with more than 32 MiB */
928 if (device
->address_cycles
>= 4)
929 device
->controller
->address(device
, (page
>> 16) & 0xff);
931 /* 5th cycle only on devices with more than 8 GiB */
932 if (device
->address_cycles
>= 5)
933 device
->controller
->address(device
, (page
>> 24) & 0xff);
937 /* column (0 when we start at the beginning of a page,
938 * or 2048 for the beginning of OOB area)
940 device
->controller
->address(device
, 0x0);
942 device
->controller
->address(device
, 0x0);
944 device
->controller
->address(device
, 0x8);
947 device
->controller
->address(device
, page
& 0xff);
948 device
->controller
->address(device
, (page
>> 8) & 0xff);
950 /* 5th cycle only on devices with more than 128 MiB */
951 if (device
->address_cycles
>= 5)
952 device
->controller
->address(device
, (page
>> 16) & 0xff);
957 if (device
->controller
->write_block_data
!= NULL
)
958 (device
->controller
->write_block_data
)(device
, data
, data_size
);
961 for (i
= 0; i
< data_size
;)
963 if (device
->device
->options
& NAND_BUSWIDTH_16
)
965 u16 data_buf
= le_to_h_u16(data
);
966 device
->controller
->write_data(device
, data_buf
);
972 device
->controller
->write_data(device
, *data
);
982 if (device
->controller
->write_block_data
!= NULL
)
983 (device
->controller
->write_block_data
)(device
, oob
, oob_size
);
986 for (i
= 0; i
< oob_size
;)
988 if (device
->device
->options
& NAND_BUSWIDTH_16
)
990 u16 oob_buf
= le_to_h_u16(data
);
991 device
->controller
->write_data(device
, oob_buf
);
997 device
->controller
->write_data(device
, *oob
);
1005 device
->controller
->command(device
, NAND_CMD_PAGEPROG
);
1007 retval
= device
->controller
->nand_ready
?
1008 device
->controller
->nand_ready(device
, 100) :
1009 nand_poll_ready(device
, 100);
1011 return ERROR_NAND_OPERATION_TIMEOUT
;
1013 if ((retval
= nand_read_status(device
, &status
)) != ERROR_OK
)
1015 LOG_ERROR("couldn't read status");
1016 return ERROR_NAND_OPERATION_FAILED
;
1019 if (status
& NAND_STATUS_FAIL
)
1021 LOG_ERROR("write operation didn't pass, status: 0x%2.2x", status
);
1022 return ERROR_NAND_OPERATION_FAILED
;
1028 int handle_nand_list_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1035 command_print(cmd_ctx
, "no NAND flash devices configured");
1039 for (p
= nand_devices
; p
; p
= p
->next
)
1042 command_print(cmd_ctx
, "#%i: %s (%s) pagesize: %i, buswidth: %i, erasesize: %i",
1043 i
++, p
->device
->name
, p
->manufacturer
->name
, p
->page_size
, p
->bus_width
, p
->erase_size
);
1045 command_print(cmd_ctx
, "#%i: not probed");
1051 int handle_nand_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1059 if ((argc
< 1) || (argc
> 3))
1061 return ERROR_COMMAND_SYNTAX_ERROR
;
1067 first
= last
= strtoul(args
[1], NULL
, 0);
1071 first
= strtoul(args
[1], NULL
, 0);
1072 last
= strtoul(args
[2], NULL
, 0);
1075 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1080 if (first
>= p
->num_blocks
)
1081 first
= p
->num_blocks
- 1;
1083 if (last
>= p
->num_blocks
)
1084 last
= p
->num_blocks
- 1;
1086 command_print(cmd_ctx
, "#%i: %s (%s) pagesize: %i, buswidth: %i, erasesize: %i",
1087 i
++, p
->device
->name
, p
->manufacturer
->name
, p
->page_size
, p
->bus_width
, p
->erase_size
);
1089 for (j
= first
; j
<= last
; j
++)
1091 char *erase_state
, *bad_state
;
1093 if (p
->blocks
[j
].is_erased
== 0)
1094 erase_state
= "not erased";
1095 else if (p
->blocks
[j
].is_erased
== 1)
1096 erase_state
= "erased";
1098 erase_state
= "erase state unknown";
1100 if (p
->blocks
[j
].is_bad
== 0)
1102 else if (p
->blocks
[j
].is_bad
== 1)
1103 bad_state
= " (marked bad)";
1105 bad_state
= " (block condition unknown)";
1107 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%xkB) %s%s",
1108 j
, p
->blocks
[j
].offset
, p
->blocks
[j
].size
/ 1024,
1109 erase_state
, bad_state
);
1114 command_print(cmd_ctx
, "#%i: not probed");
1121 int handle_nand_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1128 return ERROR_COMMAND_SYNTAX_ERROR
;
1131 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1134 if ((retval
= nand_probe(p
)) == ERROR_OK
)
1136 command_print(cmd_ctx
, "NAND flash device '%s' found", p
->device
->name
);
1138 else if (retval
== ERROR_NAND_OPERATION_FAILED
)
1140 command_print(cmd_ctx
, "probing failed for NAND flash device");
1144 command_print(cmd_ctx
, "unknown error when probing NAND flash device");
1149 command_print(cmd_ctx
, "NAND flash device '#%s' is out of bounds", args
[0]);
1155 int handle_nand_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1162 return ERROR_COMMAND_SYNTAX_ERROR
;
1166 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1169 int first
= strtoul(args
[1], NULL
, 0);
1170 int last
= strtoul(args
[2], NULL
, 0);
1172 if ((retval
= nand_erase(p
, first
, last
)) == ERROR_OK
)
1174 command_print(cmd_ctx
, "successfully erased blocks %i to %i on NAND flash device '%s'", first
, last
, p
->device
->name
);
1176 else if (retval
== ERROR_NAND_OPERATION_FAILED
)
1178 command_print(cmd_ctx
, "erase failed");
1182 command_print(cmd_ctx
, "unknown error when erasing NAND flash device");
1187 command_print(cmd_ctx
, "NAND flash device '#%s' is out of bounds", args
[0]);
1193 int handle_nand_check_bad_blocks_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1200 if ((argc
< 1) || (argc
> 3) || (argc
== 2))
1202 return ERROR_COMMAND_SYNTAX_ERROR
;
1208 first
= strtoul(args
[1], NULL
, 0);
1209 last
= strtoul(args
[2], NULL
, 0);
1212 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1215 if ((retval
= nand_build_bbt(p
, first
, last
)) == ERROR_OK
)
1217 command_print(cmd_ctx
, "checked NAND flash device for bad blocks, use \"nand info\" command to list blocks", p
->device
->name
);
1219 else if (retval
== ERROR_NAND_OPERATION_FAILED
)
1221 command_print(cmd_ctx
, "error when checking for bad blocks on NAND flash device");
1225 command_print(cmd_ctx
, "unknown error when checking for bad blocks on NAND flash device");
1230 command_print(cmd_ctx
, "NAND flash device '#%s' is out of bounds", args
[0]);
1236 int handle_nand_copy_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1242 return ERROR_COMMAND_SYNTAX_ERROR
;
1246 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1253 command_print(cmd_ctx
, "NAND flash device '#%s' is out of bounds", args
[0]);
1259 int handle_nand_write_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1264 enum oob_formats oob_format
= NAND_OOB_NONE
;
1268 duration_t duration
;
1269 char *duration_text
;
1275 return ERROR_COMMAND_SYNTAX_ERROR
;
1279 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1287 offset
= strtoul(args
[2], NULL
, 0);
1292 for (i
= 3; i
< argc
; i
++)
1294 if (!strcmp(args
[i
], "oob_raw"))
1295 oob_format
|= NAND_OOB_RAW
;
1296 else if (!strcmp(args
[i
], "oob_only"))
1297 oob_format
|= NAND_OOB_RAW
| NAND_OOB_ONLY
;
1300 command_print(cmd_ctx
, "unknown option: %s", args
[i
]);
1301 return ERROR_COMMAND_SYNTAX_ERROR
;
1306 duration_start_measure(&duration
);
1308 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
1313 buf_cnt
= binary_size
= fileio
.size
;
1315 if (!(oob_format
& NAND_OOB_ONLY
))
1317 page_size
= p
->page_size
;
1318 page
= malloc(p
->page_size
);
1321 if (oob_format
& NAND_OOB_RAW
)
1323 if (p
->page_size
== 512)
1325 else if (p
->page_size
== 2048)
1327 oob
= malloc(oob_size
);
1330 if (offset
% p
->page_size
)
1332 command_print(cmd_ctx
, "only page size aligned offsets and sizes are supported");
1333 fileio_close(&fileio
);
1345 fileio_read(&fileio
, page_size
, page
, &size_read
);
1346 buf_cnt
-= size_read
;
1347 if (size_read
< page_size
)
1349 memset(page
+ size_read
, 0xff, page_size
- size_read
);
1355 fileio_read(&fileio
, oob_size
, oob
, &size_read
);
1356 buf_cnt
-= size_read
;
1357 if (size_read
< oob_size
)
1359 memset(oob
+ size_read
, 0xff, oob_size
- size_read
);
1363 if (nand_write_page(p
, offset
/ p
->page_size
, page
, page_size
, oob
, oob_size
) != ERROR_OK
)
1365 command_print(cmd_ctx
, "failed writing file %s to NAND flash %s at offset 0x%8.8x",
1366 args
[1], args
[0], offset
);
1368 fileio_close(&fileio
);
1374 offset
+= page_size
;
1377 fileio_close(&fileio
);
1382 duration_stop_measure(&duration
, &duration_text
);
1383 command_print(cmd_ctx
, "wrote file %s to NAND flash %s up to offset 0x%8.8x in %s",
1384 args
[1], args
[0], offset
, duration_text
);
1385 free(duration_text
);
1386 duration_text
= NULL
;
1390 command_print(cmd_ctx
, "NAND flash device '#%s' is out of bounds", args
[0]);
1396 int handle_nand_dump_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1402 return ERROR_COMMAND_SYNTAX_ERROR
;
1405 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1411 duration_t duration
;
1412 char *duration_text
;
1419 u32 address
= strtoul(args
[2], NULL
, 0);
1420 u32 size
= strtoul(args
[3], NULL
, 0);
1422 enum oob_formats oob_format
= NAND_OOB_NONE
;
1427 for (i
= 4; i
< argc
; i
++)
1429 if (!strcmp(args
[i
], "oob_raw"))
1430 oob_format
|= NAND_OOB_RAW
;
1431 else if (!strcmp(args
[i
], "oob_only"))
1432 oob_format
|= NAND_OOB_RAW
| NAND_OOB_ONLY
;
1434 command_print(cmd_ctx
, "unknown option: '%s'", args
[i
]);
1438 if ((address
% p
->page_size
) || (size
% p
->page_size
))
1440 command_print(cmd_ctx
, "only page size aligned addresses and sizes are supported");
1444 if (!(oob_format
& NAND_OOB_ONLY
))
1446 page_size
= p
->page_size
;
1447 page
= malloc(p
->page_size
);
1450 if (oob_format
& NAND_OOB_RAW
)
1452 if (p
->page_size
== 512)
1454 else if (p
->page_size
== 2048)
1456 oob
= malloc(oob_size
);
1459 if (fileio_open(&fileio
, args
[1], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
1464 duration_start_measure(&duration
);
1469 if ((retval
= nand_read_page(p
, address
/ p
->page_size
, page
, page_size
, oob
, oob_size
)) != ERROR_OK
)
1471 command_print(cmd_ctx
, "reading NAND flash page failed");
1474 fileio_close(&fileio
);
1480 fileio_write(&fileio
, page_size
, page
, &size_written
);
1481 bytes_done
+= page_size
;
1486 fileio_write(&fileio
, oob_size
, oob
, &size_written
);
1487 bytes_done
+= oob_size
;
1490 size
-= p
->page_size
;
1491 address
+= p
->page_size
;
1498 fileio_close(&fileio
);
1500 duration_stop_measure(&duration
, &duration_text
);
1501 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
1502 free(duration_text
);
1503 duration_text
= NULL
;
1507 command_print(cmd_ctx
, "#%i: not probed");
1512 command_print(cmd_ctx
, "NAND flash device '#%s' is out of bounds", args
[0]);
1518 int handle_nand_raw_access_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1522 if ((argc
< 1) || (argc
> 2))
1524 return ERROR_COMMAND_SYNTAX_ERROR
;
1527 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1534 if (strcmp("enable", args
[1]) == 0)
1538 else if (strcmp("disable", args
[1]) == 0)
1544 return ERROR_COMMAND_SYNTAX_ERROR
;
1548 command_print(cmd_ctx
, "raw access is %s", (p
->use_raw
) ? "enabled" : "disabled");
1552 command_print(cmd_ctx
, "#%i: not probed");
1557 command_print(cmd_ctx
, "NAND flash device '#%s' is out of bounds", args
[0]);
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)