1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
27 #include "time_support.h"
35 #include <sys/types.h>
40 /* command handlers */
41 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
42 int handle_flash_banks_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
43 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
44 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
45 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
46 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
47 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
48 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
49 int handle_flash_write_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
50 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_flash_auto_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
);
58 extern flash_driver_t lpc2000_flash
;
59 extern flash_driver_t cfi_flash
;
60 extern flash_driver_t at91sam7_flash
;
61 extern flash_driver_t str7x_flash
;
62 extern flash_driver_t str9x_flash
;
63 extern flash_driver_t stellaris_flash
;
64 extern flash_driver_t str9xpec_flash
;
65 extern flash_driver_t stm32x_flash
;
66 extern flash_driver_t tms470_flash
;
67 extern flash_driver_t ecosflash_flash
;
69 flash_driver_t
*flash_drivers
[] =
84 flash_bank_t
*flash_banks
;
85 static command_t
*flash_cmd
;
86 static int auto_erase
= 0;
88 /* wafer thin wrapper for invoking the flash driver */
89 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
92 if (bank
->target
->state
!= TARGET_HALTED
)
94 ERROR("target not halted - aborting flash write");
95 retval
=ERROR_TARGET_NOT_HALTED
;
98 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
100 if (retval
!=ERROR_OK
)
102 ERROR("Writing to flash bank at address 0x%08x at offset 0x%8.8x", bank
->base
, offset
);
107 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
110 if (bank
->target
->state
!= TARGET_HALTED
)
112 ERROR("target not halted - aborting flash erase");
113 retval
=ERROR_TARGET_NOT_HALTED
;
114 } else if ((first
< 0) || (last
< first
) || (last
>= bank
->num_sectors
))
116 ERROR("invalid flash sector");
117 retval
=ERROR_FLASH_SECTOR_INVALID
;
120 retval
=bank
->driver
->erase(bank
, first
, last
);
122 if (retval
!=ERROR_OK
)
124 ERROR("Failed erasing banks %d to %d", first
, last
);
129 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
132 if (bank
->target
->state
!= TARGET_HALTED
)
134 ERROR("target not halted - aborting flash erase");
135 retval
=ERROR_TARGET_NOT_HALTED
;
136 } else if ((first
< 0) || (last
< first
) || (last
>= bank
->num_sectors
))
138 ERROR("invalid flash sector");
139 retval
=ERROR_FLASH_SECTOR_INVALID
;
142 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
144 if (retval
!=ERROR_OK
)
146 ERROR("Failed protecting banks %d to %d", first
, last
);
152 int flash_register_commands(struct command_context_s
*cmd_ctx
)
154 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
156 register_command(cmd_ctx
, flash_cmd
, "bank", handle_flash_bank_command
, COMMAND_CONFIG
, "flash_bank <driver> <base> <size> <chip_width> <bus_width> <target> [driver_options ...]");
157 register_command(cmd_ctx
, flash_cmd
, "auto_erase", handle_flash_auto_erase_command
, COMMAND_ANY
,
158 "auto erase flash sectors <on|off>");
162 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
166 register_command(cmd_ctx
, flash_cmd
, "banks", handle_flash_banks_command
, COMMAND_EXEC
,
167 "list configured flash banks ");
168 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
169 "print info about flash bank <num>");
170 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
171 "identify flash bank <num>");
172 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
173 "check erase state of sectors in flash bank <num>");
174 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
175 "check protection state of sectors in flash bank <num>");
176 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
177 "erase sectors at <bank> <first> <last>");
178 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
179 "erase address range <address> <length>");
180 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
181 "write binary data to <bank> <file> <offset>");
182 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
183 "write_image <file> [offset] [type]");
184 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
185 "set protection of sectors at <bank> <first> <last> <on|off>");
191 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
196 for (p
= flash_banks
; p
; p
= p
->next
)
203 ERROR("Flash bank %d does not exist", num
);
207 flash_bank_t
*get_flash_bank_by_num(int num
)
209 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
215 retval
= p
->driver
->auto_probe(p
);
217 if (retval
!= ERROR_OK
)
219 ERROR("auto_probe failed %d\n", retval
);
225 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
233 return ERROR_COMMAND_SYNTAX_ERROR
;
236 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
238 ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
242 for (i
= 0; flash_drivers
[i
]; i
++)
244 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
248 /* register flash specific commands */
249 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
251 ERROR("couldn't register '%s' commands", args
[0]);
255 c
= malloc(sizeof(flash_bank_t
));
257 c
->driver
= flash_drivers
[i
];
258 c
->driver_priv
= NULL
;
259 c
->base
= strtoul(args
[1], NULL
, 0);
260 c
->size
= strtoul(args
[2], NULL
, 0);
261 c
->chip_width
= strtoul(args
[3], NULL
, 0);
262 c
->bus_width
= strtoul(args
[4], NULL
, 0);
267 if (flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
) != ERROR_OK
)
269 ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
274 /* put flash bank in linked list */
277 /* find last flash bank */
278 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
291 /* no matching flash driver found */
294 ERROR("flash driver '%s' not found", args
[0]);
301 int handle_flash_banks_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
308 command_print(cmd_ctx
, "no flash banks configured");
312 for (p
= flash_banks
; p
; p
= p
->next
)
314 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
315 i
++, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
321 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
329 return ERROR_COMMAND_SYNTAX_ERROR
;
332 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
334 if (i
== strtoul(args
[0], NULL
, 0))
338 /* attempt auto probe */
339 p
->driver
->auto_probe(p
);
341 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
342 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
343 for (j
= 0; j
< p
->num_sectors
; j
++)
345 char *erase_state
, *protect_state
;
347 if (p
->sectors
[j
].is_erased
== 0)
348 erase_state
= "not erased";
349 else if (p
->sectors
[j
].is_erased
== 1)
350 erase_state
= "erased";
352 erase_state
= "erase state unknown";
354 if (p
->sectors
[j
].is_protected
== 0)
355 protect_state
= "not protected";
356 else if (p
->sectors
[j
].is_protected
== 1)
357 protect_state
= "protected";
359 protect_state
= "protection state unknown";
361 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s, %s",
362 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
363 erase_state
, protect_state
);
366 p
->driver
->info(p
, buf
, 1024);
367 command_print(cmd_ctx
, "%s", buf
);
374 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
381 return ERROR_COMMAND_SYNTAX_ERROR
;
384 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
387 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
389 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
391 else if (retval
== ERROR_FLASH_BANK_INVALID
)
393 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
398 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
404 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
410 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
417 return ERROR_COMMAND_SYNTAX_ERROR
;
420 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
423 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
425 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
429 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
437 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
446 target_t
*target
= get_current_target(cmd_ctx
);
450 return ERROR_COMMAND_SYNTAX_ERROR
;
453 address
= strtoul(args
[0], NULL
, 0);
454 length
= strtoul(args
[1], NULL
, 0);
457 command_print(cmd_ctx
, "Length must be >0");
458 return ERROR_COMMAND_SYNTAX_ERROR
;
461 p
= get_flash_bank_by_addr(target
, address
);
464 return ERROR_COMMAND_SYNTAX_ERROR
;
467 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
470 duration_start_measure(&duration
);
472 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
474 duration_stop_measure(&duration
, &duration_text
);
475 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
482 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
489 return ERROR_COMMAND_SYNTAX_ERROR
;
492 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
495 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
497 command_print(cmd_ctx
, "successfully checked protect state");
499 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
501 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
505 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
510 return ERROR_COMMAND_SYNTAX_ERROR
;
516 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
520 int first
= strtoul(args
[1], NULL
, 0);
521 int last
= strtoul(args
[2], NULL
, 0);
523 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
527 duration_start_measure(&duration
);
531 return ERROR_COMMAND_SYNTAX_ERROR
;
534 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
536 duration_stop_measure(&duration
, &duration_text
);
538 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
544 return ERROR_COMMAND_SYNTAX_ERROR
;
550 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
554 int first
= strtoul(args
[1], NULL
, 0);
555 int last
= strtoul(args
[2], NULL
, 0);
558 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
561 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
565 if (strcmp(args
[3], "on") == 0)
567 else if (strcmp(args
[3], "off") == 0)
571 return ERROR_COMMAND_SYNTAX_ERROR
;
574 retval
= flash_driver_protect(p
, set
, first
, last
);
575 if (retval
== ERROR_OK
)
577 command_print(cmd_ctx
, "%s protection for sectors %i through %i on flash bank %i", (set
) ? "set" : "cleared", first
, last
, strtoul(args
[0], 0, 0));
582 return ERROR_COMMAND_SYNTAX_ERROR
;
589 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
591 target_t
*target
= get_current_target(cmd_ctx
);
603 return ERROR_COMMAND_SYNTAX_ERROR
;
609 ERROR("no target selected");
613 duration_start_measure(&duration
);
617 image
.base_address_set
= 1;
618 image
.base_address
= strtoul(args
[1], NULL
, 0);
622 image
.base_address_set
= 0;
623 image
.base_address
= 0x0;
626 image
.start_address_set
= 0;
628 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
629 if (retval
!= ERROR_OK
)
631 command_print(cmd_ctx
, "image_open error: %s", image
.error_str
);
635 retval
= flash_write(target
, &image
, &written
, auto_erase
);
637 if (retval
!= ERROR_OK
)
643 duration_stop_measure(&duration
, &duration_text
);
644 if (retval
== ERROR_OK
)
646 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
647 written
, args
[0], duration_text
,
648 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
657 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
673 return ERROR_COMMAND_SYNTAX_ERROR
;
676 duration_start_measure(&duration
);
678 offset
= strtoul(args
[2], NULL
, 0);
679 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
682 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
686 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
688 command_print(cmd_ctx
, "flash write_binary error: %s", fileio
.error_str
);
692 buffer
= malloc(fileio
.size
);
693 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
695 command_print(cmd_ctx
, "flash write_binary error: %s", fileio
.error_str
);
699 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
703 duration_stop_measure(&duration
, &duration_text
);
704 if (retval
!=ERROR_OK
)
706 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
707 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
708 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
712 fileio_close(&fileio
);
717 void flash_set_dirty(void)
722 /* set all flash to require erasing */
723 for (c
= flash_banks
; c
; c
= c
->next
)
725 for (i
= 0; i
< c
->num_sectors
; i
++)
727 c
->sectors
[i
].is_erased
= 0;
732 /* lookup flash bank by address */
733 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
737 /* cycle through bank list */
738 for (c
= flash_banks
; c
; c
= c
->next
)
741 retval
= c
->driver
->auto_probe(c
);
743 if (retval
!= ERROR_OK
)
745 ERROR("auto_probe failed %d\n", retval
);
748 /* check whether address belongs to this flash bank */
749 if ((addr
>= c
->base
) && (addr
< c
->base
+ c
->size
) && target
== c
->target
)
752 ERROR("No flash at address 0x%08x\n", addr
);
756 /* erase given flash region, selects proper bank according to target and address */
757 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
764 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
765 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
767 if (c
->size
== 0 || c
->num_sectors
== 0)
768 return ERROR_FLASH_BANK_INVALID
;
772 /* special case, erase whole bank when length is zero */
774 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
776 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
779 /* check whether it fits */
780 if (addr
+ length
> c
->base
+ c
->size
)
781 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
785 for (i
= 0; i
< c
->num_sectors
; i
++)
787 /* check whether sector overlaps with the given range and is not yet erased */
788 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
789 /* if first is not set yet then this is the first sector */
792 last
= i
; /* and it is the last one so far in any case */
796 if( first
== -1 || last
== -1 )
799 return flash_driver_erase(c
, first
, last
);
802 /* write (optional verify) an image to flash memory of the given target */
803 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
819 /* assume all sectors need erasing - stops any problems
820 * when flash_write is called multiple times */
825 /* loop until we reach end of the image */
826 while (section
< image
->num_sections
)
832 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
833 u32 run_size
= image
->sections
[section
].size
- section_offset
;
835 if (image
->sections
[section
].size
== 0)
837 WARNING("empty section %d", section
);
843 /* find the corresponding flash bank */
844 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
846 section
++; /* and skip it */
851 /* collect consecutive sections which fall into the same bank */
852 section_first
= section
;
853 section_last
= section
;
854 while ((run_address
+ run_size
< c
->base
+ c
->size
)
855 && (section_last
+ 1 < image
->num_sections
))
857 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
859 DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
862 if (image
->sections
[section_last
+ 1].base_address
!= (run_address
+ run_size
))
864 run_size
+= image
->sections
[++section_last
].size
;
867 /* fit the run into bank constraints */
868 if (run_address
+ run_size
> c
->base
+ c
->size
)
869 run_size
= c
->base
+ c
->size
- run_address
;
871 /* allocate buffer */
872 buffer
= malloc(run_size
);
875 /* read sections to the buffer */
876 while (buffer_size
< run_size
)
880 if (buffer_size
- run_size
<= image
->sections
[section
].size
- section_offset
)
881 size_read
= buffer_size
- run_size
;
883 size_read
= image
->sections
[section
].size
- section_offset
;
885 if ((retval
= image_read_section(image
, section
, section_offset
,
886 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
893 buffer_size
+= size_read
;
894 section_offset
+= size_read
;
896 if (section_offset
>= image
->sections
[section
].size
)
907 /* calculate and erase sectors */
908 retval
= flash_erase_address_range( target
, run_address
, run_size
);
911 if (retval
== ERROR_OK
)
913 /* write flash sectors */
914 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
919 if (retval
!= ERROR_OK
)
921 return retval
; /* abort operation */
925 *written
+= run_size
; /* add run size to total written counter */
931 int handle_flash_auto_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
935 return ERROR_COMMAND_SYNTAX_ERROR
;
939 if (strcmp(args
[0], "on") == 0)
941 else if (strcmp(args
[0], "off") == 0)
944 return ERROR_COMMAND_SYNTAX_ERROR
;