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
)
324 if ((first
< 0) || (first
>= device
->num_blocks
))
327 if ((last
>= device
->num_blocks
) || (last
== -1))
328 last
= device
->num_blocks
- 1;
330 for (i
= first
; i
< last
; i
++)
332 nand_read_page(device
, page
, NULL
, 0, oob
, 6);
334 if (((device
->device
->options
& NAND_BUSWIDTH_16
) && ((oob
[0] & oob
[1]) != 0xff))
335 || (((device
->page_size
== 512) && (oob
[5] != 0xff)) ||
336 ((device
->page_size
== 2048) && (oob
[0] != 0xff))))
338 LOG_WARNING("invalid block: %i", i
);
339 device
->blocks
[i
].is_bad
= 1;
343 device
->blocks
[i
].is_bad
= 0;
346 page
+= (device
->erase_size
/ device
->page_size
);
352 int nand_read_status(struct nand_device_s
*device
, u8
*status
)
355 return ERROR_NAND_DEVICE_NOT_PROBED
;
357 /* Send read status command */
358 device
->controller
->command(device
, NAND_CMD_STATUS
);
363 if (device
->device
->options
& NAND_BUSWIDTH_16
)
366 device
->controller
->read_data(device
, &data
);
367 *status
= data
& 0xff;
371 device
->controller
->read_data(device
, status
);
377 int nand_poll_ready(struct nand_device_s
*device
, int timeout
)
381 device
->controller
->command(device
, NAND_CMD_STATUS
);
383 if (device
->device
->options
& NAND_BUSWIDTH_16
) {
385 device
->controller
->read_data(device
, &data
);
386 status
= data
& 0xff;
388 device
->controller
->read_data(device
, &status
);
390 if (status
& NAND_STATUS_READY
)
395 return (status
& NAND_STATUS_READY
) != 0;
398 int nand_probe(struct nand_device_s
*device
)
400 u8 manufacturer_id
, device_id
;
405 /* clear device data */
406 device
->device
= NULL
;
407 device
->manufacturer
= NULL
;
409 /* clear device parameters */
410 device
->bus_width
= 0;
411 device
->address_cycles
= 0;
412 device
->page_size
= 0;
413 device
->erase_size
= 0;
415 /* initialize controller (device parameters are zero, use controller default) */
416 if ((retval
= device
->controller
->init(device
) != ERROR_OK
))
420 case ERROR_NAND_OPERATION_FAILED
:
421 LOG_DEBUG("controller initialization failed");
422 return ERROR_NAND_OPERATION_FAILED
;
423 case ERROR_NAND_OPERATION_NOT_SUPPORTED
:
424 LOG_ERROR("BUG: controller reported that it doesn't support default parameters");
425 return ERROR_NAND_OPERATION_FAILED
;
427 LOG_ERROR("BUG: unknown controller initialization failure");
428 return ERROR_NAND_OPERATION_FAILED
;
432 device
->controller
->command(device
, NAND_CMD_RESET
);
433 device
->controller
->reset(device
);
435 device
->controller
->command(device
, NAND_CMD_READID
);
436 device
->controller
->address(device
, 0x0);
438 if (device
->bus_width
== 8)
440 device
->controller
->read_data(device
, &manufacturer_id
);
441 device
->controller
->read_data(device
, &device_id
);
446 device
->controller
->read_data(device
, &data_buf
);
447 manufacturer_id
= data_buf
& 0xff;
448 device
->controller
->read_data(device
, &data_buf
);
449 device_id
= data_buf
& 0xff;
452 for (i
= 0; nand_flash_ids
[i
].name
; i
++)
454 if (nand_flash_ids
[i
].id
== device_id
)
456 device
->device
= &nand_flash_ids
[i
];
461 for (i
= 0; nand_manuf_ids
[i
].name
; i
++)
463 if (nand_manuf_ids
[i
].id
== manufacturer_id
)
465 device
->manufacturer
= &nand_manuf_ids
[i
];
470 if (!device
->manufacturer
)
472 device
->manufacturer
= &nand_manuf_ids
[0];
473 device
->manufacturer
->id
= manufacturer_id
;
478 LOG_ERROR("unknown NAND flash device found, manufacturer id: 0x%2.2x device id: 0x%2.2x",
479 manufacturer_id
, device_id
);
480 return ERROR_NAND_OPERATION_FAILED
;
483 LOG_DEBUG("found %s (%s)", device
->device
->name
, device
->manufacturer
->name
);
485 /* initialize device parameters */
488 if (device
->device
->options
& NAND_BUSWIDTH_16
)
489 device
->bus_width
= 16;
491 device
->bus_width
= 8;
493 /* Do we need extended device probe information? */
494 if (device
->device
->page_size
== 0 ||
495 device
->device
->erase_size
== 0)
497 if (device
->bus_width
== 8)
499 device
->controller
->read_data(device
, id_buff
+3);
500 device
->controller
->read_data(device
, id_buff
+4);
501 device
->controller
->read_data(device
, id_buff
+5);
507 device
->controller
->read_data(device
, &data_buf
);
508 id_buff
[3] = data_buf
;
510 device
->controller
->read_data(device
, &data_buf
);
511 id_buff
[4] = data_buf
;
513 device
->controller
->read_data(device
, &data_buf
);
514 id_buff
[5] = data_buf
>> 8;
519 if (device
->device
->page_size
== 0)
521 device
->page_size
= 1 << (10 + (id_buff
[4] & 3));
523 else if (device
->device
->page_size
== 256)
525 LOG_ERROR("NAND flashes with 256 byte pagesize are not supported");
526 return ERROR_NAND_OPERATION_FAILED
;
530 device
->page_size
= device
->device
->page_size
;
533 /* number of address cycles */
534 if (device
->page_size
<= 512)
536 /* small page devices */
537 if (device
->device
->chip_size
<= 32)
538 device
->address_cycles
= 3;
539 else if (device
->device
->chip_size
<= 8*1024)
540 device
->address_cycles
= 4;
543 LOG_ERROR("BUG: small page NAND device with more than 8 GiB encountered");
544 device
->address_cycles
= 5;
549 /* large page devices */
550 if (device
->device
->chip_size
<= 128)
551 device
->address_cycles
= 4;
552 else if (device
->device
->chip_size
<= 32*1024)
553 device
->address_cycles
= 5;
556 LOG_ERROR("BUG: large page NAND device with more than 32 GiB encountered");
557 device
->address_cycles
= 6;
562 if (device
->device
->erase_size
== 0)
564 switch ((id_buff
[4] >> 4) & 3) {
566 device
->erase_size
= 64 << 10;
569 device
->erase_size
= 128 << 10;
572 device
->erase_size
= 256 << 10;
575 device
->erase_size
=512 << 10;
581 device
->erase_size
= device
->device
->erase_size
;
584 /* initialize controller, but leave parameters at the controllers default */
585 if ((retval
= device
->controller
->init(device
) != ERROR_OK
))
589 case ERROR_NAND_OPERATION_FAILED
:
590 LOG_DEBUG("controller initialization failed");
591 return ERROR_NAND_OPERATION_FAILED
;
592 case ERROR_NAND_OPERATION_NOT_SUPPORTED
:
593 LOG_ERROR("controller doesn't support requested parameters (buswidth: %i, address cycles: %i, page size: %i)",
594 device
->bus_width
, device
->address_cycles
, device
->page_size
);
595 return ERROR_NAND_OPERATION_FAILED
;
597 LOG_ERROR("BUG: unknown controller initialization failure");
598 return ERROR_NAND_OPERATION_FAILED
;
602 device
->num_blocks
= (device
->device
->chip_size
* 1024) / (device
->erase_size
/ 1024);
603 device
->blocks
= malloc(sizeof(nand_block_t
) * device
->num_blocks
);
605 for (i
= 0; i
< device
->num_blocks
; i
++)
607 device
->blocks
[i
].size
= device
->erase_size
;
608 device
->blocks
[i
].offset
= i
* device
->erase_size
;
609 device
->blocks
[i
].is_erased
= -1;
610 device
->blocks
[i
].is_bad
= -1;
616 int nand_erase(struct nand_device_s
*device
, int first_block
, int last_block
)
624 return ERROR_NAND_DEVICE_NOT_PROBED
;
626 if ((first_block
< 0) || (last_block
> device
->num_blocks
))
627 return ERROR_INVALID_ARGUMENTS
;
629 /* make sure we know if a block is bad before erasing it */
630 for (i
= first_block
; i
<= last_block
; i
++)
632 if (device
->blocks
[i
].is_bad
== -1)
634 nand_build_bbt(device
, i
, last_block
);
639 for (i
= first_block
; i
<= last_block
; i
++)
641 /* Send erase setup command */
642 device
->controller
->command(device
, NAND_CMD_ERASE1
);
644 page
= i
* (device
->erase_size
/ device
->page_size
);
646 /* Send page address */
647 if (device
->page_size
<= 512)
650 device
->controller
->address(device
, page
& 0xff);
651 device
->controller
->address(device
, (page
>> 8) & 0xff);
653 /* 3rd cycle only on devices with more than 32 MiB */
654 if (device
->address_cycles
>= 4)
655 device
->controller
->address(device
, (page
>> 16) & 0xff);
657 /* 4th cycle only on devices with more than 8 GiB */
658 if (device
->address_cycles
>= 5)
659 device
->controller
->address(device
, (page
>> 24) & 0xff);
664 device
->controller
->address(device
, page
& 0xff);
665 device
->controller
->address(device
, (page
>> 8) & 0xff);
667 /* 3rd cycle only on devices with more than 128 MiB */
668 if (device
->address_cycles
>= 5)
669 device
->controller
->address(device
, (page
>> 16) & 0xff);
672 /* Send erase confirm command */
673 device
->controller
->command(device
, NAND_CMD_ERASE2
);
675 retval
= device
->controller
->nand_ready
?
676 device
->controller
->nand_ready(device
, 1000) :
677 nand_poll_ready(device
, 1000);
679 LOG_ERROR("timeout waiting for NAND flash block erase to complete");
680 return ERROR_NAND_OPERATION_TIMEOUT
;
683 if ((retval
= nand_read_status(device
, &status
)) != ERROR_OK
)
685 LOG_ERROR("couldn't read status");
686 return ERROR_NAND_OPERATION_FAILED
;
691 LOG_ERROR("erase operation didn't pass, status: 0x%2.2x", status
);
692 return ERROR_NAND_OPERATION_FAILED
;
699 int nand_read_plain(struct nand_device_s
*device
, u32 address
, u8
*data
, u32 data_size
)
704 return ERROR_NAND_DEVICE_NOT_PROBED
;
706 if (address
% device
->page_size
)
708 LOG_ERROR("reads need to be page aligned");
709 return ERROR_NAND_OPERATION_FAILED
;
712 page
= malloc(device
->page_size
);
714 while (data_size
> 0 )
716 u32 thisrun_size
= (data_size
> device
->page_size
) ? device
->page_size
: data_size
;
720 page_address
= address
/ device
->page_size
;
722 nand_read_page(device
, page_address
, page
, device
->page_size
, NULL
, 0);
724 memcpy(data
, page
, thisrun_size
);
726 address
+= thisrun_size
;
727 data
+= thisrun_size
;
728 data_size
-= thisrun_size
;
736 int nand_write_plain(struct nand_device_s
*device
, u32 address
, u8
*data
, u32 data_size
)
741 return ERROR_NAND_DEVICE_NOT_PROBED
;
743 if (address
% device
->page_size
)
745 LOG_ERROR("writes need to be page aligned");
746 return ERROR_NAND_OPERATION_FAILED
;
749 page
= malloc(device
->page_size
);
751 while (data_size
> 0 )
753 u32 thisrun_size
= (data_size
> device
->page_size
) ? device
->page_size
: data_size
;
756 memset(page
, 0xff, device
->page_size
);
757 memcpy(page
, data
, thisrun_size
);
759 page_address
= address
/ device
->page_size
;
761 nand_write_page(device
, page_address
, page
, device
->page_size
, NULL
, 0);
763 address
+= thisrun_size
;
764 data
+= thisrun_size
;
765 data_size
-= thisrun_size
;
773 int nand_write_page(struct nand_device_s
*device
, u32 page
, u8
*data
, u32 data_size
, u8
*oob
, u32 oob_size
)
776 return ERROR_NAND_DEVICE_NOT_PROBED
;
778 if (device
->use_raw
|| device
->controller
->write_page
== NULL
)
779 return nand_write_page_raw(device
, page
, data
, data_size
, oob
, oob_size
);
781 return device
->controller
->write_page(device
, page
, data
, data_size
, oob
, oob_size
);
784 int nand_read_page(struct nand_device_s
*device
, u32 page
, u8
*data
, u32 data_size
, u8
*oob
, u32 oob_size
)
787 return ERROR_NAND_DEVICE_NOT_PROBED
;
789 if (device
->use_raw
|| device
->controller
->read_page
== NULL
)
790 return nand_read_page_raw(device
, page
, data
, data_size
, oob
, oob_size
);
792 return device
->controller
->read_page(device
, page
, data
, data_size
, oob
, oob_size
);
795 int nand_read_page_raw(struct nand_device_s
*device
, u32 page
, u8
*data
, u32 data_size
, u8
*oob
, u32 oob_size
)
800 return ERROR_NAND_DEVICE_NOT_PROBED
;
802 if (device
->page_size
<= 512)
804 /* small page device */
806 device
->controller
->command(device
, NAND_CMD_READ0
);
808 device
->controller
->command(device
, NAND_CMD_READOOB
);
810 /* column (always 0, we start at the beginning of a page/OOB area) */
811 device
->controller
->address(device
, 0x0);
814 device
->controller
->address(device
, page
& 0xff);
815 device
->controller
->address(device
, (page
>> 8) & 0xff);
817 /* 4th cycle only on devices with more than 32 MiB */
818 if (device
->address_cycles
>= 4)
819 device
->controller
->address(device
, (page
>> 16) & 0xff);
821 /* 5th cycle only on devices with more than 8 GiB */
822 if (device
->address_cycles
>= 5)
823 device
->controller
->address(device
, (page
>> 24) & 0xff);
827 /* large page device */
828 device
->controller
->command(device
, NAND_CMD_READ0
);
830 /* column (0 when we start at the beginning of a page,
831 * or 2048 for the beginning of OOB area)
833 device
->controller
->address(device
, 0x0);
835 device
->controller
->address(device
, 0x0);
837 device
->controller
->address(device
, 0x8);
840 device
->controller
->address(device
, page
& 0xff);
841 device
->controller
->address(device
, (page
>> 8) & 0xff);
843 /* 5th cycle only on devices with more than 128 MiB */
844 if (device
->address_cycles
>= 5)
845 device
->controller
->address(device
, (page
>> 16) & 0xff);
847 /* large page devices need a start command */
848 device
->controller
->command(device
, NAND_CMD_READSTART
);
851 if (device
->controller
->nand_ready
) {
852 if (!device
->controller
->nand_ready(device
, 100))
853 return ERROR_NAND_OPERATION_TIMEOUT
;
860 if (device
->controller
->read_block_data
!= NULL
)
861 (device
->controller
->read_block_data
)(device
, data
, data_size
);
864 for (i
= 0; i
< data_size
;)
866 if (device
->device
->options
& NAND_BUSWIDTH_16
)
868 device
->controller
->read_data(device
, data
);
874 device
->controller
->read_data(device
, data
);
884 if (device
->controller
->read_block_data
!= NULL
)
885 (device
->controller
->read_block_data
)(device
, oob
, oob_size
);
888 for (i
= 0; i
< oob_size
;)
890 if (device
->device
->options
& NAND_BUSWIDTH_16
)
892 device
->controller
->read_data(device
, oob
);
898 device
->controller
->read_data(device
, oob
);
909 int nand_write_page_raw(struct nand_device_s
*device
, u32 page
, u8
*data
, u32 data_size
, u8
*oob
, u32 oob_size
)
916 return ERROR_NAND_DEVICE_NOT_PROBED
;
918 device
->controller
->command(device
, NAND_CMD_SEQIN
);
920 if (device
->page_size
<= 512)
922 /* column (always 0, we start at the beginning of a page/OOB area) */
923 device
->controller
->address(device
, 0x0);
926 device
->controller
->address(device
, page
& 0xff);
927 device
->controller
->address(device
, (page
>> 8) & 0xff);
929 /* 4th cycle only on devices with more than 32 MiB */
930 if (device
->address_cycles
>= 4)
931 device
->controller
->address(device
, (page
>> 16) & 0xff);
933 /* 5th cycle only on devices with more than 8 GiB */
934 if (device
->address_cycles
>= 5)
935 device
->controller
->address(device
, (page
>> 24) & 0xff);
939 /* column (0 when we start at the beginning of a page,
940 * or 2048 for the beginning of OOB area)
942 device
->controller
->address(device
, 0x0);
944 device
->controller
->address(device
, 0x0);
946 device
->controller
->address(device
, 0x8);
949 device
->controller
->address(device
, page
& 0xff);
950 device
->controller
->address(device
, (page
>> 8) & 0xff);
952 /* 5th cycle only on devices with more than 128 MiB */
953 if (device
->address_cycles
>= 5)
954 device
->controller
->address(device
, (page
>> 16) & 0xff);
959 if (device
->controller
->write_block_data
!= NULL
)
960 (device
->controller
->write_block_data
)(device
, data
, data_size
);
963 for (i
= 0; i
< data_size
;)
965 if (device
->device
->options
& NAND_BUSWIDTH_16
)
967 u16 data_buf
= le_to_h_u16(data
);
968 device
->controller
->write_data(device
, data_buf
);
974 device
->controller
->write_data(device
, *data
);
984 if (device
->controller
->write_block_data
!= NULL
)
985 (device
->controller
->write_block_data
)(device
, oob
, oob_size
);
988 for (i
= 0; i
< oob_size
;)
990 if (device
->device
->options
& NAND_BUSWIDTH_16
)
992 u16 oob_buf
= le_to_h_u16(data
);
993 device
->controller
->write_data(device
, oob_buf
);
999 device
->controller
->write_data(device
, *oob
);
1007 device
->controller
->command(device
, NAND_CMD_PAGEPROG
);
1009 retval
= device
->controller
->nand_ready
?
1010 device
->controller
->nand_ready(device
, 100) :
1011 nand_poll_ready(device
, 100);
1013 return ERROR_NAND_OPERATION_TIMEOUT
;
1015 if ((retval
= nand_read_status(device
, &status
)) != ERROR_OK
)
1017 LOG_ERROR("couldn't read status");
1018 return ERROR_NAND_OPERATION_FAILED
;
1021 if (status
& NAND_STATUS_FAIL
)
1023 LOG_ERROR("write operation didn't pass, status: 0x%2.2x", status
);
1024 return ERROR_NAND_OPERATION_FAILED
;
1030 int handle_nand_list_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1037 command_print(cmd_ctx
, "no NAND flash devices configured");
1041 for (p
= nand_devices
; p
; p
= p
->next
)
1044 command_print(cmd_ctx
, "#%i: %s (%s) pagesize: %i, buswidth: %i, erasesize: %i",
1045 i
++, p
->device
->name
, p
->manufacturer
->name
, p
->page_size
, p
->bus_width
, p
->erase_size
);
1047 command_print(cmd_ctx
, "#%i: not probed");
1053 int handle_nand_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1061 if ((argc
< 1) || (argc
> 3))
1063 return ERROR_COMMAND_SYNTAX_ERROR
;
1069 first
= last
= strtoul(args
[1], NULL
, 0);
1073 first
= strtoul(args
[1], NULL
, 0);
1074 last
= strtoul(args
[2], NULL
, 0);
1077 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1082 if (first
>= p
->num_blocks
)
1083 first
= p
->num_blocks
- 1;
1085 if (last
>= p
->num_blocks
)
1086 last
= p
->num_blocks
- 1;
1088 command_print(cmd_ctx
, "#%i: %s (%s) pagesize: %i, buswidth: %i, erasesize: %i",
1089 i
++, p
->device
->name
, p
->manufacturer
->name
, p
->page_size
, p
->bus_width
, p
->erase_size
);
1091 for (j
= first
; j
<= last
; j
++)
1093 char *erase_state
, *bad_state
;
1095 if (p
->blocks
[j
].is_erased
== 0)
1096 erase_state
= "not erased";
1097 else if (p
->blocks
[j
].is_erased
== 1)
1098 erase_state
= "erased";
1100 erase_state
= "erase state unknown";
1102 if (p
->blocks
[j
].is_bad
== 0)
1104 else if (p
->blocks
[j
].is_bad
== 1)
1105 bad_state
= " (marked bad)";
1107 bad_state
= " (block condition unknown)";
1109 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%xkB) %s%s",
1110 j
, p
->blocks
[j
].offset
, p
->blocks
[j
].size
/ 1024,
1111 erase_state
, bad_state
);
1116 command_print(cmd_ctx
, "#%i: not probed");
1123 int handle_nand_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1130 return ERROR_COMMAND_SYNTAX_ERROR
;
1133 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1136 if ((retval
= nand_probe(p
)) == ERROR_OK
)
1138 command_print(cmd_ctx
, "NAND flash device '%s' found", p
->device
->name
);
1140 else if (retval
== ERROR_NAND_OPERATION_FAILED
)
1142 command_print(cmd_ctx
, "probing failed for NAND flash device");
1146 command_print(cmd_ctx
, "unknown error when probing NAND flash device");
1151 command_print(cmd_ctx
, "NAND flash device '#%s' is out of bounds", args
[0]);
1157 int handle_nand_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1164 return ERROR_COMMAND_SYNTAX_ERROR
;
1168 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1171 int first
= strtoul(args
[1], NULL
, 0);
1172 int last
= strtoul(args
[2], NULL
, 0);
1174 if ((retval
= nand_erase(p
, first
, last
)) == ERROR_OK
)
1176 command_print(cmd_ctx
, "successfully erased blocks %i to %i on NAND flash device '%s'", first
, last
, p
->device
->name
);
1178 else if (retval
== ERROR_NAND_OPERATION_FAILED
)
1180 command_print(cmd_ctx
, "erase failed");
1184 command_print(cmd_ctx
, "unknown error when erasing NAND flash device");
1189 command_print(cmd_ctx
, "NAND flash device '#%s' is out of bounds", args
[0]);
1195 int handle_nand_check_bad_blocks_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1202 if ((argc
< 1) || (argc
> 3) || (argc
== 2))
1204 return ERROR_COMMAND_SYNTAX_ERROR
;
1210 first
= strtoul(args
[1], NULL
, 0);
1211 last
= strtoul(args
[2], NULL
, 0);
1214 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1217 if ((retval
= nand_build_bbt(p
, first
, last
)) == ERROR_OK
)
1219 command_print(cmd_ctx
, "checked NAND flash device for bad blocks, use \"nand info\" command to list blocks", p
->device
->name
);
1221 else if (retval
== ERROR_NAND_OPERATION_FAILED
)
1223 command_print(cmd_ctx
, "error when checking for bad blocks on NAND flash device");
1227 command_print(cmd_ctx
, "unknown error when checking for bad blocks on NAND flash device");
1232 command_print(cmd_ctx
, "NAND flash device '#%s' is out of bounds", args
[0]);
1238 int handle_nand_copy_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1244 return ERROR_COMMAND_SYNTAX_ERROR
;
1248 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1255 command_print(cmd_ctx
, "NAND flash device '#%s' is out of bounds", args
[0]);
1261 int handle_nand_write_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1266 enum oob_formats oob_format
= NAND_OOB_NONE
;
1270 duration_t duration
;
1271 char *duration_text
;
1277 return ERROR_COMMAND_SYNTAX_ERROR
;
1281 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1289 offset
= strtoul(args
[2], NULL
, 0);
1294 for (i
= 3; i
< argc
; i
++)
1296 if (!strcmp(args
[i
], "oob_raw"))
1297 oob_format
|= NAND_OOB_RAW
;
1298 else if (!strcmp(args
[i
], "oob_only"))
1299 oob_format
|= NAND_OOB_RAW
| NAND_OOB_ONLY
;
1302 command_print(cmd_ctx
, "unknown option: %s", args
[i
]);
1303 return ERROR_COMMAND_SYNTAX_ERROR
;
1308 duration_start_measure(&duration
);
1310 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
1315 buf_cnt
= binary_size
= fileio
.size
;
1317 if (!(oob_format
& NAND_OOB_ONLY
))
1319 page_size
= p
->page_size
;
1320 page
= malloc(p
->page_size
);
1323 if (oob_format
& NAND_OOB_RAW
)
1325 if (p
->page_size
== 512)
1327 else if (p
->page_size
== 2048)
1329 oob
= malloc(oob_size
);
1332 if (offset
% p
->page_size
)
1334 command_print(cmd_ctx
, "only page size aligned offsets and sizes are supported");
1335 fileio_close(&fileio
);
1347 fileio_read(&fileio
, page_size
, page
, &size_read
);
1348 buf_cnt
-= size_read
;
1349 if (size_read
< page_size
)
1351 memset(page
+ size_read
, 0xff, page_size
- size_read
);
1357 fileio_read(&fileio
, oob_size
, oob
, &size_read
);
1358 buf_cnt
-= size_read
;
1359 if (size_read
< oob_size
)
1361 memset(oob
+ size_read
, 0xff, oob_size
- size_read
);
1365 if (nand_write_page(p
, offset
/ p
->page_size
, page
, page_size
, oob
, oob_size
) != ERROR_OK
)
1367 command_print(cmd_ctx
, "failed writing file %s to NAND flash %s at offset 0x%8.8x",
1368 args
[1], args
[0], offset
);
1370 fileio_close(&fileio
);
1376 offset
+= page_size
;
1379 fileio_close(&fileio
);
1384 duration_stop_measure(&duration
, &duration_text
);
1385 command_print(cmd_ctx
, "wrote file %s to NAND flash %s up to offset 0x%8.8x in %s",
1386 args
[1], args
[0], offset
, duration_text
);
1387 free(duration_text
);
1388 duration_text
= NULL
;
1392 command_print(cmd_ctx
, "NAND flash device '#%s' is out of bounds", args
[0]);
1398 int handle_nand_dump_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1404 return ERROR_COMMAND_SYNTAX_ERROR
;
1407 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1413 duration_t duration
;
1414 char *duration_text
;
1421 u32 address
= strtoul(args
[2], NULL
, 0);
1422 u32 size
= strtoul(args
[3], NULL
, 0);
1424 enum oob_formats oob_format
= NAND_OOB_NONE
;
1429 for (i
= 4; i
< argc
; i
++)
1431 if (!strcmp(args
[i
], "oob_raw"))
1432 oob_format
|= NAND_OOB_RAW
;
1433 else if (!strcmp(args
[i
], "oob_only"))
1434 oob_format
|= NAND_OOB_RAW
| NAND_OOB_ONLY
;
1436 command_print(cmd_ctx
, "unknown option: '%s'", args
[i
]);
1440 if ((address
% p
->page_size
) || (size
% p
->page_size
))
1442 command_print(cmd_ctx
, "only page size aligned addresses and sizes are supported");
1446 if (!(oob_format
& NAND_OOB_ONLY
))
1448 page_size
= p
->page_size
;
1449 page
= malloc(p
->page_size
);
1452 if (oob_format
& NAND_OOB_RAW
)
1454 if (p
->page_size
== 512)
1456 else if (p
->page_size
== 2048)
1458 oob
= malloc(oob_size
);
1461 if (fileio_open(&fileio
, args
[1], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
1466 duration_start_measure(&duration
);
1471 if ((retval
= nand_read_page(p
, address
/ p
->page_size
, page
, page_size
, oob
, oob_size
)) != ERROR_OK
)
1473 command_print(cmd_ctx
, "reading NAND flash page failed");
1476 fileio_close(&fileio
);
1482 fileio_write(&fileio
, page_size
, page
, &size_written
);
1483 bytes_done
+= page_size
;
1488 fileio_write(&fileio
, oob_size
, oob
, &size_written
);
1489 bytes_done
+= oob_size
;
1492 size
-= p
->page_size
;
1493 address
+= p
->page_size
;
1500 fileio_close(&fileio
);
1502 duration_stop_measure(&duration
, &duration_text
);
1503 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
1504 free(duration_text
);
1505 duration_text
= NULL
;
1509 command_print(cmd_ctx
, "#%i: not probed");
1514 command_print(cmd_ctx
, "NAND flash device '#%s' is out of bounds", args
[0]);
1520 int handle_nand_raw_access_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1524 if ((argc
< 1) || (argc
> 2))
1526 return ERROR_COMMAND_SYNTAX_ERROR
;
1529 p
= get_nand_device_by_num(strtoul(args
[0], NULL
, 0));
1536 if (strcmp("enable", args
[1]) == 0)
1540 else if (strcmp("disable", args
[1]) == 0)
1546 return ERROR_COMMAND_SYNTAX_ERROR
;
1550 command_print(cmd_ctx
, "raw access is %s", (p
->use_raw
) ? "enabled" : "disabled");
1554 command_print(cmd_ctx
, "#%i: not probed");
1559 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)