1 /* SPDX-License-Identifier: GPL-2.0-or-later */
3 /***************************************************************************
4 * Copyright (C) 2005 by Dominic Rath *
5 * Dominic.Rath@gmx.de *
7 * Copyright (C) 2008 by Spencer Oliver *
8 * spen@spen-soft.co.uk *
10 * Copyright (C) 2011 by Erik Botö
11 * erik.boto@pelagicore.com
12 ***************************************************************************/
19 #include <helper/binarybuffer.h>
20 #include <target/algorithm.h>
21 #include <target/armv7m.h>
23 /* em357 register locations */
25 #define EM357_FLASH_ACR 0x40008000
26 #define EM357_FLASH_KEYR 0x40008004
27 #define EM357_FLASH_OPTKEYR 0x40008008
28 #define EM357_FLASH_SR 0x4000800C
29 #define EM357_FLASH_CR 0x40008010
30 #define EM357_FLASH_AR 0x40008014
31 #define EM357_FLASH_OBR 0x4000801C
32 #define EM357_FLASH_WRPR 0x40008020
34 #define EM357_FPEC_CLK 0x4000402c
35 /* option byte location */
37 #define EM357_OB_RDP 0x08040800
38 #define EM357_OB_WRP0 0x08040808
39 #define EM357_OB_WRP1 0x0804080A
40 #define EM357_OB_WRP2 0x0804080C
42 /* FLASH_CR register bits */
44 #define FLASH_PG (1 << 0)
45 #define FLASH_PER (1 << 1)
46 #define FLASH_MER (1 << 2)
47 #define FLASH_OPTPG (1 << 4)
48 #define FLASH_OPTER (1 << 5)
49 #define FLASH_STRT (1 << 6)
50 #define FLASH_LOCK (1 << 7)
51 #define FLASH_OPTWRE (1 << 9)
53 /* FLASH_SR register bits */
55 #define FLASH_BSY (1 << 0)
56 #define FLASH_PGERR (1 << 2)
57 #define FLASH_WRPRTERR (1 << 4)
58 #define FLASH_EOP (1 << 5)
60 /* EM357_FLASH_OBR bit definitions (reading) */
65 /* register unlock keys */
67 #define KEY1 0x45670123
68 #define KEY2 0xCDEF89AB
70 struct em357_options
{
72 uint16_t user_options
;
73 uint16_t protection
[3];
76 struct em357_flash_bank
{
77 struct em357_options option_bytes
;
82 static int em357_mass_erase(struct flash_bank
*bank
);
84 /* flash bank em357 <base> <size> 0 0 <target#>
86 FLASH_BANK_COMMAND_HANDLER(em357_flash_bank_command
)
88 struct em357_flash_bank
*em357_info
;
91 return ERROR_COMMAND_SYNTAX_ERROR
;
93 em357_info
= malloc(sizeof(struct em357_flash_bank
));
94 bank
->driver_priv
= em357_info
;
96 em357_info
->probed
= false;
101 static inline int em357_get_flash_status(struct flash_bank
*bank
, uint32_t *status
)
103 struct target
*target
= bank
->target
;
104 return target_read_u32(target
, EM357_FLASH_SR
, status
);
107 static int em357_wait_status_busy(struct flash_bank
*bank
, int timeout
)
109 struct target
*target
= bank
->target
;
111 int retval
= ERROR_OK
;
113 /* wait for busy to clear */
115 retval
= em357_get_flash_status(bank
, &status
);
116 if (retval
!= ERROR_OK
)
118 LOG_DEBUG("status: 0x%" PRIx32
"", status
);
119 if ((status
& FLASH_BSY
) == 0)
121 if (timeout
-- <= 0) {
122 LOG_ERROR("timed out waiting for flash");
128 if (status
& FLASH_WRPRTERR
) {
129 LOG_ERROR("em357 device protected");
133 if (status
& FLASH_PGERR
) {
134 LOG_ERROR("em357 device programming failed");
138 /* Clear but report errors */
139 if (status
& (FLASH_WRPRTERR
| FLASH_PGERR
)) {
140 /* If this operation fails, we ignore it and report the original
143 target_write_u32(target
, EM357_FLASH_SR
, FLASH_WRPRTERR
| FLASH_PGERR
);
148 static int em357_read_options(struct flash_bank
*bank
)
151 struct em357_flash_bank
*em357_info
= NULL
;
152 struct target
*target
= bank
->target
;
154 em357_info
= bank
->driver_priv
;
156 /* read current option bytes */
157 int retval
= target_read_u32(target
, EM357_FLASH_OBR
, &optiondata
);
158 if (retval
!= ERROR_OK
)
161 em357_info
->option_bytes
.user_options
= (uint16_t)0xFFFC | ((optiondata
>> 2) & 0x03);
162 em357_info
->option_bytes
.RDP
= (optiondata
& (1 << OPT_READOUT
)) ? 0xFFFF : 0x5AA5;
164 if (optiondata
& (1 << OPT_READOUT
))
165 LOG_INFO("Device Security Bit Set");
167 /* each bit refers to a 4bank protection */
168 retval
= target_read_u32(target
, EM357_FLASH_WRPR
, &optiondata
);
169 if (retval
!= ERROR_OK
)
172 em357_info
->option_bytes
.protection
[0] = (uint16_t)optiondata
;
173 em357_info
->option_bytes
.protection
[1] = (uint16_t)(optiondata
>> 8);
174 em357_info
->option_bytes
.protection
[2] = (uint16_t)(optiondata
>> 16);
179 static int em357_erase_options(struct flash_bank
*bank
)
181 struct em357_flash_bank
*em357_info
= NULL
;
182 struct target
*target
= bank
->target
;
184 em357_info
= bank
->driver_priv
;
186 /* read current options */
187 em357_read_options(bank
);
189 /* unlock flash registers */
190 int retval
= target_write_u32(target
, EM357_FLASH_KEYR
, KEY1
);
191 if (retval
!= ERROR_OK
)
194 retval
= target_write_u32(target
, EM357_FLASH_KEYR
, KEY2
);
195 if (retval
!= ERROR_OK
)
198 /* unlock option flash registers */
199 retval
= target_write_u32(target
, EM357_FLASH_OPTKEYR
, KEY1
);
200 if (retval
!= ERROR_OK
)
202 retval
= target_write_u32(target
, EM357_FLASH_OPTKEYR
, KEY2
);
203 if (retval
!= ERROR_OK
)
206 /* erase option bytes */
207 retval
= target_write_u32(target
, EM357_FLASH_CR
, FLASH_OPTER
| FLASH_OPTWRE
);
208 if (retval
!= ERROR_OK
)
210 retval
= target_write_u32(target
, EM357_FLASH_CR
, FLASH_OPTER
| FLASH_STRT
| FLASH_OPTWRE
);
211 if (retval
!= ERROR_OK
)
214 retval
= em357_wait_status_busy(bank
, 10);
215 if (retval
!= ERROR_OK
)
218 /* clear readout protection and complementary option bytes
219 * this will also force a device unlock if set */
220 em357_info
->option_bytes
.RDP
= 0x5AA5;
225 static int em357_write_options(struct flash_bank
*bank
)
227 struct em357_flash_bank
*em357_info
= NULL
;
228 struct target
*target
= bank
->target
;
230 em357_info
= bank
->driver_priv
;
232 /* unlock flash registers */
233 int retval
= target_write_u32(target
, EM357_FLASH_KEYR
, KEY1
);
234 if (retval
!= ERROR_OK
)
236 retval
= target_write_u32(target
, EM357_FLASH_KEYR
, KEY2
);
237 if (retval
!= ERROR_OK
)
240 /* unlock option flash registers */
241 retval
= target_write_u32(target
, EM357_FLASH_OPTKEYR
, KEY1
);
242 if (retval
!= ERROR_OK
)
244 retval
= target_write_u32(target
, EM357_FLASH_OPTKEYR
, KEY2
);
245 if (retval
!= ERROR_OK
)
248 /* program option bytes */
249 retval
= target_write_u32(target
, EM357_FLASH_CR
, FLASH_OPTPG
| FLASH_OPTWRE
);
250 if (retval
!= ERROR_OK
)
253 retval
= em357_wait_status_busy(bank
, 10);
254 if (retval
!= ERROR_OK
)
257 /* write protection byte 1 */
258 retval
= target_write_u16(target
, EM357_OB_WRP0
, em357_info
->option_bytes
.protection
[0]);
259 if (retval
!= ERROR_OK
)
262 retval
= em357_wait_status_busy(bank
, 10);
263 if (retval
!= ERROR_OK
)
266 /* write protection byte 2 */
267 retval
= target_write_u16(target
, EM357_OB_WRP1
, em357_info
->option_bytes
.protection
[1]);
268 if (retval
!= ERROR_OK
)
271 retval
= em357_wait_status_busy(bank
, 10);
272 if (retval
!= ERROR_OK
)
275 /* write protection byte 3 */
276 retval
= target_write_u16(target
, EM357_OB_WRP2
, em357_info
->option_bytes
.protection
[2]);
277 if (retval
!= ERROR_OK
)
280 retval
= em357_wait_status_busy(bank
, 10);
281 if (retval
!= ERROR_OK
)
284 /* write readout protection bit */
285 retval
= target_write_u16(target
, EM357_OB_RDP
, em357_info
->option_bytes
.RDP
);
286 if (retval
!= ERROR_OK
)
289 retval
= em357_wait_status_busy(bank
, 10);
290 if (retval
!= ERROR_OK
)
293 retval
= target_write_u32(target
, EM357_FLASH_CR
, FLASH_LOCK
);
294 if (retval
!= ERROR_OK
)
300 static int em357_protect_check(struct flash_bank
*bank
)
302 struct target
*target
= bank
->target
;
303 struct em357_flash_bank
*em357_info
= bank
->driver_priv
;
310 if (target
->state
!= TARGET_HALTED
) {
311 LOG_ERROR("Target not halted");
312 return ERROR_TARGET_NOT_HALTED
;
315 /* each bit refers to a 4bank protection (bit 0-23) */
316 int retval
= target_read_u32(target
, EM357_FLASH_WRPR
, &protection
);
317 if (retval
!= ERROR_OK
)
320 /* each protection bit is for 4 * 2K pages */
321 num_bits
= (bank
->num_sectors
/ em357_info
->ppage_size
);
323 for (i
= 0; i
< num_bits
; i
++) {
325 if (protection
& (1 << i
))
328 for (s
= 0; s
< em357_info
->ppage_size
; s
++)
329 bank
->sectors
[(i
* em357_info
->ppage_size
) + s
].is_protected
= set
;
335 static int em357_erase(struct flash_bank
*bank
, unsigned int first
,
338 struct target
*target
= bank
->target
;
340 if (bank
->target
->state
!= TARGET_HALTED
) {
341 LOG_ERROR("Target not halted");
342 return ERROR_TARGET_NOT_HALTED
;
345 if ((first
== 0) && (last
== (bank
->num_sectors
- 1)))
346 return em357_mass_erase(bank
);
348 /* Enable FPEC clock */
349 target_write_u32(target
, EM357_FPEC_CLK
, 0x00000001);
351 /* unlock flash registers */
352 int retval
= target_write_u32(target
, EM357_FLASH_KEYR
, KEY1
);
353 if (retval
!= ERROR_OK
)
355 retval
= target_write_u32(target
, EM357_FLASH_KEYR
, KEY2
);
356 if (retval
!= ERROR_OK
)
359 for (unsigned int i
= first
; i
<= last
; i
++) {
360 retval
= target_write_u32(target
, EM357_FLASH_CR
, FLASH_PER
);
361 if (retval
!= ERROR_OK
)
363 retval
= target_write_u32(target
, EM357_FLASH_AR
,
364 bank
->base
+ bank
->sectors
[i
].offset
);
365 if (retval
!= ERROR_OK
)
367 retval
= target_write_u32(target
, EM357_FLASH_CR
, FLASH_PER
| FLASH_STRT
);
368 if (retval
!= ERROR_OK
)
371 retval
= em357_wait_status_busy(bank
, 100);
372 if (retval
!= ERROR_OK
)
376 retval
= target_write_u32(target
, EM357_FLASH_CR
, FLASH_LOCK
);
377 if (retval
!= ERROR_OK
)
383 static int em357_protect(struct flash_bank
*bank
, int set
, unsigned int first
,
386 struct em357_flash_bank
*em357_info
= NULL
;
387 struct target
*target
= bank
->target
;
388 uint16_t prot_reg
[4] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
393 em357_info
= bank
->driver_priv
;
395 if (target
->state
!= TARGET_HALTED
) {
396 LOG_ERROR("Target not halted");
397 return ERROR_TARGET_NOT_HALTED
;
400 if ((first
% em357_info
->ppage_size
) != 0) {
401 LOG_WARNING("aligned start protect sector to a %d sector boundary",
402 em357_info
->ppage_size
);
403 first
= first
- (first
% em357_info
->ppage_size
);
405 if (((last
+ 1) % em357_info
->ppage_size
) != 0) {
406 LOG_WARNING("aligned end protect sector to a %d sector boundary",
407 em357_info
->ppage_size
);
409 last
= last
- (last
% em357_info
->ppage_size
);
413 /* each bit refers to a 4bank protection */
414 int retval
= target_read_u32(target
, EM357_FLASH_WRPR
, &protection
);
415 if (retval
!= ERROR_OK
)
418 prot_reg
[0] = (uint16_t)protection
;
419 prot_reg
[1] = (uint16_t)(protection
>> 8);
420 prot_reg
[2] = (uint16_t)(protection
>> 16);
422 for (unsigned int i
= first
; i
<= last
; i
++) {
423 reg
= (i
/ em357_info
->ppage_size
) / 8;
424 bit
= (i
/ em357_info
->ppage_size
) - (reg
* 8);
426 LOG_WARNING("reg, bit: %d, %d", reg
, bit
);
428 prot_reg
[reg
] &= ~(1 << bit
);
430 prot_reg
[reg
] |= (1 << bit
);
433 status
= em357_erase_options(bank
);
434 if (retval
!= ERROR_OK
)
437 em357_info
->option_bytes
.protection
[0] = prot_reg
[0];
438 em357_info
->option_bytes
.protection
[1] = prot_reg
[1];
439 em357_info
->option_bytes
.protection
[2] = prot_reg
[2];
441 return em357_write_options(bank
);
444 static int em357_write_block(struct flash_bank
*bank
, const uint8_t *buffer
,
445 uint32_t offset
, uint32_t count
)
447 struct target
*target
= bank
->target
;
448 uint32_t buffer_size
= 16384;
449 struct working_area
*write_algorithm
;
450 struct working_area
*source
;
451 uint32_t address
= bank
->base
+ offset
;
452 struct reg_param reg_params
[4];
453 struct armv7m_algorithm armv7m_info
;
454 int retval
= ERROR_OK
;
456 /* see contrib/loaders/flash/stm32x.s for src, the same is used here except for
457 * a modified *_FLASH_BASE */
459 static const uint8_t em357_flash_write_code
[] = {
460 /* #define EM357_FLASH_CR_OFFSET 0x10
461 * #define EM357_FLASH_SR_OFFSET 0x0C
463 0x08, 0x4c, /* ldr r4, EM357_FLASH_BASE */
464 0x1c, 0x44, /* add r4, r3 */
465 /* write_half_word: */
466 0x01, 0x23, /* movs r3, #0x01 */
467 0x23, 0x61, /* str r3, [r4,
468 *#EM357_FLASH_CR_OFFSET] */
469 0x30, 0xf8, 0x02, 0x3b, /* ldrh r3, [r0], #0x02 */
470 0x21, 0xf8, 0x02, 0x3b, /* strh r3, [r1], #0x02 */
472 0xe3, 0x68, /* ldr r3, [r4,
473 *#EM357_FLASH_SR_OFFSET] */
474 0x13, 0xf0, 0x01, 0x0f, /* tst r3, #0x01 */
475 0xfb, 0xd0, /* beq busy */
476 0x13, 0xf0, 0x14, 0x0f, /* tst r3, #0x14 */
477 0x01, 0xd1, /* bne exit */
478 0x01, 0x3a, /* subs r2, r2, #0x01 */
479 0xf0, 0xd1, /* bne write_half_word */
481 0x00, 0xbe, /* bkpt #0x00 */
482 0x00, 0x80, 0x00, 0x40, /* EM357_FLASH_BASE: .word 0x40008000 */
485 /* flash write code */
486 if (target_alloc_working_area(target
, sizeof(em357_flash_write_code
),
487 &write_algorithm
) != ERROR_OK
) {
488 LOG_WARNING("no working area available, can't do block memory writes");
489 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
492 retval
= target_write_buffer(target
, write_algorithm
->address
,
493 sizeof(em357_flash_write_code
), em357_flash_write_code
);
494 if (retval
!= ERROR_OK
)
498 while (target_alloc_working_area_try(target
, buffer_size
, &source
) != ERROR_OK
) {
500 if (buffer_size
<= 256) {
501 /* we already allocated the writing code, but failed to get a
502 * buffer, free the algorithm */
503 target_free_working_area(target
, write_algorithm
);
506 "no large enough working area available, can't do block memory writes");
507 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
511 armv7m_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
512 armv7m_info
.core_mode
= ARM_MODE_THREAD
;
514 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
515 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
516 init_reg_param(®_params
[2], "r2", 32, PARAM_OUT
);
517 init_reg_param(®_params
[3], "r3", 32, PARAM_IN_OUT
);
520 uint32_t thisrun_count
= (count
> (buffer_size
/ 2)) ?
521 (buffer_size
/ 2) : count
;
523 retval
= target_write_buffer(target
, source
->address
, thisrun_count
* 2, buffer
);
524 if (retval
!= ERROR_OK
)
527 buf_set_u32(reg_params
[0].value
, 0, 32, source
->address
);
528 buf_set_u32(reg_params
[1].value
, 0, 32, address
);
529 buf_set_u32(reg_params
[2].value
, 0, 32, thisrun_count
);
530 buf_set_u32(reg_params
[3].value
, 0, 32, 0);
532 retval
= target_run_algorithm(target
, 0, NULL
, 4, reg_params
,
533 write_algorithm
->address
, 0, 10000, &armv7m_info
);
534 if (retval
!= ERROR_OK
) {
535 LOG_ERROR("error executing em357 flash write algorithm");
539 if (buf_get_u32(reg_params
[3].value
, 0, 32) & FLASH_PGERR
) {
540 LOG_ERROR("flash memory not erased before writing");
541 /* Clear but report errors */
542 target_write_u32(target
, EM357_FLASH_SR
, FLASH_PGERR
);
547 if (buf_get_u32(reg_params
[3].value
, 0, 32) & FLASH_WRPRTERR
) {
548 LOG_ERROR("flash memory write protected");
549 /* Clear but report errors */
550 target_write_u32(target
, EM357_FLASH_SR
, FLASH_WRPRTERR
);
555 buffer
+= thisrun_count
* 2;
556 address
+= thisrun_count
* 2;
557 count
-= thisrun_count
;
560 target_free_working_area(target
, source
);
561 target_free_working_area(target
, write_algorithm
);
563 destroy_reg_param(®_params
[0]);
564 destroy_reg_param(®_params
[1]);
565 destroy_reg_param(®_params
[2]);
566 destroy_reg_param(®_params
[3]);
571 static int em357_write(struct flash_bank
*bank
, const uint8_t *buffer
,
572 uint32_t offset
, uint32_t count
)
574 struct target
*target
= bank
->target
;
575 uint32_t words_remaining
= (count
/ 2);
576 uint32_t bytes_remaining
= (count
& 0x00000001);
577 uint32_t address
= bank
->base
+ offset
;
578 uint32_t bytes_written
= 0;
581 if (bank
->target
->state
!= TARGET_HALTED
) {
582 LOG_ERROR("Target not halted");
583 return ERROR_TARGET_NOT_HALTED
;
587 LOG_WARNING("offset 0x%" PRIx32
" breaks required 2-byte alignment", offset
);
588 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
591 /* unlock flash registers */
592 retval
= target_write_u32(target
, EM357_FLASH_KEYR
, KEY1
);
593 if (retval
!= ERROR_OK
)
595 retval
= target_write_u32(target
, EM357_FLASH_KEYR
, KEY2
);
596 if (retval
!= ERROR_OK
)
599 target_write_u32(target
, EM357_FPEC_CLK
, 0x00000001);
601 /* multiple half words (2-byte) to be programmed? */
602 if (words_remaining
> 0) {
603 /* try using a block write */
604 retval
= em357_write_block(bank
, buffer
, offset
, words_remaining
);
605 if (retval
!= ERROR_OK
) {
606 if (retval
== ERROR_TARGET_RESOURCE_NOT_AVAILABLE
) {
607 /* if block write failed (no sufficient working area),
608 * we use normal (slow) single dword accesses */
610 "couldn't use block writes, falling back to single memory accesses");
613 buffer
+= words_remaining
* 2;
614 address
+= words_remaining
* 2;
619 if ((retval
!= ERROR_OK
) && (retval
!= ERROR_TARGET_RESOURCE_NOT_AVAILABLE
))
622 while (words_remaining
> 0) {
624 memcpy(&value
, buffer
+ bytes_written
, sizeof(uint16_t));
626 retval
= target_write_u32(target
, EM357_FLASH_CR
, FLASH_PG
);
627 if (retval
!= ERROR_OK
)
629 retval
= target_write_u16(target
, address
, value
);
630 if (retval
!= ERROR_OK
)
633 retval
= em357_wait_status_busy(bank
, 5);
634 if (retval
!= ERROR_OK
)
642 if (bytes_remaining
) {
643 uint16_t value
= 0xffff;
644 memcpy(&value
, buffer
+ bytes_written
, bytes_remaining
);
646 retval
= target_write_u32(target
, EM357_FLASH_CR
, FLASH_PG
);
647 if (retval
!= ERROR_OK
)
649 retval
= target_write_u16(target
, address
, value
);
650 if (retval
!= ERROR_OK
)
653 retval
= em357_wait_status_busy(bank
, 5);
654 if (retval
!= ERROR_OK
)
658 return target_write_u32(target
, EM357_FLASH_CR
, FLASH_LOCK
);
661 static int em357_probe(struct flash_bank
*bank
)
663 struct target
*target
= bank
->target
;
664 struct em357_flash_bank
*em357_info
= bank
->driver_priv
;
668 uint32_t base_address
= 0x08000000;
670 em357_info
->probed
= false;
672 switch (bank
->size
) {
674 /* 64k -- 64 1k pages */
679 /* 128k -- 128 1k pages */
684 /* 192k -- 96 2k pages */
689 /* 256k -- 128 2k pages */
694 /* 512k -- 256 2k pages */
699 LOG_WARNING("No size specified for em357 flash driver, assuming 192k!");
705 /* Enable FPEC CLK */
706 int retval
= target_write_u32(target
, EM357_FPEC_CLK
, 0x00000001);
707 if (retval
!= ERROR_OK
)
710 em357_info
->ppage_size
= 4;
712 LOG_INFO("flash size = %dkbytes", num_pages
*page_size
/1024);
716 bank
->base
= base_address
;
717 bank
->size
= (num_pages
* page_size
);
718 bank
->num_sectors
= num_pages
;
719 bank
->sectors
= malloc(sizeof(struct flash_sector
) * num_pages
);
721 for (i
= 0; i
< num_pages
; i
++) {
722 bank
->sectors
[i
].offset
= i
* page_size
;
723 bank
->sectors
[i
].size
= page_size
;
724 bank
->sectors
[i
].is_erased
= -1;
725 bank
->sectors
[i
].is_protected
= 1;
728 em357_info
->probed
= true;
733 static int em357_auto_probe(struct flash_bank
*bank
)
735 struct em357_flash_bank
*em357_info
= bank
->driver_priv
;
736 if (em357_info
->probed
)
738 return em357_probe(bank
);
741 COMMAND_HANDLER(em357_handle_lock_command
)
743 struct target
*target
= NULL
;
744 struct em357_flash_bank
*em357_info
= NULL
;
747 return ERROR_COMMAND_SYNTAX_ERROR
;
749 struct flash_bank
*bank
;
750 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
751 if (retval
!= ERROR_OK
)
754 em357_info
= bank
->driver_priv
;
756 target
= bank
->target
;
758 if (target
->state
!= TARGET_HALTED
) {
759 LOG_ERROR("Target not halted");
760 return ERROR_TARGET_NOT_HALTED
;
763 if (em357_erase_options(bank
) != ERROR_OK
) {
764 command_print(CMD
, "em357 failed to erase options");
768 /* set readout protection */
769 em357_info
->option_bytes
.RDP
= 0;
771 if (em357_write_options(bank
) != ERROR_OK
) {
772 command_print(CMD
, "em357 failed to lock device");
776 command_print(CMD
, "em357 locked");
781 COMMAND_HANDLER(em357_handle_unlock_command
)
783 struct target
*target
= NULL
;
786 return ERROR_COMMAND_SYNTAX_ERROR
;
788 struct flash_bank
*bank
;
789 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
790 if (retval
!= ERROR_OK
)
793 target
= bank
->target
;
795 if (target
->state
!= TARGET_HALTED
) {
796 LOG_ERROR("Target not halted");
797 return ERROR_TARGET_NOT_HALTED
;
800 if (em357_erase_options(bank
) != ERROR_OK
) {
801 command_print(CMD
, "em357 failed to unlock device");
805 if (em357_write_options(bank
) != ERROR_OK
) {
806 command_print(CMD
, "em357 failed to lock device");
810 command_print(CMD
, "em357 unlocked.\n"
811 "INFO: a reset or power cycle is required "
812 "for the new settings to take effect.");
817 static int em357_mass_erase(struct flash_bank
*bank
)
819 struct target
*target
= bank
->target
;
821 if (target
->state
!= TARGET_HALTED
) {
822 LOG_ERROR("Target not halted");
823 return ERROR_TARGET_NOT_HALTED
;
826 /* Make sure the flash clock is on */
827 target_write_u32(target
, EM357_FPEC_CLK
, 0x00000001);
829 /* unlock option flash registers */
830 int retval
= target_write_u32(target
, EM357_FLASH_KEYR
, KEY1
);
831 if (retval
!= ERROR_OK
)
833 retval
= target_write_u32(target
, EM357_FLASH_KEYR
, KEY2
);
834 if (retval
!= ERROR_OK
)
837 /* mass erase flash memory */
838 retval
= target_write_u32(target
, EM357_FLASH_CR
, FLASH_MER
);
839 if (retval
!= ERROR_OK
)
841 retval
= target_write_u32(target
, EM357_FLASH_CR
, FLASH_MER
| FLASH_STRT
);
842 if (retval
!= ERROR_OK
)
845 retval
= em357_wait_status_busy(bank
, 100);
846 if (retval
!= ERROR_OK
)
849 retval
= target_write_u32(target
, EM357_FLASH_CR
, FLASH_LOCK
);
850 if (retval
!= ERROR_OK
)
856 COMMAND_HANDLER(em357_handle_mass_erase_command
)
859 return ERROR_COMMAND_SYNTAX_ERROR
;
861 struct flash_bank
*bank
;
862 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
863 if (retval
!= ERROR_OK
)
866 retval
= em357_mass_erase(bank
);
867 if (retval
== ERROR_OK
)
868 command_print(CMD
, "em357 mass erase complete");
870 command_print(CMD
, "em357 mass erase failed");
875 static const struct command_registration em357_exec_command_handlers
[] = {
879 .handler
= em357_handle_lock_command
,
880 .mode
= COMMAND_EXEC
,
881 .help
= "Lock entire flash device.",
886 .handler
= em357_handle_unlock_command
,
887 .mode
= COMMAND_EXEC
,
888 .help
= "Unlock entire protected flash device.",
891 .name
= "mass_erase",
893 .handler
= em357_handle_mass_erase_command
,
894 .mode
= COMMAND_EXEC
,
895 .help
= "Erase entire flash device.",
897 COMMAND_REGISTRATION_DONE
900 static const struct command_registration em357_command_handlers
[] = {
904 .help
= "em357 flash command group",
906 .chain
= em357_exec_command_handlers
,
908 COMMAND_REGISTRATION_DONE
911 const struct flash_driver em357_flash
= {
913 .commands
= em357_command_handlers
,
914 .flash_bank_command
= em357_flash_bank_command
,
915 .erase
= em357_erase
,
916 .protect
= em357_protect
,
917 .write
= em357_write
,
918 .read
= default_flash_read
,
919 .probe
= em357_probe
,
920 .auto_probe
= em357_auto_probe
,
921 .erase_check
= default_flash_blank_check
,
922 .protect_check
= em357_protect_check
,
923 .free_driver_priv
= default_flash_free_driver_priv
,
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)