Code Review / openocd.git / blob
? search:


6510e75dc1ce127706ef8263f5b44c3f6550bd5e
[openocd.git] / src / flash / nor / stm32f2x.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
7 * *
8 * Copyright (C) 2011 Øyvind Harboe *
9 * oyvind.harboe@zylin.com *
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
20 * *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
23 ***************************************************************************/
24
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28
29 #include "imp.h"
30 #include <helper/binarybuffer.h>
31 #include <target/algorithm.h>
32 #include <target/armv7m.h>
33
34 /* Regarding performance:
35 *
36 * Short story - it might be best to leave the performance at
37 * current levels.
38 *
39 * You may see a jump in speed if you change to using
40 * 32bit words for the block programming.
41 *
42 * Its a shame you cannot use the double word as its
43 * even faster - but you require external VPP for that mode.
44 *
45 * Having said all that 16bit writes give us the widest vdd
46 * operating range, so may be worth adding a note to that effect.
47 *
48 */
49
50 /* Danger!!!! The STM32F1x and STM32F2x series actually have
51 * quite different flash controllers.
52 *
53 * What's more scary is that the names of the registers and their
54 * addresses are the same, but the actual bits and what they do are
55 * can be very different.
56 *
57 * To reduce testing complexity and dangers of regressions,
58 * a separate file is used for stm32fx2x.
59 *
60 * Sector sizes in kiBytes:
61 * 1 MiByte part with 4 x 16, 1 x 64, 7 x 128.
62 * 1.5 MiByte part with 4 x 16, 1 x 64, 11 x 128.
63 * 2 MiByte part with 4 x 16, 1 x 64, 7 x 128, 4 x 16, 1 x 64, 7 x 128.
64 * 1 MiByte STM32F42x/43x part with DB1M Option set:
65 * 4 x 16, 1 x 64, 3 x 128, 4 x 16, 1 x 64, 3 x 128.
66 *
67 * STM32F7[2|3]
68 * 512 kiByte part with 4 x 16, 1 x 64, 3 x 128.
69 *
70 * STM32F7[4|5]
71 * 1 MiByte part with 4 x 32, 1 x 128, 3 x 256.
72 *
73 * STM32F7[6|7]
74 * 1 MiByte part in single bank mode with 4 x 32, 1 x 128, 3 x 256.
75 * 1 MiByte part in dual-bank mode two banks with 4 x 16, 1 x 64, 3 x 128 each.
76 * 2 MiByte part in single-bank mode with 4 x 32, 1 x 128, 7 x 256.
77 * 2 MiByte part in dual-bank mode two banks with 4 x 16, 1 x 64, 7 x 128 each.
78 *
79 * Protection size is sector size.
80 *
81 * Tested with STM3220F-EVAL board.
82 *
83 * STM32F4xx series for reference.
84 *
85 * RM0090
86 * http://www.st.com/web/en/resource/technical/document/reference_manual/DM00031020.pdf
87 *
88 * PM0059
89 * www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/
90 * PROGRAMMING_MANUAL/CD00233952.pdf
91 *
92 * STM32F7xx series for reference.
93 *
94 * RM0385
95 * http://www.st.com/web/en/resource/technical/document/reference_manual/DM00124865.pdf
96 *
97 * RM0410
98 * http://www.st.com/resource/en/reference_manual/dm00224583.pdf
99 *
100 * RM0430
101 * http://www.st.com/resource/en/reference_manual/dm00305666.pdf
102 *
103 * RM0431
104 * http://www.st.com/resource/en/reference_manual/dm00305990.pdf
105 *
106 * STM32F1x series - notice that this code was copy, pasted and knocked
107 * into a stm32f2x driver, so in case something has been converted or
108 * bugs haven't been fixed, here are the original manuals:
109 *
110 * RM0008 - Reference manual
111 *
112 * RM0042, the Flash programming manual for low-, medium- high-density and
113 * connectivity line STM32F10x devices
114 *
115 * PM0068, the Flash programming manual for XL-density STM32F10x devices.
116 *
117 */
118
119 /* Erase time can be as high as 1000ms, 10x this and it's toast... */
120 #define FLASH_ERASE_TIMEOUT 10000
121 #define FLASH_WRITE_TIMEOUT 5
122
123 /* Mass erase time can be as high as 32 s in x8 mode. */
124 #define FLASH_MASS_ERASE_TIMEOUT 33000
125
126 #define FLASH_BANK_BASE 0x80000000
127
128 #define STM32F2_OTP_SIZE 512
129 #define STM32F2_OTP_SECTOR_SIZE 32
130 #define STM32F2_OTP_BANK_BASE 0x1fff7800
131 #define STM32F2_OTP_LOCK_BASE ((STM32F2_OTP_BANK_BASE) + (STM32F2_OTP_SIZE))
132
133 /* see RM0410 section 3.6 "One-time programmable bytes" */
134 #define STM32F7_OTP_SECTOR_SIZE 64
135 #define STM32F7_OTP_SIZE 1024
136 #define STM32F7_OTP_BANK_BASE 0x1ff0f000
137 #define STM32F7_OTP_LOCK_BASE ((STM32F7_OTP_BANK_BASE) + (STM32F7_OTP_SIZE))
138
139 #define STM32_FLASH_BASE 0x40023c00
140 #define STM32_FLASH_ACR 0x40023c00
141 #define STM32_FLASH_KEYR 0x40023c04
142 #define STM32_FLASH_OPTKEYR 0x40023c08
143 #define STM32_FLASH_SR 0x40023c0C
144 #define STM32_FLASH_CR 0x40023c10
145 #define STM32_FLASH_OPTCR 0x40023c14
146 #define STM32_FLASH_OPTCR1 0x40023c18
147 #define STM32_FLASH_OPTCR2 0x40023c1c
148
149 /* FLASH_CR register bits */
150 #define FLASH_PG (1 << 0)
151 #define FLASH_SER (1 << 1)
152 #define FLASH_MER (1 << 2) /* MER/MER1 for f76x/77x */
153 #define FLASH_MER1 (1 << 15) /* MER2 for f76x/77x, confusing ... */
154 #define FLASH_STRT (1 << 16)
155 #define FLASH_PSIZE_8 (0 << 8)
156 #define FLASH_PSIZE_16 (1 << 8)
157 #define FLASH_PSIZE_32 (2 << 8)
158 #define FLASH_PSIZE_64 (3 << 8)
159 /* The sector number encoding is not straight binary for dual bank flash. */
160 #define FLASH_SNB(a) ((a) << 3)
161 #define FLASH_LOCK (1 << 31)
162
163 /* FLASH_SR register bits */
164 #define FLASH_BSY (1 << 16)
165 #define FLASH_PGSERR (1 << 7) /* Programming sequence error */
166 #define FLASH_PGPERR (1 << 6) /* Programming parallelism error */
167 #define FLASH_PGAERR (1 << 5) /* Programming alignment error */
168 #define FLASH_WRPERR (1 << 4) /* Write protection error */
169 #define FLASH_OPERR (1 << 1) /* Operation error */
170
171 #define FLASH_ERROR (FLASH_PGSERR | FLASH_PGPERR | FLASH_PGAERR | FLASH_WRPERR | FLASH_OPERR)
172
173 /* STM32_FLASH_OPTCR register bits */
174 #define OPTCR_LOCK (1 << 0)
175 #define OPTCR_START (1 << 1)
176 #define OPTCR_NDBANK (1 << 29) /* not dual bank mode */
177 #define OPTCR_DB1M (1 << 30) /* 1 MiB devices dual flash bank option */
178 #define OPTCR_SPRMOD (1 << 31) /* switches PCROPi/nWPRi interpretation */
179
180 /* STM32_FLASH_OPTCR2 register bits */
181 #define OPTCR2_PCROP_RDP (1 << 31) /* erase PCROP zone when decreasing RDP */
182
183 /* register unlock keys */
184 #define KEY1 0x45670123
185 #define KEY2 0xCDEF89AB
186
187 /* option register unlock key */
188 #define OPTKEY1 0x08192A3B
189 #define OPTKEY2 0x4C5D6E7F
190
191 struct stm32x_options {
192 uint8_t RDP;
193 uint16_t user_options; /* bit 0-7 usual options, bit 8-11 extra options */
194 uint32_t protection;
195 uint32_t boot_addr;
196 uint32_t optcr2_pcrop;
197 };
198
199 struct stm32x_flash_bank {
200 struct stm32x_options option_bytes;
201 bool probed;
202 bool otp_unlocked;
203 bool has_large_mem; /* F42x/43x/469/479/7xx in dual bank mode */
204 bool has_extra_options; /* F42x/43x/469/479/7xx */
205 bool has_boot_addr; /* F7xx */
206 bool has_optcr2_pcrop; /* F72x/73x */
207 int protection_bits; /* F413/423 */
208 uint32_t user_bank_size;
209 };
210
211 static bool stm32x_is_otp(struct flash_bank *bank)
212 {
213 return bank->base == STM32F2_OTP_BANK_BASE ||
214 bank->base == STM32F7_OTP_BANK_BASE;
215 }
216
217 static bool stm32x_otp_is_f7(struct flash_bank *bank)
218 {
219 return bank->base == STM32F7_OTP_BANK_BASE;
220 }
221
222 static int stm32x_is_otp_unlocked(struct flash_bank *bank)
223 {
224 struct stm32x_flash_bank *stm32x_info = bank->driver_priv;
225
226 return stm32x_info->otp_unlocked;
227 }
228
229 static int stm32x_otp_disable(struct flash_bank *bank)
230 {
231 struct stm32x_flash_bank *stm32x_info = bank->driver_priv;
232
233 LOG_INFO("OTP memory bank #%u is disabled for write commands.",
234 bank->bank_number);
235 stm32x_info->otp_unlocked = false;
236 return ERROR_OK;
237 }
238
239 static int stm32x_otp_enable(struct flash_bank *bank)
240 {
241 struct stm32x_flash_bank *stm32x_info = bank->driver_priv;
242
243 if (!stm32x_info->otp_unlocked) {
244 LOG_INFO("OTP memory bank #%u is is enabled for write commands.",
245 bank->bank_number);
246 stm32x_info->otp_unlocked = true;
247 } else {
248 LOG_WARNING("OTP memory bank #%u is is already enabled for write commands.",
249 bank->bank_number);
250 }
251 return ERROR_OK;
252 }
253
254 /* flash bank stm32x <base> <size> 0 0 <target#>
255 */
256 FLASH_BANK_COMMAND_HANDLER(stm32x_flash_bank_command)
257 {
258 struct stm32x_flash_bank *stm32x_info;
259
260 if (CMD_ARGC < 6)
261 return ERROR_COMMAND_SYNTAX_ERROR;
262
263 stm32x_info = malloc(sizeof(struct stm32x_flash_bank));
264 bank->driver_priv = stm32x_info;
265
266 stm32x_info->probed = false;
267 stm32x_info->otp_unlocked = false;
268 stm32x_info->user_bank_size = bank->size;
269
270 return ERROR_OK;
271 }
272
273 static inline int stm32x_get_flash_reg(struct flash_bank *bank, uint32_t reg)
274 {
275 return reg;
276 }
277
278 static inline int stm32x_get_flash_status(struct flash_bank *bank, uint32_t *status)
279 {
280 struct target *target = bank->target;
281 return target_read_u32(target, stm32x_get_flash_reg(bank, STM32_FLASH_SR), status);
282 }
283
284 static int stm32x_wait_status_busy(struct flash_bank *bank, int timeout)
285 {
286 struct target *target = bank->target;
287 uint32_t status;
288 int retval = ERROR_OK;
289
290 /* wait for busy to clear */
291 for (;;) {
292 retval = stm32x_get_flash_status(bank, &status);
293 if (retval != ERROR_OK)
294 return retval;
295 LOG_DEBUG("status: 0x%" PRIx32, status);
296 if ((status & FLASH_BSY) == 0)
297 break;
298 if (timeout-- <= 0) {
299 LOG_ERROR("timed out waiting for flash");
300 return ERROR_FAIL;
301 }
302 alive_sleep(1);
303 }
304
305
306 if (status & FLASH_WRPERR) {
307 LOG_ERROR("stm32x device protected");
308 retval = ERROR_FAIL;
309 }
310
311 /* Clear but report errors */
312 if (status & FLASH_ERROR) {
313 if (retval == ERROR_OK)
314 retval = ERROR_FAIL;
315 /* If this operation fails, we ignore it and report the original
316 * retval
317 */
318 target_write_u32(target, stm32x_get_flash_reg(bank, STM32_FLASH_SR),
319 status & FLASH_ERROR);
320 }
321 return retval;
322 }
323
324 static int stm32x_unlock_reg(struct target *target)
325 {
326 uint32_t ctrl;
327
328 /* first check if not already unlocked
329 * otherwise writing on STM32_FLASH_KEYR will fail
330 */
331 int retval = target_read_u32(target, STM32_FLASH_CR, &ctrl);
332 if (retval != ERROR_OK)
333 return retval;
334
335 if ((ctrl & FLASH_LOCK) == 0)
336 return ERROR_OK;
337
338 /* unlock flash registers */
339 retval = target_write_u32(target, STM32_FLASH_KEYR, KEY1);
340 if (retval != ERROR_OK)
341 return retval;
342
343 retval = target_write_u32(target, STM32_FLASH_KEYR, KEY2);
344 if (retval != ERROR_OK)
345 return retval;
346
347 retval = target_read_u32(target, STM32_FLASH_CR, &ctrl);
348 if (retval != ERROR_OK)
349 return retval;
350
351 if (ctrl & FLASH_LOCK) {
352 LOG_ERROR("flash not unlocked STM32_FLASH_CR: 0x%" PRIx32, ctrl);
353 return ERROR_TARGET_FAILURE;
354 }
355
356 return ERROR_OK;
357 }
358
359 static int stm32x_unlock_option_reg(struct target *target)
360 {
361 uint32_t ctrl;
362
363 int retval = target_read_u32(target, STM32_FLASH_OPTCR, &ctrl);
364 if (retval != ERROR_OK)
365 return retval;
366
367 if ((ctrl & OPTCR_LOCK) == 0)
368 return ERROR_OK;
369
370 /* unlock option registers */
371 retval = target_write_u32(target, STM32_FLASH_OPTKEYR, OPTKEY1);
372 if (retval != ERROR_OK)
373 return retval;
374
375 retval = target_write_u32(target, STM32_FLASH_OPTKEYR, OPTKEY2);
376 if (retval != ERROR_OK)
377 return retval;
378
379 retval = target_read_u32(target, STM32_FLASH_OPTCR, &ctrl);
380 if (retval != ERROR_OK)
381 return retval;
382
383 if (ctrl & OPTCR_LOCK) {
384 LOG_ERROR("options not unlocked STM32_FLASH_OPTCR: 0x%" PRIx32, ctrl);
385 return ERROR_TARGET_FAILURE;
386 }
387
388 return ERROR_OK;
389 }
390
391 static int stm32x_read_options(struct flash_bank *bank)
392 {
393 uint32_t optiondata;
394 struct stm32x_flash_bank *stm32x_info = NULL;
395 struct target *target = bank->target;
396
397 stm32x_info = bank->driver_priv;
398
399 /* read current option bytes */
400 int retval = target_read_u32(target, STM32_FLASH_OPTCR, &optiondata);
401 if (retval != ERROR_OK)
402 return retval;
403
404 /* caution: F2 implements 5 bits (WDG_SW only)
405 * whereas F7 6 bits (IWDG_SW and WWDG_SW) in user_options */
406 stm32x_info->option_bytes.user_options = optiondata & 0xfc;
407 stm32x_info->option_bytes.RDP = (optiondata >> 8) & 0xff;
408 stm32x_info->option_bytes.protection =
409 (optiondata >> 16) & (~(0xffff << stm32x_info->protection_bits) & 0xffff);
410
411 if (stm32x_info->has_extra_options) {
412 /* F42x/43x/469/479 and 7xx have up to 4 bits of extra options */
413 stm32x_info->option_bytes.user_options |= (optiondata >> 20) &
414 ((0xf00 << (stm32x_info->protection_bits - 12)) & 0xf00);
415 }
416
417 if (stm32x_info->has_large_mem || stm32x_info->has_boot_addr) {
418 retval = target_read_u32(target, STM32_FLASH_OPTCR1, &optiondata);
419 if (retval != ERROR_OK)
420 return retval;
421
422 /* FLASH_OPTCR1 has quite different meanings ... */
423 if (stm32x_info->has_boot_addr) {
424 /* for F7xx it contains boot0 and boot1 */
425 stm32x_info->option_bytes.boot_addr = optiondata;
426 } else {
427 /* for F42x/43x/469/479 it contains 12 additional protection bits */
428 stm32x_info->option_bytes.protection |= (optiondata >> 4) & 0x00fff000;
429 }
430 }
431
432 if (stm32x_info->has_optcr2_pcrop) {
433 retval = target_read_u32(target, STM32_FLASH_OPTCR2, &optiondata);
434 if (retval != ERROR_OK)
435 return retval;
436
437 stm32x_info->option_bytes.optcr2_pcrop = optiondata;
438 if (stm32x_info->has_optcr2_pcrop &&
439 (stm32x_info->option_bytes.optcr2_pcrop & ~OPTCR2_PCROP_RDP)) {
440 LOG_INFO("PCROP Engaged");
441 }
442 } else {
443 stm32x_info->option_bytes.optcr2_pcrop = 0x0;
444 }
445
446 if (stm32x_info->option_bytes.RDP != 0xAA)
447 LOG_INFO("Device Security Bit Set");
448
449 return ERROR_OK;
450 }
451
452 static int stm32x_write_options(struct flash_bank *bank)
453 {
454 struct stm32x_flash_bank *stm32x_info = NULL;
455 struct target *target = bank->target;
456 uint32_t optiondata, optiondata2;
457
458 stm32x_info = bank->driver_priv;
459
460 int retval = stm32x_unlock_option_reg(target);
461 if (retval != ERROR_OK)
462 return retval;
463
464 /* rebuild option data */
465 optiondata = stm32x_info->option_bytes.user_options & 0xfc;
466 optiondata |= stm32x_info->option_bytes.RDP << 8;
467 optiondata |= (stm32x_info->option_bytes.protection &
468 (~(0xffff << stm32x_info->protection_bits))) << 16;
469
470 if (stm32x_info->has_extra_options) {
471 /* F42x/43x/469/479 and 7xx have up to 4 bits of extra options */
472 optiondata |= (stm32x_info->option_bytes.user_options &
473 ((0xf00 << (stm32x_info->protection_bits - 12)) & 0xf00)) << 20;
474 }
475
476 if (stm32x_info->has_large_mem || stm32x_info->has_boot_addr) {
477 if (stm32x_info->has_boot_addr) {
478 /* F7xx uses FLASH_OPTCR1 for boot0 and boot1 ... */
479 optiondata2 = stm32x_info->option_bytes.boot_addr;
480 } else {
481 /* F42x/43x/469/479 uses FLASH_OPTCR1 for additional protection bits */
482 optiondata2 = (stm32x_info->option_bytes.protection & 0x00fff000) << 4;
483 }
484
485 retval = target_write_u32(target, STM32_FLASH_OPTCR1, optiondata2);
486 if (retval != ERROR_OK)
487 return retval;
488 }
489
490 /* program extra pcrop register */
491 if (stm32x_info->has_optcr2_pcrop) {
492 retval = target_write_u32(target, STM32_FLASH_OPTCR2,
493 stm32x_info->option_bytes.optcr2_pcrop);
494 if (retval != ERROR_OK)
495 return retval;
496 }
497
498 /* program options */
499 retval = target_write_u32(target, STM32_FLASH_OPTCR, optiondata);
500 if (retval != ERROR_OK)
501 return retval;
502
503 /* start programming cycle */
504 retval = target_write_u32(target, STM32_FLASH_OPTCR, optiondata | OPTCR_START);
505 if (retval != ERROR_OK)
506 return retval;
507
508 /* wait for completion, this might trigger a security erase and take a while */
509 retval = stm32x_wait_status_busy(bank, FLASH_MASS_ERASE_TIMEOUT);
510 if (retval != ERROR_OK)
511 return retval;
512
513 /* relock registers */
514 retval = target_write_u32(target, STM32_FLASH_OPTCR, optiondata | OPTCR_LOCK);
515 if (retval != ERROR_OK)
516 return retval;
517
518 return ERROR_OK;
519 }
520
521 static int stm32x_otp_read_protect(struct flash_bank *bank)
522 {
523 struct target *target = bank->target;
524 uint32_t lock_base;
525 int retval;
526 uint8_t lock;
527
528 lock_base = stm32x_otp_is_f7(bank) ? STM32F7_OTP_LOCK_BASE
529 : STM32F2_OTP_LOCK_BASE;
530
531 for (unsigned int i = 0; i < bank->num_sectors; i++) {
532 retval = target_read_u8(target, lock_base + i, &lock);
533 if (retval != ERROR_OK)
534 return retval;
535 bank->sectors[i].is_protected = !lock;
536 }
537
538 return ERROR_OK;
539 }
540
541 static int stm32x_otp_protect(struct flash_bank *bank, unsigned int first,
542 unsigned int last)
543 {
544 struct target *target = bank->target;
545 uint32_t lock_base;
546 int i, retval;
547 uint8_t lock;
548
549 assert((first <= last) && (last < bank->num_sectors));
550
551 lock_base = stm32x_otp_is_f7(bank) ? STM32F7_OTP_LOCK_BASE
552 : STM32F2_OTP_LOCK_BASE;
553
554 for (i = first; first <= last; i++) {
555 retval = target_read_u8(target, lock_base + i, &lock);
556 if (retval != ERROR_OK)
557 return retval;
558 if (lock)
559 continue;
560
561 lock = 0xff;
562 retval = target_write_u8(target, lock_base + i, lock);
563 if (retval != ERROR_OK)
564 return retval;
565 }
566
567 return ERROR_OK;
568 }
569
570 static int stm32x_protect_check(struct flash_bank *bank)
571 {
572 struct stm32x_flash_bank *stm32x_info = bank->driver_priv;
573 struct flash_sector *prot_blocks;
574 int num_prot_blocks;
575 int retval;
576
577 /* if it's the OTP bank, look at the lock bits there */
578 if (stm32x_is_otp(bank))
579 return stm32x_otp_read_protect(bank);
580
581 /* read write protection settings */
582 retval = stm32x_read_options(bank);
583 if (retval != ERROR_OK) {
584 LOG_DEBUG("unable to read option bytes");
585 return retval;
586 }
587
588 if (bank->prot_blocks) {
589 num_prot_blocks = bank->num_prot_blocks;
590 prot_blocks = bank->prot_blocks;
591 } else {
592 num_prot_blocks = bank->num_sectors;
593 prot_blocks = bank->sectors;
594 }
595
596 for (int i = 0; i < num_prot_blocks; i++)
597 prot_blocks[i].is_protected =
598 ~(stm32x_info->option_bytes.protection >> i) & 1;
599
600 return ERROR_OK;
601 }
602
603 static int stm32x_erase(struct flash_bank *bank, unsigned int first,
604 unsigned int last)
605 {
606 struct stm32x_flash_bank *stm32x_info = bank->driver_priv;
607 struct target *target = bank->target;
608
609 if (stm32x_is_otp(bank)) {
610 LOG_ERROR("Cannot erase OTP memory");
611 return ERROR_FAIL;
612 }
613
614 assert((first <= last) && (last < bank->num_sectors));
615
616 if (bank->target->state != TARGET_HALTED) {
617 LOG_ERROR("Target not halted");
618 return ERROR_TARGET_NOT_HALTED;
619 }
620
621 int retval;
622 retval = stm32x_unlock_reg(target);
623 if (retval != ERROR_OK)
624 return retval;
625
626 /*
627 Sector Erase
628 To erase a sector, follow the procedure below:
629 1. Check that no Flash memory operation is ongoing by checking the BSY bit in the
630 FLASH_SR register
631 2. Set the SER bit and select the sector
632 you wish to erase (SNB) in the FLASH_CR register
633 3. Set the STRT bit in the FLASH_CR register
634 4. Wait for the BSY bit to be cleared
635 */
636
637 for (unsigned int i = first; i <= last; i++) {
638 unsigned int snb;
639 if (stm32x_info->has_large_mem && i >= 12)
640 snb = (i - 12) | 0x10;
641 else
642 snb = i;
643
644 retval = target_write_u32(target,
645 stm32x_get_flash_reg(bank, STM32_FLASH_CR), FLASH_SER | FLASH_SNB(snb) | FLASH_STRT);
646 if (retval != ERROR_OK)
647 return retval;
648
649 retval = stm32x_wait_status_busy(bank, FLASH_ERASE_TIMEOUT);
650 if (retval != ERROR_OK)
651 return retval;
652
653 bank->sectors[i].is_erased = 1;
654 }
655
656 retval = target_write_u32(target, stm32x_get_flash_reg(bank, STM32_FLASH_CR), FLASH_LOCK);
657 if (retval != ERROR_OK)
658 return retval;
659
660 return ERROR_OK;
661 }
662
663 static int stm32x_protect(struct flash_bank *bank, int set, unsigned int first,
664 unsigned int last)
665 {
666 struct target *target = bank->target;
667 struct stm32x_flash_bank *stm32x_info = bank->driver_priv;
668
669 if (target->state != TARGET_HALTED) {
670 LOG_ERROR("Target not halted");
671 return ERROR_TARGET_NOT_HALTED;
672 }
673
674 if (stm32x_is_otp(bank)) {
675 if (!set)
676 return ERROR_COMMAND_ARGUMENT_INVALID;
677
678 return stm32x_otp_protect(bank, first, last);
679 }
680
681 /* read protection settings */
682 int retval = stm32x_read_options(bank);
683 if (retval != ERROR_OK) {
684 LOG_DEBUG("unable to read option bytes");
685 return retval;
686 }
687
688 for (unsigned int i = first; i <= last; i++) {
689 if (set)
690 stm32x_info->option_bytes.protection &= ~(1 << i);
691 else
692 stm32x_info->option_bytes.protection |= (1 << i);
693 }
694
695 retval = stm32x_write_options(bank);
696 if (retval != ERROR_OK)
697 return retval;
698
699 return ERROR_OK;
700 }
701
702 static int stm32x_write_block(struct flash_bank *bank, const uint8_t *buffer,
703 uint32_t offset, uint32_t count)
704 {
705 struct target *target = bank->target;
706 uint32_t buffer_size = 16384;
707 struct working_area *write_algorithm;
708 struct working_area *source;
709 uint32_t address = bank->base + offset;
710 struct reg_param reg_params[5];
711 struct armv7m_algorithm armv7m_info;
712 int retval = ERROR_OK;
713
714 static const uint8_t stm32x_flash_write_code[] = {
715 #include "../../../contrib/loaders/flash/stm32/stm32f2x.inc"
716 };
717
718 if (stm32x_is_otp(bank) && !stm32x_is_otp_unlocked(bank)) {
719 LOG_ERROR("OTP memory bank is disabled for write commands.");
720 return ERROR_FAIL;
721 }
722
723 if (target_alloc_working_area(target, sizeof(stm32x_flash_write_code),
724 &write_algorithm) != ERROR_OK) {
725 LOG_WARNING("no working area available, can't do block memory writes");
726 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
727 }
728
729 retval = target_write_buffer(target, write_algorithm->address,
730 sizeof(stm32x_flash_write_code),
731 stm32x_flash_write_code);
732 if (retval != ERROR_OK) {
733 target_free_working_area(target, write_algorithm);
734 return retval;
735 }
736
737 /* memory buffer */
738 while (target_alloc_working_area_try(target, buffer_size, &source) != ERROR_OK) {
739 buffer_size /= 2;
740 if (buffer_size <= 256) {
741 /* we already allocated the writing code, but failed to get a
742 * buffer, free the algorithm */
743 target_free_working_area(target, write_algorithm);
744
745 LOG_WARNING("no large enough working area available, can't do block memory writes");
746 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
747 }
748 }
749
750 armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
751 armv7m_info.core_mode = ARM_MODE_THREAD;
752
753 init_reg_param(&reg_params[0], "r0", 32, PARAM_IN_OUT); /* buffer start, status (out) */
754 init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT); /* buffer end */
755 init_reg_param(&reg_params[2], "r2", 32, PARAM_OUT); /* target address */
756 init_reg_param(&reg_params[3], "r3", 32, PARAM_OUT); /* count (halfword-16bit) */
757 init_reg_param(&reg_params[4], "r4", 32, PARAM_OUT); /* flash base */
758
759 buf_set_u32(reg_params[0].value, 0, 32, source->address);
760 buf_set_u32(reg_params[1].value, 0, 32, source->address + source->size);
761 buf_set_u32(reg_params[2].value, 0, 32, address);
762 buf_set_u32(reg_params[3].value, 0, 32, count);
763 buf_set_u32(reg_params[4].value, 0, 32, STM32_FLASH_BASE);
764
765 retval = target_run_flash_async_algorithm(target, buffer, count, 2,
766 0, NULL,
767 5, reg_params,
768 source->address, source->size,
769 write_algorithm->address, 0,
770 &armv7m_info);
771
772 if (retval == ERROR_FLASH_OPERATION_FAILED) {
773 LOG_ERROR("error executing stm32x flash write algorithm");
774
775 uint32_t error = buf_get_u32(reg_params[0].value, 0, 32) & FLASH_ERROR;
776
777 if (error & FLASH_WRPERR)
778 LOG_ERROR("flash memory write protected");
779
780 if (error != 0) {
781 LOG_ERROR("flash write failed = 0x%08" PRIx32, error);
782 /* Clear but report errors */
783 target_write_u32(target, STM32_FLASH_SR, error);
784 retval = ERROR_FAIL;
785 }
786 }
787
788 target_free_working_area(target, source);
789 target_free_working_area(target, write_algorithm);
790
791 destroy_reg_param(&reg_params[0]);
792 destroy_reg_param(&reg_params[1]);
793 destroy_reg_param(&reg_params[2]);
794 destroy_reg_param(&reg_params[3]);
795 destroy_reg_param(&reg_params[4]);
796
797 return retval;
798 }
799
800 static int stm32x_write(struct flash_bank *bank, const uint8_t *buffer,
801 uint32_t offset, uint32_t count)
802 {
803 struct target *target = bank->target;
804 uint32_t words_remaining = (count / 2);
805 uint32_t bytes_remaining = (count & 0x00000001);
806 uint32_t address = bank->base + offset;
807 uint32_t bytes_written = 0;
808 int retval;
809
810 if (bank->target->state != TARGET_HALTED) {
811 LOG_ERROR("Target not halted");
812 return ERROR_TARGET_NOT_HALTED;
813 }
814
815 if (offset & 0x1) {
816 LOG_WARNING("offset 0x%" PRIx32 " breaks required 2-byte alignment", offset);
817 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
818 }
819
820 retval = stm32x_unlock_reg(target);
821 if (retval != ERROR_OK)
822 return retval;
823
824 /* multiple half words (2-byte) to be programmed? */
825 if (words_remaining > 0) {
826 /* try using a block write */
827 retval = stm32x_write_block(bank, buffer, offset, words_remaining);
828 if (retval != ERROR_OK) {
829 if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE) {
830 /* if block write failed (no sufficient working area),
831 * we use normal (slow) single dword accesses */
832 LOG_WARNING("couldn't use block writes, falling back to single memory accesses");
833 }
834 } else {
835 buffer += words_remaining * 2;
836 address += words_remaining * 2;
837 words_remaining = 0;
838 }
839 }
840
841 if ((retval != ERROR_OK) && (retval != ERROR_TARGET_RESOURCE_NOT_AVAILABLE))
842 return retval;
843
844 /*
845 Standard programming
846 The Flash memory programming sequence is as follows:
847 1. Check that no main Flash memory operation is ongoing by checking the BSY bit in the
848 FLASH_SR register.
849 2. Set the PG bit in the FLASH_CR register
850 3. Perform the data write operation(s) to the desired memory address (inside main
851 memory block or OTP area):
852 – – Half-word access in case of x16 parallelism
853 – Word access in case of x32 parallelism
854 –
855 4.
856 Byte access in case of x8 parallelism
857 Double word access in case of x64 parallelism
858 Wait for the BSY bit to be cleared
859 */
860 while (words_remaining > 0) {
861 uint16_t value;
862 memcpy(&value, buffer + bytes_written, sizeof(uint16_t));
863
864 retval = target_write_u32(target, stm32x_get_flash_reg(bank, STM32_FLASH_CR),
865 FLASH_PG | FLASH_PSIZE_16);
866 if (retval != ERROR_OK)
867 return retval;
868
869 retval = target_write_u16(target, address, value);
870 if (retval != ERROR_OK)
871 return retval;
872
873 retval = stm32x_wait_status_busy(bank, FLASH_WRITE_TIMEOUT);
874 if (retval != ERROR_OK)
875 return retval;
876
877 bytes_written += 2;
878 words_remaining--;
879 address += 2;
880 }
881
882 if (bytes_remaining) {
883 retval = target_write_u32(target, stm32x_get_flash_reg(bank, STM32_FLASH_CR),
884 FLASH_PG | FLASH_PSIZE_8);
885 if (retval != ERROR_OK)
886 return retval;
887 retval = target_write_u8(target, address, buffer[bytes_written]);
888 if (retval != ERROR_OK)
889 return retval;
890
891 retval = stm32x_wait_status_busy(bank, FLASH_WRITE_TIMEOUT);
892 if (retval != ERROR_OK)
893 return retval;
894 }
895
896 return target_write_u32(target, STM32_FLASH_CR, FLASH_LOCK);
897 }
898
899 static void setup_sector(struct flash_bank *bank, unsigned int i,
900 unsigned int size)
901 {
902 assert(i < bank->num_sectors);
903 bank->sectors[i].offset = bank->size;
904 bank->sectors[i].size = size;
905 bank->size += bank->sectors[i].size;
906 LOG_DEBUG("sector %u: %ukBytes", i, size >> 10);
907 }
908
909 static uint16_t sector_size_in_kb(int i, uint16_t max_sector_size_in_kb)
910 {
911 assert(i >= 0);
912 if (i < 4)
913 return max_sector_size_in_kb / 8;
914 if (i == 4)
915 return max_sector_size_in_kb / 2;
916 return max_sector_size_in_kb;
917 }
918
919 static int calculate_number_of_sectors(struct flash_bank *bank,
920 uint16_t flash_size_in_kb,
921 uint16_t max_sector_size_in_kb)
922 {
923 struct stm32x_flash_bank *stm32x_info = bank->driver_priv;
924 uint16_t remaining_flash_size_in_kb = flash_size_in_kb;
925 int nr_sectors;
926
927 /* Dual Bank Flash has two identically-arranged banks of sectors. */
928 if (stm32x_info->has_large_mem)
929 remaining_flash_size_in_kb /= 2;
930
931 for (nr_sectors = 0; remaining_flash_size_in_kb > 0; nr_sectors++) {
932 uint16_t size_in_kb = sector_size_in_kb(nr_sectors, max_sector_size_in_kb);
933 if (size_in_kb > remaining_flash_size_in_kb) {
934 LOG_INFO("%s Bank %" PRIu16 " kiB final sector clipped to %" PRIu16 " kiB",
935 stm32x_info->has_large_mem ? "Dual" : "Single",
936 flash_size_in_kb, remaining_flash_size_in_kb);
937 remaining_flash_size_in_kb = 0;
938 } else {
939 remaining_flash_size_in_kb -= size_in_kb;
940 }
941 }
942
943 return stm32x_info->has_large_mem ? nr_sectors*2 : nr_sectors;
944 }
945
946 static void setup_bank(struct flash_bank *bank, int start,
947 uint16_t flash_size_in_kb, uint16_t max_sector_size_in_kb)
948 {
949 uint16_t remaining_flash_size_in_kb = flash_size_in_kb;
950 int sector_index = 0;
951 while (remaining_flash_size_in_kb > 0) {
952 uint16_t size_in_kb = sector_size_in_kb(sector_index, max_sector_size_in_kb);
953 if (size_in_kb > remaining_flash_size_in_kb) {
954 /* Clip last sector. Already warned in
955 * calculate_number_of_sectors. */
956 size_in_kb = remaining_flash_size_in_kb;
957 }
958 setup_sector(bank, start + sector_index, size_in_kb * 1024);
959 remaining_flash_size_in_kb -= size_in_kb;
960 sector_index++;
961 }
962 }
963
964 static int stm32x_get_device_id(struct flash_bank *bank, uint32_t *device_id)
965 {
966 /* this checks for a stm32f4x errata issue where a
967 * stm32f2x DBGMCU_IDCODE is incorrectly returned.
968 * If the issue is detected target is forced to stm32f4x Rev A.
969 * Only effects Rev A silicon */
970
971 struct target *target = bank->target;
972 uint32_t cpuid;
973
974 /* read stm32 device id register */
975 int retval = target_read_u32(target, 0xE0042000, device_id);
976 if (retval != ERROR_OK)
977 return retval;
978
979 if ((*device_id & 0xfff) == 0x411) {
980 /* read CPUID reg to check core type */
981 retval = target_read_u32(target, 0xE000ED00, &cpuid);
982 if (retval != ERROR_OK)
983 return retval;
984
985 /* check for cortex_m4 */
986 if (((cpuid >> 4) & 0xFFF) == 0xC24) {
987 *device_id &= ~((0xFFFF << 16) | 0xfff);
988 *device_id |= (0x1000 << 16) | 0x413;
989 LOG_INFO("stm32f4x errata detected - fixing incorrect MCU_IDCODE");
990 }
991 }
992 return retval;
993 }
994
995 static int stm32x_probe(struct flash_bank *bank)
996 {
997 struct target *target = bank->target;
998 struct stm32x_flash_bank *stm32x_info = bank->driver_priv;
999 int i, num_prot_blocks, num_sectors;
1000 uint16_t flash_size_in_kb;
1001 uint16_t otp_size_in_b;
1002 uint16_t otp_sector_size;
1003 uint32_t flash_size_reg = 0x1FFF7A22;
1004 uint16_t max_sector_size_in_kb = 128;
1005 uint16_t max_flash_size_in_kb;
1006 uint32_t device_id;
1007 uint32_t base_address = 0x08000000;
1008
1009 stm32x_info->probed = false;
1010 stm32x_info->has_large_mem = false;
1011 stm32x_info->has_boot_addr = false;
1012 stm32x_info->has_extra_options = false;
1013 stm32x_info->has_optcr2_pcrop = false;
1014 stm32x_info->protection_bits = 12; /* max. number of nWRPi bits (in FLASH_OPTCR !!!) */
1015 num_prot_blocks = 0;
1016
1017 if (bank->sectors) {
1018 free(bank->sectors);
1019 bank->num_sectors = 0;
1020 bank->sectors = NULL;
1021 }
1022
1023 if (bank->prot_blocks) {
1024 free(bank->prot_blocks);
1025 bank->num_prot_blocks = 0;
1026 bank->prot_blocks = NULL;
1027 }
1028
1029 /* if explicitly called out as OTP bank, short circuit probe */
1030 if (stm32x_is_otp(bank)) {
1031 if (stm32x_otp_is_f7(bank)) {
1032 otp_size_in_b = STM32F7_OTP_SIZE;
1033 otp_sector_size = STM32F7_OTP_SECTOR_SIZE;
1034 } else {
1035 otp_size_in_b = STM32F2_OTP_SIZE;
1036 otp_sector_size = STM32F2_OTP_SECTOR_SIZE;
1037 }
1038
1039 num_sectors = otp_size_in_b / otp_sector_size;
1040 LOG_INFO("flash size = %" PRIu16 " bytes", otp_size_in_b);
1041
1042 assert(num_sectors > 0);
1043
1044 bank->num_sectors = num_sectors;
1045 bank->sectors = calloc(sizeof(struct flash_sector), num_sectors);
1046
1047 if (stm32x_otp_is_f7(bank))
1048 bank->size = STM32F7_OTP_SIZE;
1049 else
1050 bank->size = STM32F2_OTP_SIZE;
1051
1052 for (i = 0; i < num_sectors; i++) {
1053 bank->sectors[i].offset = i * otp_sector_size;
1054 bank->sectors[i].size = otp_sector_size;
1055 bank->sectors[i].is_erased = 1;
1056 bank->sectors[i].is_protected = 0;
1057 }
1058
1059 stm32x_info->probed = true;
1060 return ERROR_OK;
1061 }
1062
1063 /* read stm32 device id register */
1064 int retval = stm32x_get_device_id(bank, &device_id);
1065 if (retval != ERROR_OK)
1066 return retval;
1067 LOG_INFO("device id = 0x%08" PRIx32, device_id);
1068 device_id &= 0xfff; /* only bits 0-11 are used further on */
1069
1070 /* set max flash size depending on family, id taken from AN2606 */
1071 switch (device_id) {
1072 case 0x411: /* F20x/21x */
1073 case 0x413: /* F40x/41x */
1074 max_flash_size_in_kb = 1024;
1075 break;
1076
1077 case 0x419: /* F42x/43x */
1078 case 0x434: /* F469/479 */
1079 stm32x_info->has_extra_options = true;
1080 max_flash_size_in_kb = 2048;
1081 break;
1082
1083 case 0x423: /* F401xB/C */
1084 max_flash_size_in_kb = 256;
1085 break;
1086
1087 case 0x421: /* F446 */
1088 case 0x431: /* F411 */
1089 case 0x433: /* F401xD/E */
1090 case 0x441: /* F412 */
1091 max_flash_size_in_kb = 512;
1092 break;
1093
1094 case 0x458: /* F410 */
1095 max_flash_size_in_kb = 128;
1096 break;
1097
1098 case 0x449: /* F74x/75x */
1099 max_flash_size_in_kb = 1024;
1100 max_sector_size_in_kb = 256;
1101 flash_size_reg = 0x1FF0F442;
1102 stm32x_info->has_extra_options = true;
1103 stm32x_info->has_boot_addr = true;
1104 break;
1105
1106 case 0x451: /* F76x/77x */
1107 max_flash_size_in_kb = 2048;
1108 max_sector_size_in_kb = 256;
1109 flash_size_reg = 0x1FF0F442;
1110 stm32x_info->has_extra_options = true;
1111 stm32x_info->has_boot_addr = true;
1112 break;
1113
1114 case 0x452: /* F72x/73x */
1115 max_flash_size_in_kb = 512;
1116 flash_size_reg = 0x1FF07A22; /* yes, 0x1FF*0*7A22, not 0x1FF*F*7A22 */
1117 stm32x_info->has_extra_options = true;
1118 stm32x_info->has_boot_addr = true;
1119 stm32x_info->has_optcr2_pcrop = true;
1120 break;
1121
1122 case 0x463: /* F413x/423x */
1123 max_flash_size_in_kb = 1536;
1124 stm32x_info->has_extra_options = true;
1125 stm32x_info->protection_bits = 15;
1126 num_prot_blocks = 15;
1127 break;
1128
1129 default:
1130 LOG_WARNING("Cannot identify target as a STM32 family.");
1131 return ERROR_FAIL;
1132 }
1133
1134 /* get flash size from target. */
1135 retval = target_read_u16(target, flash_size_reg, &flash_size_in_kb);
1136
1137 /* failed reading flash size or flash size invalid (early silicon),
1138 * default to max target family */
1139 if (retval != ERROR_OK || flash_size_in_kb == 0xffff || flash_size_in_kb == 0) {
1140 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming %" PRIu16 "k flash",
1141 max_flash_size_in_kb);
1142 flash_size_in_kb = max_flash_size_in_kb;
1143 }
1144
1145 /* if the user sets the size manually then ignore the probed value
1146 * this allows us to work around devices that have a invalid flash size register value */
1147 if (stm32x_info->user_bank_size) {
1148 LOG_INFO("ignoring flash probed value, using configured bank size");
1149 flash_size_in_kb = stm32x_info->user_bank_size / 1024;
1150 }
1151
1152 LOG_INFO("flash size = %" PRIu16 " kbytes", flash_size_in_kb);
1153
1154 /* did we assign flash size? */
1155 assert(flash_size_in_kb != 0xffff);
1156
1157 /* F42x/43x/469/479 1024 kiByte devices have a dual bank option */
1158 if ((device_id == 0x419) || (device_id == 0x434)) {
1159 uint32_t optiondata;
1160 retval = target_read_u32(target, STM32_FLASH_OPTCR, &optiondata);
1161 if (retval != ERROR_OK) {
1162 LOG_DEBUG("unable to read option bytes");
1163 return retval;
1164 }
1165 if ((flash_size_in_kb > 1024) || (optiondata & OPTCR_DB1M)) {
1166 stm32x_info->has_large_mem = true;
1167 LOG_INFO("Dual Bank %" PRIu16 " kiB STM32F42x/43x/469/479 found", flash_size_in_kb);
1168 } else {
1169 stm32x_info->has_large_mem = false;
1170 LOG_INFO("Single Bank %" PRIu16 " kiB STM32F42x/43x/469/479 found", flash_size_in_kb);
1171 }
1172 }
1173
1174 /* F76x/77x devices have a dual bank option */
1175 if (device_id == 0x451) {
1176 uint32_t optiondata;
1177 retval = target_read_u32(target, STM32_FLASH_OPTCR, &optiondata);
1178 if (retval != ERROR_OK) {
1179 LOG_DEBUG("unable to read option bytes");
1180 return retval;
1181 }
1182 if (optiondata & OPTCR_NDBANK) {
1183 stm32x_info->has_large_mem = false;
1184 LOG_INFO("Single Bank %" PRIu16 " kiB STM32F76x/77x found", flash_size_in_kb);
1185 } else {
1186 stm32x_info->has_large_mem = true;
1187 max_sector_size_in_kb >>= 1; /* sector size divided by 2 in dual-bank mode */
1188 LOG_INFO("Dual Bank %" PRIu16 " kiB STM32F76x/77x found", flash_size_in_kb);
1189 }
1190 }
1191
1192 /* calculate numbers of pages */
1193 int num_pages = calculate_number_of_sectors(
1194 bank, flash_size_in_kb, max_sector_size_in_kb);
1195
1196 bank->base = base_address;
1197 bank->num_sectors = num_pages;
1198 bank->sectors = calloc(num_pages, sizeof(struct flash_sector));
1199 for (i = 0; i < num_pages; i++) {
1200 bank->sectors[i].is_erased = -1;
1201 bank->sectors[i].is_protected = 0;
1202 }
1203 bank->size = 0;
1204 LOG_DEBUG("allocated %d sectors", num_pages);
1205
1206 /* F76x/77x in dual bank mode */
1207 if ((device_id == 0x451) && stm32x_info->has_large_mem)
1208 num_prot_blocks = num_pages >> 1;
1209
1210 if (num_prot_blocks) {
1211 bank->prot_blocks = malloc(sizeof(struct flash_sector) * num_prot_blocks);
1212 for (i = 0; i < num_prot_blocks; i++)
1213 bank->prot_blocks[i].is_protected = 0;
1214 LOG_DEBUG("allocated %d prot blocks", num_prot_blocks);
1215 }
1216
1217 if (stm32x_info->has_large_mem) {
1218 /* dual-bank */
1219 setup_bank(bank, 0, flash_size_in_kb >> 1, max_sector_size_in_kb);
1220 setup_bank(bank, num_pages >> 1, flash_size_in_kb >> 1,
1221 max_sector_size_in_kb);
1222
1223 /* F767x/F77x in dual mode, one protection bit refers to two adjacent sectors */
1224 if (device_id == 0x451) {
1225 for (i = 0; i < num_prot_blocks; i++) {
1226 bank->prot_blocks[i].offset = bank->sectors[i << 1].offset;
1227 bank->prot_blocks[i].size = bank->sectors[i << 1].size
1228 + bank->sectors[(i << 1) + 1].size;
1229 }
1230 }
1231 } else {
1232 /* single-bank */
1233 setup_bank(bank, 0, flash_size_in_kb, max_sector_size_in_kb);
1234
1235 /* F413/F423, sectors 14 and 15 share one common protection bit */
1236 if (device_id == 0x463) {
1237 for (i = 0; i < num_prot_blocks; i++) {
1238 bank->prot_blocks[i].offset = bank->sectors[i].offset;
1239 bank->prot_blocks[i].size = bank->sectors[i].size;
1240 }
1241 bank->prot_blocks[num_prot_blocks - 1].size <<= 1;
1242 }
1243 }
1244 bank->num_prot_blocks = num_prot_blocks;
1245 assert((bank->size >> 10) == flash_size_in_kb);
1246
1247 stm32x_info->probed = true;
1248 return ERROR_OK;
1249 }
1250
1251 static int stm32x_auto_probe(struct flash_bank *bank)
1252 {
1253 struct stm32x_flash_bank *stm32x_info = bank->driver_priv;
1254 if (stm32x_info->probed)
1255 return ERROR_OK;
1256 return stm32x_probe(bank);
1257 }
1258
1259 static int get_stm32x_info(struct flash_bank *bank, char *buf, int buf_size)
1260 {
1261 uint32_t dbgmcu_idcode;
1262
1263 /* read stm32 device id register */
1264 int retval = stm32x_get_device_id(bank, &dbgmcu_idcode);
1265 if (retval != ERROR_OK)
1266 return retval;
1267
1268 uint16_t device_id = dbgmcu_idcode & 0xfff;
1269 uint16_t rev_id = dbgmcu_idcode >> 16;
1270 const char *device_str;
1271 const char *rev_str = NULL;
1272
1273 switch (device_id) {
1274 case 0x411:
1275 device_str = "STM32F2xx";
1276
1277 switch (rev_id) {
1278 case 0x1000:
1279 rev_str = "A";
1280 break;
1281
1282 case 0x2000:
1283 rev_str = "B";
1284 break;
1285
1286 case 0x1001:
1287 rev_str = "Z";
1288 break;
1289
1290 case 0x2001:
1291 rev_str = "Y";
1292 break;
1293
1294 case 0x2003:
1295 rev_str = "X";
1296 break;
1297
1298 case 0x2007:
1299 rev_str = "1";
1300 break;
1301
1302 case 0x200F:
1303 rev_str = "V";
1304 break;
1305
1306 case 0x201F:
1307 rev_str = "2";
1308 break;
1309 }
1310 break;
1311
1312 case 0x413:
1313 case 0x419:
1314 case 0x434:
1315 device_str = "STM32F4xx";
1316
1317 switch (rev_id) {
1318 case 0x1000:
1319 rev_str = "A";
1320 break;
1321
1322 case 0x1001:
1323 rev_str = "Z";
1324 break;
1325
1326 case 0x1003:
1327 rev_str = "Y";
1328 break;
1329
1330 case 0x1007:
1331 rev_str = "1";
1332 break;
1333
1334 case 0x2001:
1335 rev_str = "3";
1336 break;
1337 }
1338 break;
1339
1340 case 0x421:
1341 device_str = "STM32F446";
1342
1343 switch (rev_id) {
1344 case 0x1000:
1345 rev_str = "A";
1346 break;
1347 }
1348 break;
1349
1350 case 0x423:
1351 case 0x431:
1352 case 0x433:
1353 case 0x458:
1354 case 0x441:
1355 device_str = "STM32F4xx (Low Power)";
1356
1357 switch (rev_id) {
1358 case 0x1000:
1359 rev_str = "A";
1360 break;
1361
1362 case 0x1001:
1363 rev_str = "Z";
1364 break;
1365
1366 case 0x2000:
1367 rev_str = "B";
1368 break;
1369
1370 case 0x3000:
1371 rev_str = "C";
1372 break;
1373 }
1374 break;
1375
1376 case 0x449:
1377 device_str = "STM32F7[4|5]x";
1378
1379 switch (rev_id) {
1380 case 0x1000:
1381 rev_str = "A";
1382 break;
1383
1384 case 0x1001:
1385 rev_str = "Z";
1386 break;
1387 }
1388 break;
1389
1390 case 0x451:
1391 device_str = "STM32F7[6|7]x";
1392
1393 switch (rev_id) {
1394 case 0x1000:
1395 rev_str = "A";
1396 break;
1397 case 0x1001:
1398 rev_str = "Z";
1399 break;
1400 }
1401 break;
1402
1403 case 0x452:
1404 device_str = "STM32F7[2|3]x";
1405
1406 switch (rev_id) {
1407 case 0x1000:
1408 rev_str = "A";
1409 break;
1410 }
1411 break;
1412
1413 case 0x463:
1414 device_str = "STM32F4[1|2]3";
1415
1416 switch (rev_id) {
1417 case 0x1000:
1418 rev_str = "A";
1419 break;
1420 }
1421 break;
1422
1423 default:
1424 snprintf(buf, buf_size, "Cannot identify target as a STM32F2/4/7\n");
1425 return ERROR_FAIL;
1426 }
1427
1428 if (rev_str != NULL)
1429 snprintf(buf, buf_size, "%s - Rev: %s", device_str, rev_str);
1430 else
1431 snprintf(buf, buf_size, "%s - Rev: unknown (0x%04" PRIx16 ")", device_str, rev_id);
1432
1433 return ERROR_OK;
1434 }
1435
1436 COMMAND_HANDLER(stm32x_handle_lock_command)
1437 {
1438 struct target *target = NULL;
1439 struct stm32x_flash_bank *stm32x_info = NULL;
1440
1441 if (CMD_ARGC < 1)
1442 return ERROR_COMMAND_SYNTAX_ERROR;
1443
1444 struct flash_bank *bank;
1445 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
1446 if (ERROR_OK != retval)
1447 return retval;
1448
1449 stm32x_info = bank->driver_priv;
1450 target = bank->target;
1451
1452 if (target->state != TARGET_HALTED) {
1453 LOG_INFO("Target not halted");
1454 /* return ERROR_TARGET_NOT_HALTED; */
1455 }
1456
1457 if (stm32x_read_options(bank) != ERROR_OK) {
1458 command_print(CMD, "%s failed to read options", bank->driver->name);
1459 return ERROR_OK;
1460 }
1461
1462 /* set readout protection */
1463 stm32x_info->option_bytes.RDP = 0;
1464
1465 if (stm32x_write_options(bank) != ERROR_OK) {
1466 command_print(CMD, "%s failed to lock device", bank->driver->name);
1467 return ERROR_OK;
1468 }
1469
1470 command_print(CMD, "%s locked", bank->driver->name);
1471
1472 return ERROR_OK;
1473 }
1474
1475 COMMAND_HANDLER(stm32x_handle_unlock_command)
1476 {
1477 struct target *target = NULL;
1478 struct stm32x_flash_bank *stm32x_info = NULL;
1479
1480 if (CMD_ARGC < 1)
1481 return ERROR_COMMAND_SYNTAX_ERROR;
1482
1483 struct flash_bank *bank;
1484 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
1485 if (ERROR_OK != retval)
1486 return retval;
1487
1488 stm32x_info = bank->driver_priv;
1489 target = bank->target;
1490
1491 if (target->state != TARGET_HALTED) {
1492 LOG_INFO("Target not halted");
1493 /* return ERROR_TARGET_NOT_HALTED; */
1494 }
1495
1496 if (stm32x_read_options(bank) != ERROR_OK) {
1497 command_print(CMD, "%s failed to read options", bank->driver->name);
1498 return ERROR_OK;
1499 }
1500
1501 /* clear readout protection and complementary option bytes
1502 * this will also force a device unlock if set */
1503 stm32x_info->option_bytes.RDP = 0xAA;
1504 if (stm32x_info->has_optcr2_pcrop) {
1505 stm32x_info->option_bytes.optcr2_pcrop = OPTCR2_PCROP_RDP | (~1U << bank->num_sectors);
1506 }
1507
1508 if (stm32x_write_options(bank) != ERROR_OK) {
1509 command_print(CMD, "%s failed to unlock device", bank->driver->name);
1510 return ERROR_OK;
1511 }
1512
1513 command_print(CMD, "%s unlocked.\n"
1514 "INFO: a reset or power cycle is required "
1515 "for the new settings to take effect.", bank->driver->name);
1516
1517 return ERROR_OK;
1518 }
1519
1520 static int stm32x_mass_erase(struct flash_bank *bank)
1521 {
1522 int retval;
1523 uint32_t flash_mer;
1524 struct target *target = bank->target;
1525 struct stm32x_flash_bank *stm32x_info = NULL;
1526
1527 if (target->state != TARGET_HALTED) {
1528 LOG_ERROR("Target not halted");
1529 return ERROR_TARGET_NOT_HALTED;
1530 }
1531
1532 stm32x_info = bank->driver_priv;
1533
1534 retval = stm32x_unlock_reg(target);
1535 if (retval != ERROR_OK)
1536 return retval;
1537
1538 /* mass erase flash memory */
1539 if (stm32x_info->has_large_mem)
1540 flash_mer = FLASH_MER | FLASH_MER1;
1541 else
1542 flash_mer = FLASH_MER;
1543
1544 retval = target_write_u32(target, stm32x_get_flash_reg(bank, STM32_FLASH_CR), flash_mer);
1545 if (retval != ERROR_OK)
1546 return retval;
1547 retval = target_write_u32(target, stm32x_get_flash_reg(bank, STM32_FLASH_CR),
1548 flash_mer | FLASH_STRT);
1549 if (retval != ERROR_OK)
1550 return retval;
1551
1552 retval = stm32x_wait_status_busy(bank, FLASH_MASS_ERASE_TIMEOUT);
1553 if (retval != ERROR_OK)
1554 return retval;
1555
1556 retval = target_write_u32(target, stm32x_get_flash_reg(bank, STM32_FLASH_CR), FLASH_LOCK);
1557 if (retval != ERROR_OK)
1558 return retval;
1559
1560 return ERROR_OK;
1561 }
1562
1563 COMMAND_HANDLER(stm32x_handle_mass_erase_command)
1564 {
1565 if (CMD_ARGC < 1) {
1566 command_print(CMD, "stm32x mass_erase <bank>");
1567 return ERROR_COMMAND_SYNTAX_ERROR;
1568 }
1569
1570 struct flash_bank *bank;
1571 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
1572 if (ERROR_OK != retval)
1573 return retval;
1574
1575 retval = stm32x_mass_erase(bank);
1576 if (retval == ERROR_OK) {
1577 /* set all sectors as erased */
1578 for (unsigned int i = 0; i < bank->num_sectors; i++)
1579 bank->sectors[i].is_erased = 1;
1580
1581 command_print(CMD, "stm32x mass erase complete");
1582 } else {
1583 command_print(CMD, "stm32x mass erase failed");
1584 }
1585
1586 return retval;
1587 }
1588
1589 COMMAND_HANDLER(stm32f2x_handle_options_read_command)
1590 {
1591 int retval;
1592 struct flash_bank *bank;
1593 struct stm32x_flash_bank *stm32x_info = NULL;
1594
1595 if (CMD_ARGC != 1) {
1596 command_print(CMD, "stm32f2x options_read <bank>");
1597 return ERROR_COMMAND_SYNTAX_ERROR;
1598 }
1599
1600 retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
1601 if (ERROR_OK != retval)
1602 return retval;
1603
1604 retval = stm32x_read_options(bank);
1605 if (ERROR_OK != retval)
1606 return retval;
1607
1608 stm32x_info = bank->driver_priv;
1609 if (stm32x_info->has_extra_options) {
1610 if (stm32x_info->has_boot_addr) {
1611 uint32_t boot_addr = stm32x_info->option_bytes.boot_addr;
1612
1613 command_print(CMD, "stm32f2x user_options 0x%03" PRIX16 ","
1614 " boot_add0 0x%04" PRIX32 ", boot_add1 0x%04" PRIX32,
1615 stm32x_info->option_bytes.user_options,
1616 boot_addr & 0xffff, (boot_addr & 0xffff0000) >> 16);
1617 if (stm32x_info->has_optcr2_pcrop) {
1618 command_print(CMD, "stm32f2x optcr2_pcrop 0x%08" PRIX32,
1619 stm32x_info->option_bytes.optcr2_pcrop);
1620 }
1621 } else {
1622 command_print(CMD, "stm32f2x user_options 0x%03" PRIX16,
1623 stm32x_info->option_bytes.user_options);
1624 }
1625 } else {
1626 command_print(CMD, "stm32f2x user_options 0x%02" PRIX16,
1627 stm32x_info->option_bytes.user_options);
1628
1629 }
1630
1631 return retval;
1632 }
1633
1634 COMMAND_HANDLER(stm32f2x_handle_options_write_command)
1635 {
1636 int retval;
1637 struct flash_bank *bank;
1638 struct stm32x_flash_bank *stm32x_info = NULL;
1639 uint16_t user_options, boot_addr0, boot_addr1, options_mask;
1640
1641 if (CMD_ARGC < 1) {
1642 command_print(CMD, "stm32f2x options_write <bank> ...");
1643 return ERROR_COMMAND_SYNTAX_ERROR;
1644 }
1645
1646 retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
1647 if (ERROR_OK != retval)
1648 return retval;
1649
1650 retval = stm32x_read_options(bank);
1651 if (ERROR_OK != retval)
1652 return retval;
1653
1654 stm32x_info = bank->driver_priv;
1655 if (stm32x_info->has_boot_addr) {
1656 if (CMD_ARGC != 4) {
1657 command_print(CMD, "stm32f2x options_write <bank> <user_options>"
1658 " <boot_addr0> <boot_addr1>");
1659 return ERROR_COMMAND_SYNTAX_ERROR;
1660 }
1661 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[2], boot_addr0);
1662 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[3], boot_addr1);
1663 stm32x_info->option_bytes.boot_addr = boot_addr0 | (((uint32_t) boot_addr1) << 16);
1664 } else {
1665 if (CMD_ARGC != 2) {
1666 command_print(CMD, "stm32f2x options_write <bank> <user_options>");
1667 return ERROR_COMMAND_SYNTAX_ERROR;
1668 }
1669 }
1670
1671 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[1], user_options);
1672 options_mask = !stm32x_info->has_extra_options ? ~0xfc :
1673 ~(((0xf00 << (stm32x_info->protection_bits - 12)) | 0xff) & 0xffc);
1674 if (user_options & options_mask) {
1675 command_print(CMD, "stm32f2x invalid user_options");
1676 return ERROR_COMMAND_ARGUMENT_INVALID;
1677 }
1678
1679 stm32x_info->option_bytes.user_options = user_options;
1680
1681 if (stm32x_write_options(bank) != ERROR_OK) {
1682 command_print(CMD, "stm32f2x failed to write options");
1683 return ERROR_OK;
1684 }
1685
1686 /* switching between single- and dual-bank modes requires re-probe */
1687 /* ... and reprogramming of whole flash */
1688 stm32x_info->probed = false;
1689
1690 command_print(CMD, "stm32f2x write options complete.\n"
1691 "INFO: a reset or power cycle is required "
1692 "for the new settings to take effect.");
1693 return retval;
1694 }
1695
1696 COMMAND_HANDLER(stm32f2x_handle_optcr2_write_command)
1697 {
1698 int retval;
1699 struct flash_bank *bank;
1700 struct stm32x_flash_bank *stm32x_info = NULL;
1701 uint32_t optcr2_pcrop;
1702
1703 if (CMD_ARGC != 2) {
1704 command_print(CMD, "stm32f2x optcr2_write <bank> <optcr2_value>");
1705 return ERROR_COMMAND_SYNTAX_ERROR;
1706 }
1707
1708 retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
1709 if (ERROR_OK != retval)
1710 return retval;
1711
1712 stm32x_info = bank->driver_priv;
1713 if (!stm32x_info->has_optcr2_pcrop) {
1714 command_print(CMD, "no optcr2 register");
1715 return ERROR_COMMAND_ARGUMENT_INVALID;
1716 }
1717
1718 command_print(CMD, "INFO: To disable PCROP, set PCROP_RDP"
1719 " with PCROPi bits STILL SET, then\nlock device and"
1720 " finally unlock it. Clears PCROP and mass erases flash.");
1721
1722 retval = stm32x_read_options(bank);
1723 if (ERROR_OK != retval)
1724 return retval;
1725
1726 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], optcr2_pcrop);
1727 stm32x_info->option_bytes.optcr2_pcrop = optcr2_pcrop;
1728
1729 if (stm32x_write_options(bank) != ERROR_OK) {
1730 command_print(CMD, "stm32f2x failed to write options");
1731 return ERROR_OK;
1732 }
1733
1734 command_print(CMD, "stm32f2x optcr2_write complete.");
1735 return retval;
1736 }
1737
1738 COMMAND_HANDLER(stm32x_handle_otp_command)
1739 {
1740 if (CMD_ARGC < 2) {
1741 command_print(CMD, "stm32x otp <bank> (enable|disable|show)");
1742 return ERROR_COMMAND_SYNTAX_ERROR;
1743 }
1744
1745 struct flash_bank *bank;
1746 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
1747 if (ERROR_OK != retval)
1748 return retval;
1749 if (stm32x_is_otp(bank)) {
1750 if (strcmp(CMD_ARGV[1], "enable") == 0) {
1751 stm32x_otp_enable(bank);
1752 } else if (strcmp(CMD_ARGV[1], "disable") == 0) {
1753 stm32x_otp_disable(bank);
1754 } else if (strcmp(CMD_ARGV[1], "show") == 0) {
1755 command_print(CMD,
1756 "OTP memory bank #%u is %s for write commands.",
1757 bank->bank_number,
1758 stm32x_is_otp_unlocked(bank) ? "enabled" : "disabled");
1759 } else {
1760 return ERROR_COMMAND_SYNTAX_ERROR;
1761 }
1762 } else {
1763 command_print(CMD, "Failed: not an OTP bank.");
1764 }
1765
1766 return retval;
1767 }
1768
1769 static const struct command_registration stm32x_exec_command_handlers[] = {
1770 {
1771 .name = "lock",
1772 .handler = stm32x_handle_lock_command,
1773 .mode = COMMAND_EXEC,
1774 .usage = "bank_id",
1775 .help = "Lock entire flash device.",
1776 },
1777 {
1778 .name = "unlock",
1779 .handler = stm32x_handle_unlock_command,
1780 .mode = COMMAND_EXEC,
1781 .usage = "bank_id",
1782 .help = "Unlock entire protected flash device.",
1783 },
1784 {
1785 .name = "mass_erase",
1786 .handler = stm32x_handle_mass_erase_command,
1787 .mode = COMMAND_EXEC,
1788 .usage = "bank_id",
1789 .help = "Erase entire flash device.",
1790 },
1791 {
1792 .name = "options_read",
1793 .handler = stm32f2x_handle_options_read_command,
1794 .mode = COMMAND_EXEC,
1795 .usage = "bank_id",
1796 .help = "Read and display device option bytes.",
1797 },
1798 {
1799 .name = "options_write",
1800 .handler = stm32f2x_handle_options_write_command,
1801 .mode = COMMAND_EXEC,
1802 .usage = "bank_id user_options [ boot_add0 boot_add1 ]",
1803 .help = "Write option bytes",
1804 },
1805 {
1806 .name = "optcr2_write",
1807 .handler = stm32f2x_handle_optcr2_write_command,
1808 .mode = COMMAND_EXEC,
1809 .usage = "bank_id optcr2",
1810 .help = "Write optcr2 word",
1811 },
1812 {
1813 .name = "otp",
1814 .handler = stm32x_handle_otp_command,
1815 .mode = COMMAND_EXEC,
1816 .usage = "bank_id",
1817 .help = "OTP (One Time Programmable) memory write enable/disable.",
1818 },
1819 COMMAND_REGISTRATION_DONE
1820 };
1821
1822 static const struct command_registration stm32x_command_handlers[] = {
1823 {
1824 .name = "stm32f2x",
1825 .mode = COMMAND_ANY,
1826 .help = "stm32f2x flash command group",
1827 .usage = "",
1828 .chain = stm32x_exec_command_handlers,
1829 },
1830 COMMAND_REGISTRATION_DONE
1831 };
1832
1833 const struct flash_driver stm32f2x_flash = {
1834 .name = "stm32f2x",
1835 .commands = stm32x_command_handlers,
1836 .flash_bank_command = stm32x_flash_bank_command,
1837 .erase = stm32x_erase,
1838 .protect = stm32x_protect,
1839 .write = stm32x_write,
1840 .read = default_flash_read,
1841 .probe = stm32x_probe,
1842 .auto_probe = stm32x_auto_probe,
1843 .erase_check = default_flash_blank_check,
1844 .protect_check = stm32x_protect_check,
1845 .info = get_stm32x_info,
1846 .free_driver_priv = default_flash_free_driver_priv,
1847 };
Open On-Chip Debugger

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)