1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath <Dominic.Rath@gmx.de> *
3 * Copyright (C) 2007,2008 Øyvind Harboe <oyvind.harboe@zylin.com> *
4 * Copyright (C) 2008 by Spencer Oliver <spen@spen-soft.co.uk> *
5 * Copyright (C) 2009 Zachary T Welch <zw@superlucidity.net> *
7 * This program is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation; either version 2 of the License, or *
10 * (at your option) any later version. *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
17 * You should have received a copy of the GNU General Public License *
18 * along with this program; if not, write to the *
19 * Free Software Foundation, Inc., *
20 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
21 ***************************************************************************/
26 #include <helper/time_support.h>
27 #include <target/image.h>
31 * Implements Tcl commands used to access NOR flash facilities.
34 COMMAND_HELPER(flash_command_get_bank
, unsigned name_index
,
35 struct flash_bank
**bank
)
37 const char *name
= CMD_ARGV
[name_index
];
38 *bank
= get_flash_bank_by_name(name
);
43 COMMAND_PARSE_NUMBER(uint
, name
, bank_num
);
45 return get_flash_bank_by_num(bank_num
, bank
);
49 COMMAND_HANDLER(handle_flash_info_command
)
56 return ERROR_COMMAND_SYNTAX_ERROR
;
58 retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &p
);
59 if (retval
!= ERROR_OK
)
66 /* attempt auto probe */
67 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
70 /* We must query the hardware to avoid printing stale information! */
71 retval
= p
->driver
->protect_check(p
);
72 if (retval
!= ERROR_OK
)
75 command_print(CMD_CTX
,
76 "#%" PRIu32
" : %s at 0x%8.8" PRIx32
", size 0x%8.8" PRIx32
", buswidth %i, chipwidth %i",
83 for (j
= 0; j
< p
->num_sectors
; j
++)
87 if (p
->sectors
[j
].is_protected
== 0)
88 protect_state
= "not protected";
89 else if (p
->sectors
[j
].is_protected
== 1)
90 protect_state
= "protected";
92 protect_state
= "protection state unknown";
94 command_print(CMD_CTX
,
95 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
99 p
->sectors
[j
].size
>> 10,
103 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
104 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
105 command_print(CMD_CTX
, "%s", buf
);
106 if (retval
!= ERROR_OK
)
107 LOG_ERROR("error retrieving flash info (%d)", retval
);
113 COMMAND_HANDLER(handle_flash_probe_command
)
115 struct flash_bank
*p
;
120 return ERROR_COMMAND_SYNTAX_ERROR
;
123 retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &p
);
124 if (retval
!= ERROR_OK
)
129 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
131 command_print(CMD_CTX
, "flash '%s' found at 0x%8.8" PRIx32
, p
->driver
->name
, p
->base
);
133 else if (retval
== ERROR_FLASH_BANK_INVALID
)
135 command_print(CMD_CTX
, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32
,
136 CMD_ARGV
[0], p
->base
);
140 command_print(CMD_CTX
, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32
,
141 CMD_ARGV
[0], p
->base
);
146 command_print(CMD_CTX
, "flash bank '#%s' is out of bounds", CMD_ARGV
[0]);
152 COMMAND_HANDLER(handle_flash_erase_check_command
)
156 return ERROR_COMMAND_SYNTAX_ERROR
;
159 struct flash_bank
*p
;
160 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &p
);
161 if (ERROR_OK
!= retval
)
165 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
167 command_print(CMD_CTX
, "successfully checked erase state");
171 command_print(CMD_CTX
, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32
,
172 CMD_ARGV
[0], p
->base
);
175 for (j
= 0; j
< p
->num_sectors
; j
++)
179 if (p
->sectors
[j
].is_erased
== 0)
180 erase_state
= "not erased";
181 else if (p
->sectors
[j
].is_erased
== 1)
182 erase_state
= "erased";
184 erase_state
= "erase state unknown";
186 command_print(CMD_CTX
,
187 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
189 p
->sectors
[j
].offset
,
191 p
->sectors
[j
].size
>> 10,
198 COMMAND_HANDLER(handle_flash_erase_address_command
)
200 struct flash_bank
*p
;
201 int retval
= ERROR_OK
;
205 bool do_unlock
= false;
206 struct target
*target
= get_current_target(CMD_CTX
);
208 while (CMD_ARGC
>= 3)
210 /* Optionally pad out the address range to block/sector
211 * boundaries. We can't know if there's data in that part
212 * of the flash; only do padding if we're told to.
214 if (strcmp("pad", CMD_ARGV
[0]) == 0)
217 } else if (strcmp("unlock", CMD_ARGV
[0]) == 0)
222 return ERROR_COMMAND_SYNTAX_ERROR
;
229 return ERROR_COMMAND_SYNTAX_ERROR
;
232 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[0], address
);
233 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[1], length
);
237 command_print(CMD_CTX
, "Length must be >0");
238 return ERROR_COMMAND_SYNTAX_ERROR
;
241 p
= get_flash_bank_by_addr(target
, address
);
247 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
250 struct duration bench
;
251 duration_start(&bench
);
255 retval
= flash_unlock_address_range(target
, address
, length
);
258 if (retval
== ERROR_OK
)
260 retval
= flash_erase_address_range(target
, do_pad
, address
, length
);
263 if ((ERROR_OK
== retval
) && (duration_measure(&bench
) == ERROR_OK
))
265 command_print(CMD_CTX
, "erased address 0x%8.8x (length %i)"
266 " in %fs (%0.3f kb/s)", address
, length
,
267 duration_elapsed(&bench
), duration_kbps(&bench
, length
));
273 static int flash_check_sector_parameters(struct command_context
*cmd_ctx
,
274 uint32_t first
, uint32_t last
, uint32_t num_sectors
)
276 if (!(first
<= last
)) {
277 command_print(cmd_ctx
, "ERROR: "
278 "first sector must be <= last sector");
282 if (!(last
<= (num_sectors
- 1))) {
283 command_print(cmd_ctx
, "ERROR: last sector must be <= %d",
284 (int) num_sectors
- 1);
291 COMMAND_HANDLER(handle_flash_erase_command
)
294 return ERROR_COMMAND_SYNTAX_ERROR
;
299 struct flash_bank
*p
;
302 retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &p
);
303 if (retval
!= ERROR_OK
)
306 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], first
);
307 if (strcmp(CMD_ARGV
[2], "last") == 0)
308 last
= p
->num_sectors
- 1;
310 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], last
);
312 if ((retval
= flash_check_sector_parameters(CMD_CTX
,
313 first
, last
, p
->num_sectors
)) != ERROR_OK
)
316 struct duration bench
;
317 duration_start(&bench
);
319 retval
= flash_driver_erase(p
, first
, last
);
321 if ((ERROR_OK
== retval
) && (duration_measure(&bench
) == ERROR_OK
))
323 command_print(CMD_CTX
, "erased sectors %" PRIu32
" "
324 "through %" PRIu32
" on flash bank %" PRIu32
" "
325 "in %fs", first
, last
, p
->bank_number
, duration_elapsed(&bench
));
331 COMMAND_HANDLER(handle_flash_protect_command
)
334 return ERROR_COMMAND_SYNTAX_ERROR
;
339 struct flash_bank
*p
;
342 retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &p
);
343 if (retval
!= ERROR_OK
)
346 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], first
);
347 if (strcmp(CMD_ARGV
[2], "last") == 0)
348 last
= p
->num_sectors
- 1;
350 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], last
);
353 COMMAND_PARSE_ON_OFF(CMD_ARGV
[3], set
);
355 if ((retval
= flash_check_sector_parameters(CMD_CTX
,
356 first
, last
, p
->num_sectors
)) != ERROR_OK
)
359 retval
= flash_driver_protect(p
, set
, first
, last
);
360 if (retval
== ERROR_OK
) {
361 command_print(CMD_CTX
, "%s protection for sectors %i "
362 "through %i on flash bank %" PRIu32
"",
363 (set
) ? "set" : "cleared", (int) first
,
364 (int) last
, p
->bank_number
);
370 COMMAND_HANDLER(handle_flash_write_image_command
)
372 struct target
*target
= get_current_target(CMD_CTX
);
381 return ERROR_COMMAND_SYNTAX_ERROR
;
384 /* flash auto-erase is disabled by default*/
386 bool auto_unlock
= false;
390 if (strcmp(CMD_ARGV
[0], "erase") == 0)
395 command_print(CMD_CTX
, "auto erase enabled");
396 } else if (strcmp(CMD_ARGV
[0], "unlock") == 0)
401 command_print(CMD_CTX
, "auto unlock enabled");
410 return ERROR_COMMAND_SYNTAX_ERROR
;
415 LOG_ERROR("no target selected");
419 struct duration bench
;
420 duration_start(&bench
);
424 image
.base_address_set
= 1;
425 COMMAND_PARSE_NUMBER(llong
, CMD_ARGV
[1], image
.base_address
);
429 image
.base_address_set
= 0;
430 image
.base_address
= 0x0;
433 image
.start_address_set
= 0;
435 retval
= image_open(&image
, CMD_ARGV
[0], (CMD_ARGC
== 3) ? CMD_ARGV
[2] : NULL
);
436 if (retval
!= ERROR_OK
)
441 retval
= flash_write_unlock(target
, &image
, &written
, auto_erase
, auto_unlock
);
442 if (retval
!= ERROR_OK
)
448 if ((ERROR_OK
== retval
) && (duration_measure(&bench
) == ERROR_OK
))
450 command_print(CMD_CTX
, "wrote %" PRIu32
" bytes from file %s "
451 "in %fs (%0.3f kb/s)", written
, CMD_ARGV
[0],
452 duration_elapsed(&bench
), duration_kbps(&bench
, written
));
460 COMMAND_HANDLER(handle_flash_fill_command
)
467 uint32_t cur_size
= 0;
468 uint32_t chunk_count
;
469 struct target
*target
= get_current_target(CMD_CTX
);
472 int retval
= ERROR_OK
;
474 static size_t const chunksize
= 1024;
475 uint8_t *chunk
= malloc(chunksize
);
479 uint8_t *readback
= malloc(chunksize
);
480 if (readback
== NULL
)
489 retval
= ERROR_COMMAND_SYNTAX_ERROR
;
494 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], address
);
495 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], pattern
);
496 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], count
);
513 retval
= ERROR_COMMAND_SYNTAX_ERROR
;
517 chunk_count
= MIN(count
, (chunksize
/ wordsize
));
521 for (i
= 0; i
< chunk_count
; i
++)
523 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
527 for (i
= 0; i
< chunk_count
; i
++)
529 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
533 memset(chunk
, pattern
, chunk_count
);
536 LOG_ERROR("BUG: can't happen");
540 struct duration bench
;
541 duration_start(&bench
);
543 for (wrote
= 0; wrote
< (count
*wordsize
); wrote
+= cur_size
)
545 struct flash_bank
*bank
;
547 bank
= get_flash_bank_by_addr(target
, address
);
554 cur_size
= MIN((count
* wordsize
- wrote
), chunksize
);
555 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
562 err
= target_read_buffer(target
, address
+ wrote
, cur_size
, readback
);
570 for (i
= 0; i
< cur_size
; i
++)
572 if (readback
[i
]!=chunk
[i
])
574 LOG_ERROR("Verfication error address 0x%08" PRIx32
", read back 0x%02x, expected 0x%02x",
575 address
+ wrote
+ i
, readback
[i
], chunk
[i
]);
582 if (duration_measure(&bench
) == ERROR_OK
)
584 command_print(CMD_CTX
, "wrote %" PRIu32
" bytes to 0x%8.8" PRIx32
585 " in %fs (%0.3f kb/s)", wrote
, address
,
586 duration_elapsed(&bench
), duration_kbps(&bench
, wrote
));
596 COMMAND_HANDLER(handle_flash_write_bank_command
)
600 struct fileio fileio
;
603 return ERROR_COMMAND_SYNTAX_ERROR
;
605 struct duration bench
;
606 duration_start(&bench
);
608 struct flash_bank
*p
;
609 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &p
);
610 if (ERROR_OK
!= retval
)
613 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], offset
);
615 if (fileio_open(&fileio
, CMD_ARGV
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
620 buffer
= malloc(fileio
.size
);
622 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
625 fileio_close(&fileio
);
629 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
634 if ((ERROR_OK
== retval
) && (duration_measure(&bench
) == ERROR_OK
))
636 command_print(CMD_CTX
, "wrote %ld bytes from file %s to flash bank %u"
637 " at offset 0x%8.8" PRIx32
" in %fs (%0.3f kb/s)",
638 (long)fileio
.size
, CMD_ARGV
[1], p
->bank_number
, offset
,
639 duration_elapsed(&bench
), duration_kbps(&bench
, fileio
.size
));
642 fileio_close(&fileio
);
647 void flash_set_dirty(void)
649 struct flash_bank
*c
;
652 /* set all flash to require erasing */
653 for (c
= flash_bank_list(); c
; c
= c
->next
)
655 for (i
= 0; i
< c
->num_sectors
; i
++)
657 c
->sectors
[i
].is_erased
= 0;
662 static const struct command_registration flash_exec_command_handlers
[] = {
665 .handler
= handle_flash_probe_command
,
666 .mode
= COMMAND_EXEC
,
668 .help
= "Identify a flash bank.",
672 .handler
= handle_flash_info_command
,
673 .mode
= COMMAND_EXEC
,
675 .help
= "Print information about a flash bank.",
678 .name
= "erase_check",
679 .handler
= handle_flash_erase_check_command
,
680 .mode
= COMMAND_EXEC
,
682 .help
= "Check erase state of all blocks in a "
686 .name
= "erase_sector",
687 .handler
= handle_flash_erase_command
,
688 .mode
= COMMAND_EXEC
,
689 .usage
= "bank_id first_sector_num last_sector_num",
690 .help
= "Erase a range of sectors in a flash bank.",
693 .name
= "erase_address",
694 .handler
= handle_flash_erase_address_command
,
695 .mode
= COMMAND_EXEC
,
696 .usage
= "['pad'] ['unlock'] address length",
697 .help
= "Erase flash sectors starting at address and "
698 "continuing for length bytes. If 'pad' is specified, "
699 "data outside that range may also be erased: the start "
700 "address may be decreased, and length increased, so "
701 "that all of the first and last sectors are erased. "
702 "If 'unlock' is specified, then the flash is unprotected "
708 .handler
= handle_flash_fill_command
,
709 .mode
= COMMAND_EXEC
,
710 .usage
= "address value n",
711 .help
= "Fill n words with 32-bit value, starting at "
712 "word address. (No autoerase.)",
716 .handler
= handle_flash_fill_command
,
717 .mode
= COMMAND_EXEC
,
718 .usage
= "address value n",
719 .help
= "Fill n halfwords with 16-bit value, starting at "
720 "word address. (No autoerase.)",
724 .handler
= handle_flash_fill_command
,
725 .mode
= COMMAND_EXEC
,
726 .usage
= "address value n",
727 .help
= "Fill n bytes with 8-bit value, starting at "
728 "word address. (No autoerase.)",
731 .name
= "write_bank",
732 .handler
= handle_flash_write_bank_command
,
733 .mode
= COMMAND_EXEC
,
734 .usage
= "bank_id filename offset",
735 .help
= "Write binary data from file to flash bank, "
736 "starting at specified byte offset from the "
737 "beginning of the bank.",
740 .name
= "write_image",
741 .handler
= handle_flash_write_image_command
,
742 .mode
= COMMAND_EXEC
,
743 .usage
= "[erase] [unlock] filename [offset [file_type]]",
744 .help
= "Write an image to flash. Optionally first unprotect "
745 "and/or erase the region to be used. Allow optional "
746 "offset from beginning of bank (defaults to zero)",
750 .handler
= handle_flash_protect_command
,
751 .mode
= COMMAND_EXEC
,
752 .usage
= "bank_id first_sector [last_sector|'last'] "
754 .help
= "Turn protection on or off for a range of sectors "
755 "in a given flash bank.",
757 COMMAND_REGISTRATION_DONE
760 static int flash_init_drivers(struct command_context
*cmd_ctx
)
762 if (!flash_bank_list())
765 struct command
*parent
= command_find_in_context(cmd_ctx
, "flash");
766 return register_commands(cmd_ctx
, parent
, flash_exec_command_handlers
);
770 COMMAND_HANDLER(handle_flash_bank_command
)
774 LOG_ERROR("usage: flash bank <name> <driver> "
775 "<base> <size> <chip_width> <bus_width> <target>");
776 return ERROR_COMMAND_SYNTAX_ERROR
;
778 // save bank name and advance arguments for compatibility
779 const char *bank_name
= *CMD_ARGV
++;
782 struct target
*target
;
783 if ((target
= get_target(CMD_ARGV
[5])) == NULL
)
785 LOG_ERROR("target '%s' not defined", CMD_ARGV
[5]);
789 const char *driver_name
= CMD_ARGV
[0];
790 struct flash_driver
*driver
= flash_driver_find_by_name(driver_name
);
793 /* no matching flash driver found */
794 LOG_ERROR("flash driver '%s' not found", driver_name
);
798 /* check the flash bank name is unique */
799 if (get_flash_bank_by_name(bank_name
) != NULL
)
801 /* flash bank name already exists */
802 LOG_ERROR("flash bank name '%s' already exists", bank_name
);
806 /* register flash specific commands */
807 if (NULL
!= driver
->commands
)
809 int retval
= register_commands(CMD_CTX
, NULL
,
811 if (ERROR_OK
!= retval
)
813 LOG_ERROR("couldn't register '%s' commands",
819 struct flash_bank
*c
= malloc(sizeof(*c
));
820 c
->name
= strdup(bank_name
);
823 c
->driver_priv
= NULL
;
824 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], c
->base
);
825 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], c
->size
);
826 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[3], c
->chip_width
);
827 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[4], c
->bus_width
);
833 retval
= CALL_COMMAND_HANDLER(driver
->flash_bank_command
, c
);
834 if (ERROR_OK
!= retval
)
836 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32
,
837 driver_name
, c
->base
);
847 COMMAND_HANDLER(handle_flash_banks_command
)
850 return ERROR_INVALID_ARGUMENTS
;
853 for (struct flash_bank
*p
= flash_bank_list(); p
; p
= p
->next
, n
++)
855 LOG_USER("#%" PRIu32
" : %s at 0x%8.8" PRIx32
", size 0x%8.8" PRIx32
", "
856 "buswidth %u, chipwidth %u", p
->bank_number
,
857 p
->driver
->name
, p
->base
, p
->size
,
858 p
->bus_width
, p
->chip_width
);
863 static int jim_flash_list(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
867 Jim_WrongNumArgs(interp
, 1, argv
,
868 "no arguments to 'flash list' command");
872 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
874 for (struct flash_bank
*p
= flash_bank_list(); p
; p
= p
->next
)
876 Jim_Obj
*elem
= Jim_NewListObj(interp
, NULL
, 0);
878 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
879 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
880 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
881 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
882 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
883 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
884 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
885 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
886 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
887 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
889 Jim_ListAppendElement(interp
, list
, elem
);
892 Jim_SetResult(interp
, list
);
898 COMMAND_HANDLER(handle_flash_init_command
)
901 return ERROR_COMMAND_SYNTAX_ERROR
;
903 static bool flash_initialized
= false;
904 if (flash_initialized
)
906 LOG_INFO("'flash init' has already been called");
909 flash_initialized
= true;
911 LOG_DEBUG("Initializing flash devices...");
912 return flash_init_drivers(CMD_CTX
);
915 static const struct command_registration flash_config_command_handlers
[] = {
918 .handler
= handle_flash_bank_command
,
919 .mode
= COMMAND_CONFIG
,
920 .usage
= "bank_id driver_name base_address size_bytes "
921 "chip_width_bytes bus_width_bytes target "
922 "[driver_options ...]",
923 .help
= "Define a new bank with the given name, "
924 "using the specified NOR flash driver.",
928 .mode
= COMMAND_CONFIG
,
929 .handler
= handle_flash_init_command
,
930 .help
= "Initialize flash devices.",
935 .handler
= handle_flash_banks_command
,
936 .help
= "Display table with information about flash banks.",
941 .jim_handler
= jim_flash_list
,
942 .help
= "Returns a list of details about the flash banks.",
944 COMMAND_REGISTRATION_DONE
946 static const struct command_registration flash_command_handlers
[] = {
950 .help
= "NOR flash command group",
951 .chain
= flash_config_command_handlers
,
953 COMMAND_REGISTRATION_DONE
956 int flash_register_commands(struct command_context
*cmd_ctx
)
958 return register_commands(cmd_ctx
, NULL
, flash_command_handlers
);
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)