1 /***************************************************************************
2 * Copyright (C) 2015 by Uwe Bonnes *
3 * bon@elektron.ikp.physik.tu-darmstadt.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 ***************************************************************************/
25 #include <helper/binarybuffer.h>
26 #include <target/algorithm.h>
27 #include <target/armv7m.h>
29 /* STM32L4xxx series for reference.
32 * http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/DM00083560.pdf
34 * STM32L476RG Datasheet (for erase timing)
35 * http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00108832.pdf
38 * The device has normally two banks, but on 512 and 256 kiB devices an
39 * option byte is available to map all sectors to the first bank.
40 * Both STM32 banks are treated as one OpenOCD bank, as other STM32 devices
45 /* Erase time can be as high as 25ms, 10x this and assume it's toast... */
47 #define FLASH_ERASE_TIMEOUT 250
49 #define STM32_FLASH_BASE 0x40022000
50 #define STM32_FLASH_ACR 0x40022000
51 #define STM32_FLASH_KEYR 0x40022008
52 #define STM32_FLASH_OPTKEYR 0x4002200c
53 #define STM32_FLASH_SR 0x40022010
54 #define STM32_FLASH_CR 0x40022014
55 #define STM32_FLASH_OPTR 0x40022020
56 #define STM32_FLASH_WRP1AR 0x4002202c
57 #define STM32_FLASH_WRP2AR 0x40022030
58 #define STM32_FLASH_WRP1BR 0x4002204c
59 #define STM32_FLASH_WRP2BR 0x40022050
61 /* FLASH_CR register bits */
63 #define FLASH_PG (1 << 0)
64 #define FLASH_PER (1 << 1)
65 #define FLASH_MER1 (1 << 2)
66 #define FLASH_PAGE_SHIFT 3
67 #define FLASH_CR_BKER (1 << 11)
68 #define FLASH_MER2 (1 << 15)
69 #define FLASH_STRT (1 << 16)
70 #define FLASH_EOPIE (1 << 24)
71 #define FLASH_ERRIE (1 << 25)
72 #define FLASH_OPTLOCK (1 << 30)
73 #define FLASH_LOCK (1 << 31)
75 /* FLASH_SR register bits */
77 #define FLASH_BSY (1 << 16)
78 /* Fast programming not used => related errors not used*/
79 #define FLASH_PGSERR (1 << 7) /* Programming sequence error */
80 #define FLASH_SIZERR (1 << 6) /* Size error */
81 #define FLASH_PGAERR (1 << 5) /* Programming alignment error */
82 #define FLASH_WRPERR (1 << 4) /* Write protection error */
83 #define FLASH_PROGERR (1 << 3) /* Programming error */
84 #define FLASH_OPERR (1 << 1) /* Operation error */
85 #define FLASH_EOP (1 << 0) /* End of operation */
87 #define FLASH_ERROR (FLASH_PGSERR | FLASH_PGSERR | FLASH_PGAERR | FLASH_WRPERR | FLASH_OPERR)
89 /* STM32_FLASH_OBR bit definitions (reading) */
91 #define OPT_DUALBANK 21 /* dual flash bank only */
93 /* register unlock keys */
95 #define KEY1 0x45670123
96 #define KEY2 0xCDEF89AB
98 /* option register unlock key */
99 #define OPTKEY1 0x08192A3B
100 #define OPTKEY2 0x4C5D6E7F
103 /* other registers */
104 #define DBGMCU_IDCODE 0xE0042000
105 #define FLASH_SIZE_REG 0x1FFF75E0
107 struct stm32l4_options {
109 uint16_t bank_b_start;
110 uint8_t user_options;
119 /* Fixme: Handle PCROP */
122 struct stm32l4_flash_bank {
123 struct stm32l4_options option_bytes;
127 /* flash bank stm32l4x <base> <size> 0 0 <target#>
129 FLASH_BANK_COMMAND_HANDLER(stm32l4_flash_bank_command)
131 struct stm32l4_flash_bank *stm32l4_info;
134 return ERROR_COMMAND_SYNTAX_ERROR;
136 stm32l4_info = malloc(sizeof(struct stm32l4_flash_bank));
138 return ERROR_FAIL; /* Checkme: What better error to use?*/
139 bank->driver_priv = stm32l4_info;
141 stm32l4_info->probed = 0;
146 static inline int stm32l4_get_flash_reg(struct flash_bank *bank, uint32_t reg)
151 static inline int stm32l4_get_flash_status(struct flash_bank *bank, uint32_t *status)
153 struct target *target = bank->target;
154 return target_read_u32(
155 target, stm32l4_get_flash_reg(bank, STM32_FLASH_SR), status);
158 static int stm32l4_wait_status_busy(struct flash_bank *bank, int timeout)
160 struct target *target = bank->target;
162 int retval = ERROR_OK;
164 /* wait for busy to clear */
166 retval = stm32l4_get_flash_status(bank, &status);
167 if (retval != ERROR_OK)
169 LOG_DEBUG("status: 0x%" PRIx32 "", status);
170 if ((status & FLASH_BSY) == 0)
172 if (timeout-- <= 0) {
173 LOG_ERROR("timed out waiting for flash");
180 if (status & FLASH_WRPERR) {
181 LOG_ERROR("stm32x device protected");
185 /* Clear but report errors */
186 if (status & FLASH_ERROR) {
187 /* If this operation fails, we ignore it and report the original
190 target_write_u32(target, stm32l4_get_flash_reg(bank, STM32_FLASH_SR),
191 status & FLASH_ERROR);
196 static int stm32l4_unlock_reg(struct target *target)
200 /* first check if not already unlocked
201 * otherwise writing on STM32_FLASH_KEYR will fail
203 int retval = target_read_u32(target, STM32_FLASH_CR, &ctrl);
204 if (retval != ERROR_OK)
207 if ((ctrl & FLASH_LOCK) == 0)
210 /* unlock flash registers */
211 retval = target_write_u32(target, STM32_FLASH_KEYR, KEY1);
212 if (retval != ERROR_OK)
215 retval = target_write_u32(target, STM32_FLASH_KEYR, KEY2);
216 if (retval != ERROR_OK)
219 retval = target_read_u32(target, STM32_FLASH_CR, &ctrl);
220 if (retval != ERROR_OK)
223 if (ctrl & FLASH_LOCK) {
224 LOG_ERROR("flash not unlocked STM32_FLASH_CR: %" PRIx32, ctrl);
225 return ERROR_TARGET_FAILURE;
231 static int stm32l4_unlock_option_reg(struct target *target)
235 int retval = target_read_u32(target, STM32_FLASH_CR, &ctrl);
236 if (retval != ERROR_OK)
239 if ((ctrl & FLASH_OPTLOCK) == 0)
242 /* unlock option registers */
243 retval = target_write_u32(target, STM32_FLASH_OPTKEYR, OPTKEY1);
244 if (retval != ERROR_OK)
247 retval = target_write_u32(target, STM32_FLASH_OPTKEYR, OPTKEY2);
248 if (retval != ERROR_OK)
251 retval = target_read_u32(target, STM32_FLASH_CR, &ctrl);
252 if (retval != ERROR_OK)
255 if (ctrl & FLASH_OPTLOCK) {
256 LOG_ERROR("options not unlocked STM32_FLASH_CR: %" PRIx32, ctrl);
257 return ERROR_TARGET_FAILURE;
263 static int stm32l4_read_options(struct flash_bank *bank)
266 struct stm32l4_flash_bank *stm32l4_info = NULL;
267 struct target *target = bank->target;
269 stm32l4_info = bank->driver_priv;
271 /* read current option bytes */
272 int retval = target_read_u32(target, STM32_FLASH_OPTR, &optiondata);
273 if (retval != ERROR_OK)
276 stm32l4_info->option_bytes.user_options = (optiondata >> 8) & 0x3ffff;
277 stm32l4_info->option_bytes.RDP = optiondata & 0xff;
279 retval = target_read_u32(target, STM32_FLASH_WRP1AR, &optiondata);
280 if (retval != ERROR_OK)
282 stm32l4_info->option_bytes.wpr1a_start = optiondata & 0xff;
283 stm32l4_info->option_bytes.wpr1a_end = (optiondata >> 16) & 0xff;
285 retval = target_read_u32(target, STM32_FLASH_WRP2AR, &optiondata);
286 if (retval != ERROR_OK)
288 stm32l4_info->option_bytes.wpr2a_start = optiondata & 0xff;
289 stm32l4_info->option_bytes.wpr2a_end = (optiondata >> 16) & 0xff;
291 retval = target_read_u32(target, STM32_FLASH_WRP1BR, &optiondata);
292 if (retval != ERROR_OK)
294 stm32l4_info->option_bytes.wpr1b_start = optiondata & 0xff;
295 stm32l4_info->option_bytes.wpr1b_end = (optiondata >> 16) & 0xff;
297 retval = target_read_u32(target, STM32_FLASH_WRP2BR, &optiondata);
298 if (retval != ERROR_OK)
300 stm32l4_info->option_bytes.wpr2b_start = optiondata & 0xff;
301 stm32l4_info->option_bytes.wpr2b_end = (optiondata >> 16) & 0xff;
303 if (stm32l4_info->option_bytes.RDP != 0xAA)
304 LOG_INFO("Device Security Bit Set");
309 static int stm32l4_write_options(struct flash_bank *bank)
311 struct stm32l4_flash_bank *stm32l4_info = NULL;
312 struct target *target = bank->target;
315 stm32l4_info = bank->driver_priv;
320 int retval = stm32l4_unlock_option_reg(target);
321 if (retval != ERROR_OK)
323 /* FIXME: Implement Option writing!*/
327 static int stm32l4_protect_check(struct flash_bank *bank)
329 struct stm32l4_flash_bank *stm32l4_info = bank->driver_priv;
331 /* read write protection settings */
332 int retval = stm32l4_read_options(bank);
333 if (retval != ERROR_OK) {
334 LOG_DEBUG("unable to read option bytes");
338 for (int i = 0; i < bank->num_sectors; i++) {
339 if (i < stm32l4_info->option_bytes.bank_b_start) {
340 if (((i >= stm32l4_info->option_bytes.wpr1a_start) &&
341 (i <= stm32l4_info->option_bytes.wpr1a_end)) ||
342 ((i >= stm32l4_info->option_bytes.wpr2a_start) &&
343 (i <= stm32l4_info->option_bytes.wpr2a_end)))
344 bank->sectors[i].is_protected = 1;
346 bank->sectors[i].is_protected = 0;
349 snb = i - stm32l4_info->option_bytes.bank_b_start + 256;
350 if (((snb >= stm32l4_info->option_bytes.wpr1b_start) &&
351 (snb <= stm32l4_info->option_bytes.wpr1b_end)) ||
352 ((snb >= stm32l4_info->option_bytes.wpr2b_start) &&
353 (snb <= stm32l4_info->option_bytes.wpr2b_end)))
354 bank->sectors[i].is_protected = 1;
356 bank->sectors[i].is_protected = 0;
362 static int stm32l4_erase(struct flash_bank *bank, int first, int last)
364 struct target *target = bank->target;
367 assert(first < bank->num_sectors);
368 assert(last < bank->num_sectors);
370 if (bank->target->state != TARGET_HALTED) {
371 LOG_ERROR("Target not halted");
372 return ERROR_TARGET_NOT_HALTED;
376 retval = stm32l4_unlock_reg(target);
377 if (retval != ERROR_OK)
382 To erase a sector, follow the procedure below:
383 1. Check that no Flash memory operation is ongoing by
384 checking the BSY bit in the FLASH_SR register
385 2. Set the PER bit and select the page and bank
386 you wish to erase in the FLASH_CR register
387 3. Set the STRT bit in the FLASH_CR register
388 4. Wait for the BSY bit to be cleared
390 struct stm32l4_flash_bank *stm32l4_info = bank->driver_priv;
392 for (i = first; i <= last; i++) {
393 uint32_t erase_flags;
394 erase_flags = FLASH_PER | FLASH_STRT;
396 if (i >= stm32l4_info->option_bytes.bank_b_start) {
398 snb = (i - stm32l4_info->option_bytes.bank_b_start) + 256;
399 erase_flags |= snb << FLASH_PAGE_SHIFT | FLASH_CR_BKER;
401 erase_flags |= i << FLASH_PAGE_SHIFT;
402 retval = target_write_u32(target,
403 stm32l4_get_flash_reg(bank, STM32_FLASH_CR), erase_flags);
404 if (retval != ERROR_OK)
407 retval = stm32l4_wait_status_busy(bank, FLASH_ERASE_TIMEOUT);
408 if (retval != ERROR_OK)
411 bank->sectors[i].is_erased = 1;
414 retval = target_write_u32(
415 target, stm32l4_get_flash_reg(bank, STM32_FLASH_CR), FLASH_LOCK);
416 if (retval != ERROR_OK)
422 static int stm32l4_protect(struct flash_bank *bank, int set, int first, int last)
424 struct target *target = bank->target;
425 struct stm32l4_flash_bank *stm32l4_info = bank->driver_priv;
427 if (target->state != TARGET_HALTED) {
428 LOG_ERROR("Target not halted");
429 return ERROR_TARGET_NOT_HALTED;
432 /* read protection settings */
433 int retval = stm32l4_read_options(bank);
434 if (retval != ERROR_OK) {
435 LOG_DEBUG("unable to read option bytes");
440 /* FIXME: Write First and last in a valid WRPxx_start/end combo*/
441 retval = stm32l4_write_options(bank);
442 if (retval != ERROR_OK)
448 /* Count is in halfwords */
449 static int stm32l4_write_block(struct flash_bank *bank, const uint8_t *buffer,
450 uint32_t offset, uint32_t count)
452 struct target *target = bank->target;
453 uint32_t buffer_size = 16384;
454 struct working_area *write_algorithm;
455 struct working_area *source;
456 uint32_t address = bank->base + offset;
457 struct reg_param reg_params[5];
458 struct armv7m_algorithm armv7m_info;
459 int retval = ERROR_OK;
461 /* See contrib/loaders/flash/stm32l4x.S for source and
462 * hints how to generate the data!
465 static const uint8_t stm32l4_flash_write_code[] = {
466 0xd0, 0xf8, 0x00, 0x80, 0xb8, 0xf1, 0x00, 0x0f, 0x1e, 0xd0, 0x45, 0x68,
467 0xb8, 0xeb, 0x05, 0x06, 0x07, 0x2e, 0xf5, 0xd3, 0xdf, 0xf8, 0x34, 0x60,
468 0x66, 0x61, 0xf5, 0xe8, 0x02, 0x67, 0xe2, 0xe8, 0x02, 0x67, 0xbf, 0xf3,
469 0x4f, 0x8f, 0x26, 0x69, 0x16, 0xf4, 0x80, 0x3f, 0xfb, 0xd1, 0x16, 0xf0,
470 0xfa, 0x0f, 0x07, 0xd1, 0x8d, 0x42, 0x28, 0xbf, 0x00, 0xf1, 0x08, 0x05,
471 0x45, 0x60, 0x01, 0x3b, 0x13, 0xb1, 0xdd, 0xe7, 0x00, 0x21, 0x41, 0x60,
472 0x30, 0x46, 0x00, 0xbe, 0x01, 0x00, 0x00, 0x00
475 if (target_alloc_working_area(target, sizeof(stm32l4_flash_write_code),
476 &write_algorithm) != ERROR_OK) {
477 LOG_WARNING("no working area available, can't do block memory writes");
478 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
481 retval = target_write_buffer(target, write_algorithm->address,
482 sizeof(stm32l4_flash_write_code),
483 stm32l4_flash_write_code);
484 if (retval != ERROR_OK)
488 while (target_alloc_working_area_try(target, buffer_size, &source) !=
491 if (buffer_size <= 256) {
492 /* we already allocated the writing code, but failed to get a
493 * buffer, free the algorithm */
494 target_free_working_area(target, write_algorithm);
496 LOG_WARNING("no large enough working area available, can't do block memory writes");
497 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
501 armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
502 armv7m_info.core_mode = ARM_MODE_THREAD;
504 init_reg_param(®_params[0], "r0", 32, PARAM_IN_OUT); /* buffer start, status (out) */
505 init_reg_param(®_params[1], "r1", 32, PARAM_OUT); /* buffer end */
506 init_reg_param(®_params[2], "r2", 32, PARAM_OUT); /* target address */
507 init_reg_param(®_params[3], "r3", 32, PARAM_OUT); /* count (double word-64bit) */
508 init_reg_param(®_params[4], "r4", 32, PARAM_OUT); /* flash base */
510 buf_set_u32(reg_params[0].value, 0, 32, source->address);
511 buf_set_u32(reg_params[1].value, 0, 32, source->address + source->size);
512 buf_set_u32(reg_params[2].value, 0, 32, address);
513 buf_set_u32(reg_params[3].value, 0, 32, count / 4);
514 buf_set_u32(reg_params[4].value, 0, 32, STM32_FLASH_BASE);
516 retval = target_run_flash_async_algorithm(target, buffer, count, 2,
519 source->address, source->size,
520 write_algorithm->address, 0,
523 if (retval == ERROR_FLASH_OPERATION_FAILED) {
524 LOG_ERROR("error executing stm32l4 flash write algorithm");
526 uint32_t error = buf_get_u32(reg_params[0].value, 0, 32) & FLASH_ERROR;
528 if (error & FLASH_WRPERR)
529 LOG_ERROR("flash memory write protected");
532 LOG_ERROR("flash write failed = %08" PRIx32, error);
533 /* Clear but report errors */
534 target_write_u32(target, STM32_FLASH_SR, error);
539 target_free_working_area(target, source);
540 target_free_working_area(target, write_algorithm);
542 destroy_reg_param(®_params[0]);
543 destroy_reg_param(®_params[1]);
544 destroy_reg_param(®_params[2]);
545 destroy_reg_param(®_params[3]);
546 destroy_reg_param(®_params[4]);
551 static int stm32l4_write(struct flash_bank *bank, const uint8_t *buffer,
552 uint32_t offset, uint32_t count)
554 struct target *target = bank->target;
557 if (bank->target->state != TARGET_HALTED) {
558 LOG_ERROR("Target not halted");
559 return ERROR_TARGET_NOT_HALTED;
563 LOG_WARNING("offset 0x%" PRIx32 " breaks required 8-byte alignment",
565 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
569 LOG_WARNING("Padding %d bytes to keep 8-byte write size",
571 count = (count + 7) & ~7;
572 /* This pads the write chunk with random bytes by overrunning the
573 * write buffer. Padding with the erased pattern 0xff is purely
574 * cosmetical, as 8-byte flash words are ECC secured and the first
575 * write will program the ECC bits. A second write would need
576 * to reprogramm these ECC bits.
577 * But this can only be done after erase!
581 retval = stm32l4_unlock_reg(target);
582 if (retval != ERROR_OK)
585 /* Only full double words (8-byte) can be programmed*/
586 retval = stm32l4_write_block(bank, buffer, offset, count / 2);
587 if (retval != ERROR_OK) {
588 LOG_WARNING("block write failed");
592 LOG_WARNING("block write succeeded");
593 return target_write_u32(target, STM32_FLASH_CR, FLASH_LOCK);
596 static int stm32l4_probe(struct flash_bank *bank)
598 struct target *target = bank->target;
599 struct stm32l4_flash_bank *stm32l4_info = bank->driver_priv;
601 uint16_t flash_size_in_kb = 0xffff;
604 uint32_t base_address = 0x08000000;
606 stm32l4_info->probed = 0;
608 /* read stm32 device id register */
609 int retval = target_read_u32(target, DBGMCU_IDCODE, &device_id);
610 if (retval != ERROR_OK)
612 LOG_INFO("device id = 0x%08" PRIx32 "", device_id);
614 /* set max flash size depending on family */
615 switch (device_id & 0xfff) {
619 LOG_WARNING("Cannot identify target as a STM32L4 family.");
623 /* get flash size from target. */
624 retval = target_read_u16(target, FLASH_SIZE_REG, &flash_size_in_kb);
626 /* get options to for DUAL BANK. */
627 retval = target_read_u32(target, STM32_FLASH_OPTR, &options);
629 /* only devices with < 1024 kiB may be set to single bank dual banks */
630 if ((flash_size_in_kb == 1024) || !(options & OPT_DUALBANK))
631 stm32l4_info->option_bytes.bank_b_start = 256;
633 stm32l4_info->option_bytes.bank_b_start = flash_size_in_kb << 9;
635 LOG_INFO("flash size = %dkbytes", flash_size_in_kb);
637 /* did we assign flash size? */
638 assert((flash_size_in_kb != 0xffff) && flash_size_in_kb);
640 /* calculate numbers of pages */
641 int num_pages = flash_size_in_kb / 2;
643 /* check that calculation result makes sense */
644 assert(num_pages > 0);
648 bank->sectors = NULL;
651 bank->base = base_address;
652 bank->size = num_pages * (1 << 11);
653 bank->num_sectors = num_pages;
654 bank->sectors = malloc(sizeof(struct flash_sector) * num_pages);
656 return ERROR_FAIL; /* Checkme: What better error to use?*/
658 for (i = 0; i < num_pages; i++) {
659 bank->sectors[i].offset = i << 11;
660 bank->sectors[i].size = 1 << 11;
661 bank->sectors[i].is_erased = -1;
662 bank->sectors[i].is_protected = 1;
665 stm32l4_info->probed = 1;
670 static int stm32l4_auto_probe(struct flash_bank *bank)
672 struct stm32l4_flash_bank *stm32l4_info = bank->driver_priv;
673 if (stm32l4_info->probed)
675 return stm32l4_probe(bank);
678 static int get_stm32l4_info(struct flash_bank *bank, char *buf, int buf_size)
680 struct target *target = bank->target;
681 uint32_t dbgmcu_idcode;
683 /* read stm32 device id register */
684 int retval = target_read_u32(target, DBGMCU_IDCODE, &dbgmcu_idcode);
685 if (retval != ERROR_OK)
688 uint16_t device_id = dbgmcu_idcode & 0xffff;
689 uint8_t rev_id = dbgmcu_idcode >> 28;
690 uint8_t rev_minor = 0;
693 for (i = 16; i < 28; i++) {
694 if (dbgmcu_idcode & (1 << i))
700 const char *device_str;
704 device_str = "STM32L4xx";
708 snprintf(buf, buf_size, "Cannot identify target as a STM32L4\n");
712 snprintf(buf, buf_size, "%s - Rev: %1d.%02d",
713 device_str, rev_id, rev_minor);
718 COMMAND_HANDLER(stm32l4_handle_lock_command)
720 struct target *target = NULL;
721 struct stm32l4_flash_bank *stm32l4_info = NULL;
724 return ERROR_COMMAND_SYNTAX_ERROR;
726 struct flash_bank *bank;
727 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
728 if (ERROR_OK != retval)
731 stm32l4_info = bank->driver_priv;
732 target = bank->target;
734 if (target->state != TARGET_HALTED) {
735 LOG_ERROR("Target not halted");
736 return ERROR_TARGET_NOT_HALTED;
739 if (stm32l4_read_options(bank) != ERROR_OK) {
740 command_print(CMD_CTX, "%s failed to read options",
745 /* set readout protection */
746 stm32l4_info->option_bytes.RDP = 0;
748 if (stm32l4_write_options(bank) != ERROR_OK) {
749 command_print(CMD_CTX, "%s failed to lock device", bank->driver->name);
753 command_print(CMD_CTX, "%s locked", bank->driver->name);
758 COMMAND_HANDLER(stm32l4_handle_unlock_command)
760 struct target *target = NULL;
761 struct stm32l4_flash_bank *stm32l4_info = NULL;
764 return ERROR_COMMAND_SYNTAX_ERROR;
766 struct flash_bank *bank;
767 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
768 if (ERROR_OK != retval)
771 stm32l4_info = bank->driver_priv;
772 target = bank->target;
774 if (target->state != TARGET_HALTED) {
775 LOG_ERROR("Target not halted");
776 return ERROR_TARGET_NOT_HALTED;
779 if (stm32l4_read_options(bank) != ERROR_OK) {
780 command_print(CMD_CTX, "%s failed to read options", bank->driver->name);
784 /* clear readout protection and complementary option bytes
785 * this will also force a device unlock if set */
786 stm32l4_info->option_bytes.RDP = 0xAA;
788 if (stm32l4_write_options(bank) != ERROR_OK) {
789 command_print(CMD_CTX, "%s failed to unlock device",
794 command_print(CMD_CTX, "%s unlocked.\n"
795 "INFO: a reset or power cycle is required "
796 "for the new settings to take effect.", bank->driver->name);
801 static int stm32l4_mass_erase(struct flash_bank *bank, uint32_t action)
804 struct target *target = bank->target;
806 if (target->state != TARGET_HALTED) {
807 LOG_ERROR("Target not halted");
808 return ERROR_TARGET_NOT_HALTED;
811 retval = stm32l4_unlock_reg(target);
812 if (retval != ERROR_OK)
815 /* mass erase flash memory */
816 retval = target_write_u32(
817 target, stm32l4_get_flash_reg(bank, STM32_FLASH_CR), action);
818 if (retval != ERROR_OK)
820 retval = target_write_u32(
821 target, stm32l4_get_flash_reg(bank, STM32_FLASH_CR),
822 action | FLASH_STRT);
823 if (retval != ERROR_OK)
826 retval = stm32l4_wait_status_busy(bank, FLASH_ERASE_TIMEOUT);
827 if (retval != ERROR_OK)
830 retval = target_write_u32(
831 target, stm32l4_get_flash_reg(bank, STM32_FLASH_CR), FLASH_LOCK);
832 if (retval != ERROR_OK)
838 COMMAND_HANDLER(stm32l4_handle_mass_erase_command)
844 command_print(CMD_CTX, "stm32x mass_erase <STM32L4 bank>");
845 return ERROR_COMMAND_SYNTAX_ERROR;
848 struct flash_bank *bank;
849 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
850 if (ERROR_OK != retval)
853 action = FLASH_MER1 | FLASH_MER2;
854 retval = stm32l4_mass_erase(bank, action);
855 if (retval == ERROR_OK) {
856 /* set all sectors as erased */
857 for (i = 0; i < bank->num_sectors; i++)
858 bank->sectors[i].is_erased = 1;
860 command_print(CMD_CTX, "stm32x mass erase complete");
862 command_print(CMD_CTX, "stm32x mass erase failed");
868 static const struct command_registration stm32l4_exec_command_handlers[] = {
871 .handler = stm32l4_handle_lock_command,
872 .mode = COMMAND_EXEC,
874 .help = "Lock entire flash device.",
878 .handler = stm32l4_handle_unlock_command,
879 .mode = COMMAND_EXEC,
881 .help = "Unlock entire protected flash device.",
884 .name = "mass_erase",
885 .handler = stm32l4_handle_mass_erase_command,
886 .mode = COMMAND_EXEC,
888 .help = "Erase entire flash device.",
890 COMMAND_REGISTRATION_DONE
893 static const struct command_registration stm32l4_command_handlers[] = {
897 .help = "stm32l4x flash command group",
899 .chain = stm32l4_exec_command_handlers,
901 COMMAND_REGISTRATION_DONE
904 struct flash_driver stm32l4x_flash = {
906 .commands = stm32l4_command_handlers,
907 .flash_bank_command = stm32l4_flash_bank_command,
908 .erase = stm32l4_erase,
909 .protect = stm32l4_protect,
910 .write = stm32l4_write,
911 .read = default_flash_read,
912 .probe = stm32l4_probe,
913 .auto_probe = stm32l4_auto_probe,
914 .erase_check = default_flash_blank_check,
915 .protect_check = stm32l4_protect_check,
916 .info = get_stm32l4_info,