1 /***************************************************************************
2 * Copyright (C) 2007 by Dominic Rath <Dominic.Rath@gmx.de> *
3 * Copyright (C) 2002 Thomas Gleixner <tglx@linutronix.de> *
4 * Copyright (C) 2009 Zachary T Welch <zw@superlucidity.net> *
6 * Partially based on drivers/mtd/nand_ids.c from Linux. *
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 ***************************************************************************/
32 extern struct nand_device
*nand_devices
;
34 COMMAND_HANDLER(handle_nand_list_command
)
36 struct nand_device
*p
;
41 command_print(CMD_CTX
, "no NAND flash devices configured");
45 for (p
= nand_devices
, i
= 0; p
; p
= p
->next
, i
++)
48 command_print(CMD_CTX
, "#%i: %s (%s) "
49 "pagesize: %i, buswidth: %i,\n\t"
50 "blocksize: %i, blocks: %i",
51 i
, p
->device
->name
, p
->manufacturer
->name
,
52 p
->page_size
, p
->bus_width
,
53 p
->erase_size
, p
->num_blocks
);
55 command_print(CMD_CTX
, "#%i: not probed", i
);
61 COMMAND_HANDLER(handle_nand_info_command
)
70 return ERROR_COMMAND_SYNTAX_ERROR
;
76 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[1], i
);
81 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[1], first
);
82 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[2], last
);
86 struct nand_device
*p
;
87 int retval
= CALL_COMMAND_HANDLER(nand_command_get_device
, 0, &p
);
88 if (ERROR_OK
!= retval
)
91 if (NULL
== p
->device
)
93 command_print(CMD_CTX
, "#%s: not probed", CMD_ARGV
[0]);
97 if (first
>= p
->num_blocks
)
98 first
= p
->num_blocks
- 1;
100 if (last
>= p
->num_blocks
)
101 last
= p
->num_blocks
- 1;
103 command_print(CMD_CTX
, "#%i: %s (%s) pagesize: %i, buswidth: %i, erasesize: %i",
104 i
++, p
->device
->name
, p
->manufacturer
->name
, p
->page_size
, p
->bus_width
, p
->erase_size
);
106 for (j
= first
; j
<= last
; j
++)
108 char *erase_state
, *bad_state
;
110 if (p
->blocks
[j
].is_erased
== 0)
111 erase_state
= "not erased";
112 else if (p
->blocks
[j
].is_erased
== 1)
113 erase_state
= "erased";
115 erase_state
= "erase state unknown";
117 if (p
->blocks
[j
].is_bad
== 0)
119 else if (p
->blocks
[j
].is_bad
== 1)
120 bad_state
= " (marked bad)";
122 bad_state
= " (block condition unknown)";
124 command_print(CMD_CTX
,
125 "\t#%i: 0x%8.8" PRIx32
" (%" PRId32
"kB) %s%s",
128 p
->blocks
[j
].size
/ 1024,
136 COMMAND_HANDLER(handle_nand_probe_command
)
140 return ERROR_COMMAND_SYNTAX_ERROR
;
143 struct nand_device
*p
;
144 int retval
= CALL_COMMAND_HANDLER(nand_command_get_device
, 0, &p
);
145 if (ERROR_OK
!= retval
)
148 if ((retval
= nand_probe(p
)) == ERROR_OK
)
150 command_print(CMD_CTX
, "NAND flash device '%s' found", p
->device
->name
);
152 else if (retval
== ERROR_NAND_OPERATION_FAILED
)
154 command_print(CMD_CTX
, "probing failed for NAND flash device");
158 command_print(CMD_CTX
, "unknown error when probing NAND flash device");
164 COMMAND_HANDLER(handle_nand_erase_command
)
166 if (CMD_ARGC
!= 1 && CMD_ARGC
!= 3)
168 return ERROR_COMMAND_SYNTAX_ERROR
;
172 struct nand_device
*p
;
173 int retval
= CALL_COMMAND_HANDLER(nand_command_get_device
, 0, &p
);
174 if (ERROR_OK
!= retval
)
177 unsigned long offset
;
178 unsigned long length
;
180 /* erase specified part of the chip; or else everything */
182 unsigned long size
= p
->erase_size
* p
->num_blocks
;
184 COMMAND_PARSE_NUMBER(ulong
, CMD_ARGV
[1], offset
);
185 if ((offset
% p
->erase_size
) != 0 || offset
>= size
)
186 return ERROR_INVALID_ARGUMENTS
;
188 COMMAND_PARSE_NUMBER(ulong
, CMD_ARGV
[2], length
);
189 if ((length
== 0) || (length
% p
->erase_size
) != 0
190 || (length
+ offset
) > size
)
191 return ERROR_INVALID_ARGUMENTS
;
193 offset
/= p
->erase_size
;
194 length
/= p
->erase_size
;
197 length
= p
->num_blocks
;
200 retval
= nand_erase(p
, offset
, offset
+ length
- 1);
201 if (retval
== ERROR_OK
)
203 command_print(CMD_CTX
, "erased blocks %lu to %lu "
204 "on NAND flash device #%s '%s'",
205 offset
, offset
+ length
,
206 CMD_ARGV
[0], p
->device
->name
);
208 else if (retval
== ERROR_NAND_OPERATION_FAILED
)
210 command_print(CMD_CTX
, "erase failed");
214 command_print(CMD_CTX
, "unknown error when erasing NAND flash device");
220 COMMAND_HANDLER(handle_nand_check_bad_blocks_command
)
225 if ((CMD_ARGC
< 1) || (CMD_ARGC
> 3) || (CMD_ARGC
== 2))
227 return ERROR_COMMAND_SYNTAX_ERROR
;
231 struct nand_device
*p
;
232 int retval
= CALL_COMMAND_HANDLER(nand_command_get_device
, 0, &p
);
233 if (ERROR_OK
!= retval
)
238 unsigned long offset
;
239 unsigned long length
;
241 COMMAND_PARSE_NUMBER(ulong
, CMD_ARGV
[1], offset
);
242 if (offset
% p
->erase_size
)
243 return ERROR_INVALID_ARGUMENTS
;
244 offset
/= p
->erase_size
;
246 COMMAND_PARSE_NUMBER(ulong
, CMD_ARGV
[2], length
);
247 if (length
% p
->erase_size
)
248 return ERROR_INVALID_ARGUMENTS
;
251 length
/= p
->erase_size
;
254 last
= offset
+ length
;
257 retval
= nand_build_bbt(p
, first
, last
);
258 if (retval
== ERROR_OK
)
260 command_print(CMD_CTX
, "checked NAND flash device for bad blocks, "
261 "use \"nand info\" command to list blocks");
263 else if (retval
== ERROR_NAND_OPERATION_FAILED
)
265 command_print(CMD_CTX
, "error when checking for bad blocks on "
266 "NAND flash device");
270 command_print(CMD_CTX
, "unknown error when checking for bad "
271 "blocks on NAND flash device");
277 COMMAND_HANDLER(handle_nand_write_command
)
279 struct nand_device
*nand
= NULL
;
280 struct nand_fileio_state s
;
281 int retval
= CALL_COMMAND_HANDLER(nand_fileio_parse_args
,
282 &s
, &nand
, FILEIO_READ
, false, true);
283 if (ERROR_OK
!= retval
)
286 uint32_t total_bytes
= s
.size
;
289 int bytes_read
= nand_fileio_read(nand
, &s
);
292 command_print(CMD_CTX
, "error while reading file");
293 return nand_fileio_cleanup(&s
);
295 s
.size
-= bytes_read
;
297 retval
= nand_write_page(nand
, s
.address
/ nand
->page_size
,
298 s
.page
, s
.page_size
, s
.oob
, s
.oob_size
);
299 if (ERROR_OK
!= retval
)
301 command_print(CMD_CTX
, "failed writing file %s "
302 "to NAND flash %s at offset 0x%8.8" PRIx32
,
303 CMD_ARGV
[1], CMD_ARGV
[0], s
.address
);
304 return nand_fileio_cleanup(&s
);
306 s
.address
+= s
.page_size
;
309 if (nand_fileio_finish(&s
))
311 command_print(CMD_CTX
, "wrote file %s to NAND flash %s up to "
312 "offset 0x%8.8" PRIx32
" in %fs (%0.3f kb/s)",
313 CMD_ARGV
[1], CMD_ARGV
[0], s
.address
, duration_elapsed(&s
.bench
),
314 duration_kbps(&s
.bench
, total_bytes
));
319 COMMAND_HANDLER(handle_nand_verify_command
)
321 struct nand_device
*nand
= NULL
;
322 struct nand_fileio_state file
;
323 int retval
= CALL_COMMAND_HANDLER(nand_fileio_parse_args
,
324 &file
, &nand
, FILEIO_READ
, false, true);
325 if (ERROR_OK
!= retval
)
328 struct nand_fileio_state dev
;
329 nand_fileio_init(&dev
);
330 dev
.address
= file
.address
;
331 dev
.size
= file
.size
;
332 dev
.oob_format
= file
.oob_format
;
333 retval
= nand_fileio_start(CMD_CTX
, nand
, NULL
, FILEIO_NONE
, &dev
);
334 if (ERROR_OK
!= retval
)
337 while (file
.size
> 0)
339 int retval
= nand_read_page(nand
, dev
.address
/ dev
.page_size
,
340 dev
.page
, dev
.page_size
, dev
.oob
, dev
.oob_size
);
341 if (ERROR_OK
!= retval
)
343 command_print(CMD_CTX
, "reading NAND flash page failed");
344 nand_fileio_cleanup(&dev
);
345 return nand_fileio_cleanup(&file
);
348 int bytes_read
= nand_fileio_read(nand
, &file
);
351 command_print(CMD_CTX
, "error while reading file");
352 nand_fileio_cleanup(&dev
);
353 return nand_fileio_cleanup(&file
);
356 if ((dev
.page
&& memcmp(dev
.page
, file
.page
, dev
.page_size
)) ||
357 (dev
.oob
&& memcmp(dev
.oob
, file
.oob
, dev
.oob_size
)) )
359 command_print(CMD_CTX
, "NAND flash contents differ "
360 "at 0x%8.8" PRIx32
, dev
.address
);
361 nand_fileio_cleanup(&dev
);
362 return nand_fileio_cleanup(&file
);
365 file
.size
-= bytes_read
;
366 dev
.address
+= nand
->page_size
;
369 if (nand_fileio_finish(&file
) == ERROR_OK
)
371 command_print(CMD_CTX
, "verified file %s in NAND flash %s "
372 "up to offset 0x%8.8" PRIx32
" in %fs (%0.3f kb/s)",
373 CMD_ARGV
[1], CMD_ARGV
[0], dev
.address
, duration_elapsed(&file
.bench
),
374 duration_kbps(&file
.bench
, dev
.size
));
377 return nand_fileio_cleanup(&dev
);
380 COMMAND_HANDLER(handle_nand_dump_command
)
382 struct nand_device
*nand
= NULL
;
383 struct nand_fileio_state s
;
384 int retval
= CALL_COMMAND_HANDLER(nand_fileio_parse_args
,
385 &s
, &nand
, FILEIO_WRITE
, true, false);
386 if (ERROR_OK
!= retval
)
392 int retval
= nand_read_page(nand
, s
.address
/ nand
->page_size
,
393 s
.page
, s
.page_size
, s
.oob
, s
.oob_size
);
394 if (ERROR_OK
!= retval
)
396 command_print(CMD_CTX
, "reading NAND flash page failed");
397 return nand_fileio_cleanup(&s
);
401 fileio_write(&s
.fileio
, s
.page_size
, s
.page
, &size_written
);
404 fileio_write(&s
.fileio
, s
.oob_size
, s
.oob
, &size_written
);
406 s
.size
-= nand
->page_size
;
407 s
.address
+= nand
->page_size
;
410 if (nand_fileio_finish(&s
) == ERROR_OK
)
412 command_print(CMD_CTX
, "dumped %ld bytes in %fs (%0.3f kb/s)",
413 (long)s
.fileio
.size
, duration_elapsed(&s
.bench
),
414 duration_kbps(&s
.bench
, s
.fileio
.size
));
419 COMMAND_HANDLER(handle_nand_raw_access_command
)
421 if ((CMD_ARGC
< 1) || (CMD_ARGC
> 2))
423 return ERROR_COMMAND_SYNTAX_ERROR
;
426 struct nand_device
*p
;
427 int retval
= CALL_COMMAND_HANDLER(nand_command_get_device
, 0, &p
);
428 if (ERROR_OK
!= retval
)
431 if (NULL
== p
->device
)
433 command_print(CMD_CTX
, "#%s: not probed", CMD_ARGV
[0]);
438 COMMAND_PARSE_ENABLE(CMD_ARGV
[1], p
->use_raw
);
440 const char *msg
= p
->use_raw
? "enabled" : "disabled";
441 command_print(CMD_CTX
, "raw access is %s", msg
);
446 static const struct command_registration nand_exec_command_handlers
[] = {
449 .handler
= handle_nand_list_command
,
450 .mode
= COMMAND_EXEC
,
451 .help
= "list configured NAND flash devices",
455 .handler
= handle_nand_info_command
,
456 .mode
= COMMAND_EXEC
,
457 .usage
= "[banknum | first_bank_num last_bank_num]",
458 .help
= "print info about one or more NAND flash devices",
462 .handler
= handle_nand_probe_command
,
463 .mode
= COMMAND_EXEC
,
465 .help
= "identify NAND flash device",
468 .name
= "check_bad_blocks",
469 .handler
= handle_nand_check_bad_blocks_command
,
470 .mode
= COMMAND_EXEC
,
471 .usage
= "bank_id [offset length]",
472 .help
= "check all or part of NAND flash device for bad blocks",
476 .handler
= handle_nand_erase_command
,
477 .mode
= COMMAND_EXEC
,
478 .usage
= "bank_id [offset length]",
479 .help
= "erase all or subset of blocks on NAND flash device",
483 .handler
= handle_nand_dump_command
,
484 .mode
= COMMAND_EXEC
,
485 .usage
= "bank_id filename offset length "
486 "['oob_raw'|'oob_only']",
487 .help
= "dump from NAND flash device",
491 .handler
= handle_nand_verify_command
,
492 .mode
= COMMAND_EXEC
,
493 .usage
= "bank_id filename offset "
494 "['oob_raw'|'oob_only'|'oob_softecc'|'oob_softecc_kw']",
495 .help
= "verify NAND flash device",
499 .handler
= handle_nand_write_command
,
500 .mode
= COMMAND_EXEC
,
501 .usage
= "bank_id filename offset "
502 "['oob_raw'|'oob_only'|'oob_softecc'|'oob_softecc_kw']",
503 .help
= "write to NAND flash device",
506 .name
= "raw_access",
507 .handler
= handle_nand_raw_access_command
,
508 .mode
= COMMAND_EXEC
,
509 .usage
= "bank_id ['enable'|'disable']",
510 .help
= "raw access to NAND flash device",
512 COMMAND_REGISTRATION_DONE
515 int nand_init(struct command_context
*cmd_ctx
)
519 struct command
*parent
= command_find_in_context(cmd_ctx
, "nand");
520 return register_commands(cmd_ctx
, parent
, nand_exec_command_handlers
);
523 COMMAND_HANDLER(handle_nand_init_command
)
526 return ERROR_COMMAND_SYNTAX_ERROR
;
528 static bool nand_initialized
= false;
529 if (nand_initialized
)
531 LOG_INFO("'nand init' has already been called");
534 nand_initialized
= true;
536 LOG_DEBUG("Initializing NAND devices...");
537 return nand_init(CMD_CTX
);
539 int nand_list_walker(struct nand_flash_controller
*c
, void *x
)
541 struct command_context
*cmd_ctx
= (struct command_context
*)x
;
542 command_print(cmd_ctx
, " %s", c
->name
);
545 COMMAND_HANDLER(handle_nand_list_drivers
)
547 command_print(CMD_CTX
, "Available NAND flash controller drivers:");
548 return nand_driver_walk(&nand_list_walker
, CMD_CTX
);
551 static COMMAND_HELPER(create_nand_device
, const char *bank_name
,
552 struct nand_flash_controller
*controller
)
554 if (NULL
!= controller
->commands
)
556 int retval
= register_commands(CMD_CTX
, NULL
,
557 controller
->commands
);
558 if (ERROR_OK
!= retval
)
561 struct nand_device
*c
= malloc(sizeof(struct nand_device
));
563 c
->name
= strdup(bank_name
);
564 c
->controller
= controller
;
565 c
->controller_priv
= NULL
;
566 c
->manufacturer
= NULL
;
569 c
->address_cycles
= 0;
574 int retval
= CALL_COMMAND_HANDLER(controller
->nand_device_command
, c
);
575 if (ERROR_OK
!= retval
)
577 LOG_ERROR("'%s' driver rejected nand flash", controller
->name
);
587 COMMAND_HANDLER(handle_nand_device_command
)
591 LOG_ERROR("incomplete nand device configuration");
592 return ERROR_FLASH_BANK_INVALID
;
595 // save name and increment (for compatibility) with drivers
596 const char *bank_name
= *CMD_ARGV
++;
599 const char *driver_name
= CMD_ARGV
[0];
600 struct nand_flash_controller
*controller
;
601 controller
= nand_driver_find_by_name(CMD_ARGV
[0]);
602 if (NULL
== controller
)
604 LOG_ERROR("No valid NAND flash driver found (%s)", driver_name
);
605 return CALL_COMMAND_HANDLER(handle_nand_list_drivers
);
607 return CALL_COMMAND_HANDLER(create_nand_device
, bank_name
, controller
);
610 static const struct command_registration nand_config_command_handlers
[] = {
613 .handler
= &handle_nand_device_command
,
614 .mode
= COMMAND_CONFIG
,
615 .help
= "defines a new NAND bank",
616 .usage
= "bank_id driver target [driver_options ...]",
620 .handler
= &handle_nand_list_drivers
,
622 .help
= "lists available NAND drivers",
626 .mode
= COMMAND_CONFIG
,
627 .handler
= &handle_nand_init_command
,
628 .help
= "initialize NAND devices",
630 COMMAND_REGISTRATION_DONE
632 static const struct command_registration nand_command_handlers
[] = {
636 .help
= "NAND flash command group",
637 .chain
= nand_config_command_handlers
,
639 COMMAND_REGISTRATION_DONE
642 int nand_register_commands(struct command_context
*cmd_ctx
)
644 return register_commands(cmd_ctx
, NULL
, nand_command_handlers
);