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
;
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)