3863144029959d4c9461189a34dd90ec9871c71c
[openocd.git] / src / flash / nor / stm32lx.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 by Clement Burin des Roziers *
9 * clement.burin-des-roziers@hikob.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, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
26
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #include "imp.h"
32 #include <helper/binarybuffer.h>
33 #include <target/algorithm.h>
34 #include <target/armv7m.h>
35
36 /* stm32lx flash register locations */
37
38 #define FLASH_BASE 0x40023C00
39 #define FLASH_ACR 0x40023C00
40 #define FLASH_PECR 0x40023C04
41 #define FLASH_PDKEYR 0x40023C08
42 #define FLASH_PEKEYR 0x40023C0C
43 #define FLASH_PRGKEYR 0x40023C10
44 #define FLASH_OPTKEYR 0x40023C14
45 #define FLASH_SR 0x40023C18
46 #define FLASH_OBR 0x40023C1C
47 #define FLASH_WRPR 0x40023C20
48
49 /* FLASH_ACR bites */
50 #define FLASH_ACR__LATENCY (1<<0)
51 #define FLASH_ACR__PRFTEN (1<<1)
52 #define FLASH_ACR__ACC64 (1<<2)
53 #define FLASH_ACR__SLEEP_PD (1<<3)
54 #define FLASH_ACR__RUN_PD (1<<4)
55
56 /* FLASH_PECR bits */
57 #define FLASH_PECR__PELOCK (1<<0)
58 #define FLASH_PECR__PRGLOCK (1<<1)
59 #define FLASH_PECR__OPTLOCK (1<<2)
60 #define FLASH_PECR__PROG (1<<3)
61 #define FLASH_PECR__DATA (1<<4)
62 #define FLASH_PECR__FTDW (1<<8)
63 #define FLASH_PECR__ERASE (1<<9)
64 #define FLASH_PECR__FPRG (1<<10)
65 #define FLASH_PECR__EOPIE (1<<16)
66 #define FLASH_PECR__ERRIE (1<<17)
67 #define FLASH_PECR__OBL_LAUNCH (1<<18)
68
69 /* FLASH_SR bits */
70 #define FLASH_SR__BSY (1<<0)
71 #define FLASH_SR__EOP (1<<1)
72 #define FLASH_SR__ENDHV (1<<2)
73 #define FLASH_SR__READY (1<<3)
74 #define FLASH_SR__WRPERR (1<<8)
75 #define FLASH_SR__PGAERR (1<<9)
76 #define FLASH_SR__SIZERR (1<<10)
77 #define FLASH_SR__OPTVERR (1<<11)
78
79 /* Unlock keys */
80 #define PEKEY1 0x89ABCDEF
81 #define PEKEY2 0x02030405
82 #define PRGKEY1 0x8C9DAEBF
83 #define PRGKEY2 0x13141516
84 #define OPTKEY1 0xFBEAD9C8
85 #define OPTKEY2 0x24252627
86
87 /* other registers */
88 #define DBGMCU_IDCODE 0xE0042000
89 #define F_SIZE 0x1FF8004C
90
91 /* Constants */
92 #define FLASH_PAGE_SIZE 256
93 #define FLASH_SECTOR_SIZE 4096
94 #define FLASH_PAGES_PER_SECTOR 16
95 #define FLASH_BANK0_ADDRESS 0x08000000
96
97 /* stm32lx option byte register location */
98 #define OB_RDP 0x1FF80000
99 #define OB_USER 0x1FF80004
100 #define OB_WRP0_1 0x1FF80008
101 #define OB_WRP2_3 0x1FF8000C
102
103 /* OB_RDP values */
104 #define OB_RDP__LEVEL0 0xFF5500AA
105 #define OB_RDP__LEVEL1 0xFFFF0000
106
107 /* stm32lx RCC register locations */
108 #define RCC_CR 0x40023800
109 #define RCC_ICSCR 0x40023804
110 #define RCC_CFGR 0x40023808
111
112 /* RCC_ICSCR bits */
113 #define RCC_ICSCR__MSIRANGE_MASK (7<<13)
114
115 static int stm32lx_unlock_program_memory(struct flash_bank *bank);
116 static int stm32lx_lock_program_memory(struct flash_bank *bank);
117 static int stm32lx_enable_write_half_page(struct flash_bank *bank);
118 static int stm32lx_erase_sector(struct flash_bank *bank, int sector);
119 static int stm32lx_wait_until_bsy_clear(struct flash_bank *bank);
120
121 struct stm32lx_flash_bank {
122 struct working_area *write_algorithm;
123 int probed;
124 };
125
126 /* flash bank stm32lx <base> <size> 0 0 <target#>
127 */
128 FLASH_BANK_COMMAND_HANDLER(stm32lx_flash_bank_command)
129 {
130 struct stm32lx_flash_bank *stm32lx_info;
131 if (CMD_ARGC < 6)
132 return ERROR_COMMAND_SYNTAX_ERROR;
133
134 /* Create the bank structure */
135 stm32lx_info = malloc(sizeof(struct stm32lx_flash_bank));
136
137 /* Check allocation */
138 if (stm32lx_info == NULL) {
139 LOG_ERROR("failed to allocate bank structure");
140 return ERROR_FAIL;
141 }
142
143 bank->driver_priv = stm32lx_info;
144
145 stm32lx_info->write_algorithm = NULL;
146 stm32lx_info->probed = 0;
147
148 return ERROR_OK;
149 }
150
151 static int stm32lx_protect_check(struct flash_bank *bank)
152 {
153 int retval;
154 struct target *target = bank->target;
155
156 uint32_t wrpr;
157
158 if (target->state != TARGET_HALTED) {
159 LOG_ERROR("Target not halted");
160 return ERROR_TARGET_NOT_HALTED;
161 }
162
163 /*
164 * Read the WRPR word, and check each bit (corresponding to each
165 * flash sector
166 */
167 retval = target_read_u32(target, FLASH_WRPR, &wrpr);
168 if (retval != ERROR_OK)
169 return retval;
170
171 for (int i = 0; i < 32; i++) {
172 if (wrpr & (1 << i))
173 bank->sectors[i].is_protected = 1;
174 else
175 bank->sectors[i].is_protected = 0;
176 }
177 return ERROR_OK;
178 }
179
180 static int stm32lx_erase(struct flash_bank *bank, int first, int last)
181 {
182 int retval;
183
184 /*
185 * It could be possible to do a mass erase if all sectors must be
186 * erased, but it is not implemented yet.
187 */
188
189 if (bank->target->state != TARGET_HALTED) {
190 LOG_ERROR("Target not halted");
191 return ERROR_TARGET_NOT_HALTED;
192 }
193
194 /*
195 * Loop over the selected sectors and erase them
196 */
197 for (int i = first; i <= last; i++) {
198 retval = stm32lx_erase_sector(bank, i);
199 if (retval != ERROR_OK)
200 return retval;
201 bank->sectors[i].is_erased = 1;
202 }
203 return ERROR_OK;
204 }
205
206 static int stm32lx_protect(struct flash_bank *bank, int set, int first,
207 int last)
208 {
209 LOG_WARNING("protection of the STM32L flash is not implemented");
210 return ERROR_OK;
211 }
212
213 static int stm32lx_write_half_pages(struct flash_bank *bank, uint8_t *buffer,
214 uint32_t offset, uint32_t count)
215 {
216 struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv;
217 struct target *target = bank->target;
218 uint32_t buffer_size = 4096 * 4;
219 struct working_area *source;
220 uint32_t address = bank->base + offset;
221
222 struct reg_param reg_params[5];
223 struct armv7m_algorithm armv7m_info;
224
225 int retval = ERROR_OK;
226 uint32_t reg32;
227
228 /* see contib/loaders/flash/stm32lx.s for src */
229
230 static const uint16_t stm32lx_flash_write_code_16[] = {
231 /* 00000000 <write_word-0x4>: */
232 0x2300, /* 0: 2300 movs r3, #0 */
233 0xe004, /* 2: e004 b.n e <test_done> */
234
235 /* 00000004 <write_word>: */
236 0xf851, 0xcb04, /* 4: f851 cb04 ldr.w ip, [r1], #4 */
237 0xf840, 0xcb04, /* 8: f840 cb04 str.w ip, [r0], #4 */
238 0x3301, /* c: 3301 adds r3, #1 */
239
240 /* 0000000e <test_done>: */
241 0x4293, /* e: 4293 cmp r3, r2 */
242 0xd3f8, /* 10: d3f8 bcc.n 4 <write_word> */
243 0xbe00, /* 12: be00 bkpt 0x0000 */
244
245 };
246
247 /* Flip endian */
248 uint8_t stm32lx_flash_write_code[sizeof(stm32lx_flash_write_code_16)];
249 for (unsigned int i = 0; i < sizeof(stm32lx_flash_write_code_16) / 2; i++) {
250 stm32lx_flash_write_code[i * 2 + 0] = stm32lx_flash_write_code_16[i]
251 & 0xff;
252 stm32lx_flash_write_code[i * 2 + 1] = (stm32lx_flash_write_code_16[i]
253 >> 8) & 0xff;
254 }
255 /* Check if there is an even number of half pages (128bytes) */
256 if (count % 128) {
257 LOG_ERROR("there should be an even number "
258 "of half pages = 128 bytes (count = %" PRIi32 " bytes)", count);
259 return ERROR_FAIL;
260 }
261
262 /* Allocate working area */
263 reg32 = sizeof(stm32lx_flash_write_code);
264 /* Add bytes to make 4byte aligned */
265 reg32 += (4 - (reg32 % 4)) % 4;
266 retval = target_alloc_working_area(target, reg32,
267 &stm32lx_info->write_algorithm);
268 if (retval != ERROR_OK)
269 return retval;
270
271 /* Write the flashing code */
272 retval = target_write_buffer(target,
273 stm32lx_info->write_algorithm->address,
274 sizeof(stm32lx_flash_write_code),
275 (uint8_t *)stm32lx_flash_write_code);
276 if (retval != ERROR_OK) {
277 target_free_working_area(target, stm32lx_info->write_algorithm);
278 return retval;
279 }
280
281 /* Allocate half pages memory */
282 while (target_alloc_working_area_try(target, buffer_size, &source)
283 != ERROR_OK) {
284 if (buffer_size > 1024)
285 buffer_size -= 1024;
286 else
287 buffer_size /= 2;
288
289 if (buffer_size <= 256) {
290 /* if we already allocated the writing code, but failed to get a
291 * buffer, free the algorithm */
292 if (stm32lx_info->write_algorithm)
293 target_free_working_area(target, stm32lx_info->write_algorithm);
294
295 LOG_WARNING("no large enough working area available, can't do block memory writes");
296 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
297 }
298 }
299 LOG_DEBUG("allocated working area for data (%" PRIx32 " bytes)", buffer_size);
300
301 armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
302 armv7m_info.core_mode = ARMV7M_MODE_ANY;
303 init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
304 init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
305 init_reg_param(&reg_params[2], "r2", 32, PARAM_OUT);
306 init_reg_param(&reg_params[3], "r3", 32, PARAM_IN_OUT);
307 init_reg_param(&reg_params[4], "r4", 32, PARAM_OUT);
308
309 /* Enable half-page write */
310 retval = stm32lx_enable_write_half_page(bank);
311 if (retval != ERROR_OK) {
312 target_free_working_area(target, source);
313 target_free_working_area(target, stm32lx_info->write_algorithm);
314
315 destroy_reg_param(&reg_params[0]);
316 destroy_reg_param(&reg_params[1]);
317 destroy_reg_param(&reg_params[2]);
318 destroy_reg_param(&reg_params[3]);
319 return retval;
320 }
321
322 /* Loop while there are bytes to write */
323 while (count > 0) {
324 uint32_t this_count;
325 this_count = (count > buffer_size) ? buffer_size : count;
326
327 /* Write the next half pages */
328 retval = target_write_buffer(target, source->address, this_count,
329 buffer);
330 if (retval != ERROR_OK)
331 break;
332
333 /* 4: Store useful information in the registers */
334 /* the destination address of the copy (R0) */
335 buf_set_u32(reg_params[0].value, 0, 32, address);
336 /* The source address of the copy (R1) */
337 buf_set_u32(reg_params[1].value, 0, 32, source->address);
338 /* The length of the copy (R2) */
339 buf_set_u32(reg_params[2].value, 0, 32, this_count / 4);
340
341 /* 5: Execute the bunch of code */
342 retval = target_run_algorithm(target, 0, NULL, sizeof(reg_params)
343 / sizeof(*reg_params), reg_params,
344 stm32lx_info->write_algorithm->address, 0, 20000, &armv7m_info);
345 if (retval != ERROR_OK)
346 break;
347
348 /* 6: Wait while busy */
349 retval = stm32lx_wait_until_bsy_clear(bank);
350 if (retval != ERROR_OK)
351 break;
352
353 buffer += this_count;
354 address += this_count;
355 count -= this_count;
356 }
357
358 if (retval == ERROR_OK)
359 retval = stm32lx_lock_program_memory(bank);
360
361 target_free_working_area(target, source);
362 target_free_working_area(target, stm32lx_info->write_algorithm);
363
364 destroy_reg_param(&reg_params[0]);
365 destroy_reg_param(&reg_params[1]);
366 destroy_reg_param(&reg_params[2]);
367 destroy_reg_param(&reg_params[3]);
368
369 return retval;
370 }
371 static int stm32lx_write(struct flash_bank *bank, uint8_t *buffer,
372 uint32_t offset, uint32_t count)
373 {
374 struct target *target = bank->target;
375
376 uint32_t halfpages_number;
377 uint32_t words_remaining;
378 uint32_t bytes_remaining;
379 uint32_t address = bank->base + offset;
380 uint32_t bytes_written = 0;
381 int retval;
382
383 if (bank->target->state != TARGET_HALTED) {
384 LOG_ERROR("Target not halted");
385 return ERROR_TARGET_NOT_HALTED;
386 }
387
388 if (offset & 0x1) {
389 LOG_ERROR("offset 0x%" PRIx32 " breaks required 2-byte alignment", offset);
390 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
391 }
392
393 /* Check if there are some full half pages */
394 if (((offset % 128) == 0) && (count >= 128)) {
395 halfpages_number = count / 128;
396 words_remaining = (count - 128 * halfpages_number) / 4;
397 bytes_remaining = (count & 0x3);
398 } else {
399 halfpages_number = 0;
400 words_remaining = (count / 4);
401 bytes_remaining = (count & 0x3);
402 }
403
404 if (halfpages_number) {
405 retval = stm32lx_write_half_pages(bank, buffer, offset, 128
406 * halfpages_number);
407 if (retval != ERROR_OK)
408 return ERROR_FAIL;
409 }
410
411 bytes_written = 128 * halfpages_number;
412 address += bytes_written;
413
414 retval = stm32lx_unlock_program_memory(bank);
415 if (retval != ERROR_OK)
416 return retval;
417
418 while (words_remaining > 0) {
419 uint32_t value;
420 uint8_t *p = buffer + bytes_written;
421
422 /* Prepare the word, Little endian conversion */
423 value = p[0] + (p[1] << 8) + (p[2] << 16) + (p[3] << 24);
424
425 retval = target_write_u32(target, address, value);
426 if (retval != ERROR_OK)
427 return retval;
428
429 bytes_written += 4;
430 words_remaining--;
431 address += 4;
432
433 retval = stm32lx_wait_until_bsy_clear(bank);
434 if (retval != ERROR_OK)
435 return retval;
436 }
437
438 if (bytes_remaining) {
439 uint8_t last_word[4] = {0xff, 0xff, 0xff, 0xff};
440
441 /* copy the last remaining bytes into the write buffer */
442 memcpy(last_word, buffer+bytes_written, bytes_remaining);
443
444 retval = target_write_buffer(target, address, 4, last_word);
445 if (retval != ERROR_OK)
446 return retval;
447
448 retval = stm32lx_wait_until_bsy_clear(bank);
449 if (retval != ERROR_OK)
450 return retval;
451 }
452
453 retval = stm32lx_lock_program_memory(bank);
454 if (retval != ERROR_OK)
455 return retval;
456
457 return ERROR_OK;
458 }
459
460 static int stm32lx_probe(struct flash_bank *bank)
461 {
462 struct target *target = bank->target;
463 struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv;
464 int i;
465 uint16_t flash_size_in_kb;
466 uint32_t device_id;
467
468 stm32lx_info->probed = 0;
469
470 /* read stm32 device id register */
471 int retval = target_read_u32(target, DBGMCU_IDCODE, &device_id);
472 if (retval != ERROR_OK)
473 return retval;
474
475 LOG_DEBUG("device id = 0x%08" PRIx32 "", device_id);
476
477 /* get flash size from target. */
478 retval = target_read_u16(target, F_SIZE, &flash_size_in_kb);
479 if (retval != ERROR_OK) {
480 LOG_WARNING("failed reading flash size, default to max target family");
481 /* failed reading flash size, default to max target family */
482 flash_size_in_kb = 0xffff;
483 }
484
485 if ((device_id & 0xfff) == 0x416) {
486 /* check for early silicon */
487 if (flash_size_in_kb == 0xffff) {
488 /* number of sectors may be incorrrect on early silicon */
489 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 128k flash");
490 flash_size_in_kb = 128;
491 }
492 } else if ((device_id & 0xfff) == 0x436) {
493 /* check for early silicon */
494 if (flash_size_in_kb == 0xffff) {
495 /* number of sectors may be incorrrect on early silicon */
496 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 384k flash");
497 flash_size_in_kb = 384;
498 }
499 } else {
500 LOG_WARNING("Cannot identify target as a STM32L family.");
501 return ERROR_FAIL;
502 }
503
504 /* STM32L - we have 32 sectors, 16 pages per sector -> 512 pages
505 * 16 pages for a protection area */
506
507 /* calculate numbers of sectors (4kB per sector) */
508 int num_sectors = (flash_size_in_kb * 1024) / FLASH_SECTOR_SIZE;
509 LOG_INFO("flash size = %dkbytes", flash_size_in_kb);
510
511 if (bank->sectors) {
512 free(bank->sectors);
513 bank->sectors = NULL;
514 }
515
516 bank->base = FLASH_BANK0_ADDRESS;
517 bank->size = flash_size_in_kb * 1024;
518 bank->num_sectors = num_sectors;
519 bank->sectors = malloc(sizeof(struct flash_sector) * num_sectors);
520 if (bank->sectors == NULL) {
521 LOG_ERROR("failed to allocate bank sectors");
522 return ERROR_FAIL;
523 }
524
525 for (i = 0; i < num_sectors; i++) {
526 bank->sectors[i].offset = i * FLASH_SECTOR_SIZE;
527 bank->sectors[i].size = FLASH_SECTOR_SIZE;
528 bank->sectors[i].is_erased = -1;
529 bank->sectors[i].is_protected = 1;
530 }
531
532 stm32lx_info->probed = 1;
533
534 return ERROR_OK;
535 }
536
537 static int stm32lx_auto_probe(struct flash_bank *bank)
538 {
539 struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv;
540
541 if (stm32lx_info->probed)
542 return ERROR_OK;
543
544 return stm32lx_probe(bank);
545 }
546
547 static int stm32lx_erase_check(struct flash_bank *bank)
548 {
549 struct target *target = bank->target;
550 const int buffer_size = 4096;
551 int i;
552 uint32_t nBytes;
553 int retval = ERROR_OK;
554
555 if (bank->target->state != TARGET_HALTED) {
556 LOG_ERROR("Target not halted");
557 return ERROR_TARGET_NOT_HALTED;
558 }
559
560 uint8_t *buffer = malloc(buffer_size);
561 if (buffer == NULL) {
562 LOG_ERROR("failed to allocate read buffer");
563 return ERROR_FAIL;
564 }
565
566 for (i = 0; i < bank->num_sectors; i++) {
567 uint32_t j;
568 bank->sectors[i].is_erased = 1;
569
570 /* Loop chunk by chunk over the sector */
571 for (j = 0; j < bank->sectors[i].size; j += buffer_size) {
572 uint32_t chunk;
573 chunk = buffer_size;
574 if (chunk > (j - bank->sectors[i].size))
575 chunk = (j - bank->sectors[i].size);
576
577 retval = target_read_memory(target, bank->base
578 + bank->sectors[i].offset + j, 4, chunk / 4, buffer);
579 if (retval != ERROR_OK)
580 break;
581
582 for (nBytes = 0; nBytes < chunk; nBytes++) {
583 if (buffer[nBytes] != 0x00) {
584 bank->sectors[i].is_erased = 0;
585 break;
586 }
587 }
588 }
589 if (retval != ERROR_OK)
590 break;
591 }
592 free(buffer);
593
594 return retval;
595 }
596
597 static int stm32lx_get_info(struct flash_bank *bank, char *buf, int buf_size)
598 {
599 /* This method must return a string displaying information about the bank */
600
601 struct target *target = bank->target;
602 uint32_t device_id;
603 int printed;
604
605 /* read stm32 device id register */
606 int retval = target_read_u32(target, DBGMCU_IDCODE, &device_id);
607 if (retval != ERROR_OK)
608 return retval;
609
610 if ((device_id & 0xfff) == 0x416) {
611 printed = snprintf(buf, buf_size, "stm32lx - Rev: ");
612 buf += printed;
613 buf_size -= printed;
614
615 switch (device_id >> 16) {
616 case 0x1000:
617 snprintf(buf, buf_size, "A");
618 break;
619
620 case 0x1008:
621 snprintf(buf, buf_size, "Y");
622 break;
623
624 case 0x1018:
625 snprintf(buf, buf_size, "X");
626 break;
627
628 case 0x1038:
629 snprintf(buf, buf_size, "W");
630 break;
631
632 case 0x1078:
633 snprintf(buf, buf_size, "V");
634 break;
635
636 default:
637 snprintf(buf, buf_size, "unknown");
638 break;
639 }
640 } else if ((device_id & 0xfff) == 0x436) {
641 printed = snprintf(buf, buf_size, "stm32lx (HD) - Rev: ");
642 buf += printed;
643 buf_size -= printed;
644
645 switch (device_id >> 16) {
646 case 0x1000:
647 snprintf(buf, buf_size, "A");
648 break;
649
650 case 0x1008:
651 snprintf(buf, buf_size, "Z");
652 break;
653
654 default:
655 snprintf(buf, buf_size, "unknown");
656 break;
657 }
658 } else {
659 snprintf(buf, buf_size, "Cannot identify target as a stm32lx");
660 return ERROR_FAIL;
661 }
662
663 return ERROR_OK;
664 }
665
666 static const struct command_registration stm32lx_exec_command_handlers[] = {
667 COMMAND_REGISTRATION_DONE
668 };
669
670 static const struct command_registration stm32lx_command_handlers[] = {
671 {
672 .name = "stm32lx",
673 .mode = COMMAND_ANY,
674 .help = "stm32lx flash command group",
675 .usage = "",
676 .chain = stm32lx_exec_command_handlers,
677 },
678 COMMAND_REGISTRATION_DONE
679 };
680
681 struct flash_driver stm32lx_flash = {
682 .name = "stm32lx",
683 .commands = stm32lx_command_handlers,
684 .flash_bank_command = stm32lx_flash_bank_command,
685 .erase = stm32lx_erase,
686 .protect = stm32lx_protect,
687 .write = stm32lx_write,
688 .read = default_flash_read,
689 .probe = stm32lx_probe,
690 .auto_probe = stm32lx_auto_probe,
691 .erase_check = stm32lx_erase_check,
692 .protect_check = stm32lx_protect_check,
693 .info = stm32lx_get_info,
694 };
695
696 /* Static methods implementation */
697 static int stm32lx_unlock_program_memory(struct flash_bank *bank)
698 {
699 struct target *target = bank->target;
700 int retval;
701 uint32_t reg32;
702
703 /*
704 * Unlocking the program memory is done by unlocking the PECR,
705 * then by writing the 2 PRGKEY to the PRGKEYR register
706 */
707
708 /* To unlock the PECR write the 2 PEKEY to the PEKEYR register */
709 retval = target_write_u32(target, FLASH_PEKEYR, PEKEY1);
710 if (retval != ERROR_OK)
711 return retval;
712
713 retval = target_write_u32(target, FLASH_PEKEYR, PEKEY2);
714 if (retval != ERROR_OK)
715 return retval;
716
717 /* Make sure it worked */
718 retval = target_read_u32(target, FLASH_PECR, &reg32);
719 if (retval != ERROR_OK)
720 return retval;
721
722 if (reg32 & FLASH_PECR__PELOCK) {
723 LOG_ERROR("PELOCK is not cleared :(");
724 return ERROR_FLASH_OPERATION_FAILED;
725 }
726
727 retval = target_write_u32(target, FLASH_PRGKEYR, PRGKEY1);
728 if (retval != ERROR_OK)
729 return retval;
730 retval = target_write_u32(target, FLASH_PRGKEYR, PRGKEY2);
731 if (retval != ERROR_OK)
732 return retval;
733
734 /* Make sure it worked */
735 retval = target_read_u32(target, FLASH_PECR, &reg32);
736 if (retval != ERROR_OK)
737 return retval;
738
739 if (reg32 & FLASH_PECR__PRGLOCK) {
740 LOG_ERROR("PRGLOCK is not cleared :(");
741 return ERROR_FLASH_OPERATION_FAILED;
742 }
743 return ERROR_OK;
744 }
745
746 static int stm32lx_enable_write_half_page(struct flash_bank *bank)
747 {
748 struct target *target = bank->target;
749 int retval;
750 uint32_t reg32;
751
752 /**
753 * Unlock the program memory, then set the FPRG bit in the PECR register.
754 */
755 retval = stm32lx_unlock_program_memory(bank);
756 if (retval != ERROR_OK)
757 return retval;
758
759 retval = target_read_u32(target, FLASH_PECR, &reg32);
760 if (retval != ERROR_OK)
761 return retval;
762
763 reg32 |= FLASH_PECR__FPRG;
764 retval = target_write_u32(target, FLASH_PECR, reg32);
765 if (retval != ERROR_OK)
766 return retval;
767
768 retval = target_read_u32(target, FLASH_PECR, &reg32);
769 if (retval != ERROR_OK)
770 return retval;
771
772 reg32 |= FLASH_PECR__PROG;
773 retval = target_write_u32(target, FLASH_PECR, reg32);
774
775 return retval;
776 }
777
778 static int stm32lx_lock_program_memory(struct flash_bank *bank)
779 {
780 struct target *target = bank->target;
781 int retval;
782 uint32_t reg32;
783
784 /* To lock the program memory, simply set the lock bit and lock PECR */
785
786 retval = target_read_u32(target, FLASH_PECR, &reg32);
787 if (retval != ERROR_OK)
788 return retval;
789
790 reg32 |= FLASH_PECR__PRGLOCK;
791 retval = target_write_u32(target, FLASH_PECR, reg32);
792 if (retval != ERROR_OK)
793 return retval;
794
795 retval = target_read_u32(target, FLASH_PECR, &reg32);
796 if (retval != ERROR_OK)
797 return retval;
798
799 reg32 |= FLASH_PECR__PELOCK;
800 retval = target_write_u32(target, FLASH_PECR, reg32);
801 if (retval != ERROR_OK)
802 return retval;
803
804 return ERROR_OK;
805 }
806
807 static int stm32lx_erase_sector(struct flash_bank *bank, int sector)
808 {
809 struct target *target = bank->target;
810 int retval;
811 uint32_t reg32;
812
813 /*
814 * To erase a sector (i.e. FLASH_PAGES_PER_SECTOR pages),
815 * first unlock the memory, loop over the pages of this sector
816 * and write 0x0 to its first word.
817 */
818
819 retval = stm32lx_unlock_program_memory(bank);
820 if (retval != ERROR_OK)
821 return retval;
822
823 for (int page = 0; page < FLASH_PAGES_PER_SECTOR; page++) {
824 reg32 = FLASH_PECR__PROG | FLASH_PECR__ERASE;
825 retval = target_write_u32(target, FLASH_PECR, reg32);
826 if (retval != ERROR_OK)
827 return retval;
828
829 retval = stm32lx_wait_until_bsy_clear(bank);
830 if (retval != ERROR_OK)
831 return retval;
832
833 uint32_t addr = bank->base + bank->sectors[sector].offset + (page
834 * FLASH_PAGE_SIZE);
835 retval = target_write_u32(target, addr, 0x0);
836 if (retval != ERROR_OK)
837 return retval;
838
839 retval = stm32lx_wait_until_bsy_clear(bank);
840 if (retval != ERROR_OK)
841 return retval;
842 }
843
844 retval = stm32lx_lock_program_memory(bank);
845 if (retval != ERROR_OK)
846 return retval;
847
848 return ERROR_OK;
849 }
850
851 static int stm32lx_wait_until_bsy_clear(struct flash_bank *bank)
852 {
853 struct target *target = bank->target;
854 uint32_t status;
855 int retval = ERROR_OK;
856 int timeout = 100;
857
858 /* wait for busy to clear */
859 for (;;) {
860 retval = target_read_u32(target, FLASH_SR, &status);
861 if (retval != ERROR_OK)
862 return retval;
863
864 if ((status & FLASH_SR__BSY) == 0)
865 break;
866 if (timeout-- <= 0) {
867 LOG_ERROR("timed out waiting for flash");
868 return ERROR_FAIL;
869 }
870 alive_sleep(1);
871 }
872
873 if (status & FLASH_SR__WRPERR) {
874 LOG_ERROR("access denied / write protected");
875 retval = ERROR_FAIL;
876 }
877
878 if (status & FLASH_SR__PGAERR) {
879 LOG_ERROR("invalid program address");
880 retval = ERROR_FAIL;
881 }
882
883 return retval;
884 }

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)