Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
em357: fix warning by removing unused local variables
[openocd.git] / src / flash / nor / em357.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 Erik Botö
9 * erik.boto@pelagicore.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 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29
30 #include "imp.h"
31 #include <helper/binarybuffer.h>
32 #include <target/algorithm.h>
33 #include <target/armv7m.h>
34
35 /* em357 register locations */
36
37 #define EM357_FLASH_ACR 0x40008000
38 #define EM357_FLASH_KEYR 0x40008004
39 #define EM357_FLASH_OPTKEYR 0x40008008
40 #define EM357_FLASH_SR 0x4000800C
41 #define EM357_FLASH_CR 0x40008010
42 #define EM357_FLASH_AR 0x40008014
43 #define EM357_FLASH_OBR 0x4000801C
44 #define EM357_FLASH_WRPR 0x40008020
45
46 #define EM357_FPEC_CLK 0x4000402c
47 /* option byte location */
48
49 #define EM357_OB_RDP 0x08040800
50 #define EM357_OB_WRP0 0x08040808
51 #define EM357_OB_WRP1 0x0804080A
52 #define EM357_OB_WRP2 0x0804080C
53
54 /* FLASH_CR register bits */
55
56 #define FLASH_PG (1 << 0)
57 #define FLASH_PER (1 << 1)
58 #define FLASH_MER (1 << 2)
59 #define FLASH_OPTPG (1 << 4)
60 #define FLASH_OPTER (1 << 5)
61 #define FLASH_STRT (1 << 6)
62 #define FLASH_LOCK (1 << 7)
63 #define FLASH_OPTWRE (1 << 9)
64
65 /* FLASH_SR register bits */
66
67 #define FLASH_BSY (1 << 0)
68 #define FLASH_PGERR (1 << 2)
69 #define FLASH_WRPRTERR (1 << 4)
70 #define FLASH_EOP (1 << 5)
71
72 /* EM357_FLASH_OBR bit definitions (reading) */
73
74 #define OPT_ERROR 0
75 #define OPT_READOUT 1
76
77 /* register unlock keys */
78
79 #define KEY1 0x45670123
80 #define KEY2 0xCDEF89AB
81
82 struct em357_options
83 {
84 uint16_t RDP;
85 uint16_t user_options;
86 uint16_t protection[3];
87 };
88
89 struct em357_flash_bank
90 {
91 struct em357_options option_bytes;
92 struct working_area *write_algorithm;
93 int ppage_size;
94 int probed;
95 };
96
97 static int em357_mass_erase(struct flash_bank *bank);
98
99 /* flash bank em357 <base> <size> 0 0 <target#>
100 */
101 FLASH_BANK_COMMAND_HANDLER(em357_flash_bank_command)
102 {
103 struct em357_flash_bank *em357_info;
104
105 if (CMD_ARGC < 6)
106 {
107 LOG_WARNING("incomplete flash_bank em357 configuration");
108 return ERROR_FLASH_BANK_INVALID;
109 }
110
111 em357_info = malloc(sizeof(struct em357_flash_bank));
112 bank->driver_priv = em357_info;
113
114 em357_info->write_algorithm = NULL;
115 em357_info->probed = 0;
116
117 return ERROR_OK;
118 }
119
120 static inline int em357_get_flash_status(struct flash_bank *bank, uint32_t *status)
121 {
122 struct target *target = bank->target;
123 return target_read_u32(target, EM357_FLASH_SR, status);
124 }
125
126 static int em357_wait_status_busy(struct flash_bank *bank, int timeout)
127 {
128 struct target *target = bank->target;
129 uint32_t status;
130 int retval = ERROR_OK;
131
132 /* wait for busy to clear */
133 for (;;)
134 {
135 retval = em357_get_flash_status(bank, &status);
136 if (retval != ERROR_OK)
137 return retval;
138 LOG_DEBUG("status: 0x%" PRIx32 "", status);
139 if ((status & FLASH_BSY) == 0)
140 break;
141 if (timeout-- <= 0)
142 {
143 LOG_ERROR("timed out waiting for flash");
144 return ERROR_FAIL;
145 }
146 alive_sleep(1);
147 }
148
149 if (status & FLASH_WRPRTERR)
150 {
151 LOG_ERROR("em357 device protected");
152 retval = ERROR_FAIL;
153 }
154
155 if (status & FLASH_PGERR)
156 {
157 LOG_ERROR("em357 device programming failed");
158 retval = ERROR_FAIL;
159 }
160
161 /* Clear but report errors */
162 if (status & (FLASH_WRPRTERR | FLASH_PGERR))
163 {
164 /* If this operation fails, we ignore it and report the original
165 * retval
166 */
167 target_write_u32(target, EM357_FLASH_SR, FLASH_WRPRTERR | FLASH_PGERR);
168 }
169 return retval;
170 }
171
172 static int em357_read_options(struct flash_bank *bank)
173 {
174 uint32_t optiondata;
175 struct em357_flash_bank *em357_info = NULL;
176 struct target *target = bank->target;
177
178 em357_info = bank->driver_priv;
179
180 /* read current option bytes */
181 int retval = target_read_u32(target, EM357_FLASH_OBR, &optiondata);
182 if (retval != ERROR_OK)
183 return retval;
184
185 em357_info->option_bytes.user_options = (uint16_t)0xFFFC | ((optiondata >> 2) & 0x03);
186 em357_info->option_bytes.RDP = (optiondata & (1 << OPT_READOUT)) ? 0xFFFF : 0x5AA5;
187
188 if (optiondata & (1 << OPT_READOUT))
189 LOG_INFO("Device Security Bit Set");
190
191 /* each bit refers to a 4bank protection */
192 retval = target_read_u32(target, EM357_FLASH_WRPR, &optiondata);
193 if (retval != ERROR_OK)
194 return retval;
195
196 em357_info->option_bytes.protection[0] = (uint16_t)optiondata;
197 em357_info->option_bytes.protection[1] = (uint16_t)(optiondata >> 8);
198 em357_info->option_bytes.protection[2] = (uint16_t)(optiondata >> 16);
199
200 return ERROR_OK;
201 }
202
203 static int em357_erase_options(struct flash_bank *bank)
204 {
205 struct em357_flash_bank *em357_info = NULL;
206 struct target *target = bank->target;
207
208 em357_info = bank->driver_priv;
209
210 /* read current options */
211 em357_read_options(bank);
212
213 /* unlock flash registers */
214 int retval = target_write_u32(target, EM357_FLASH_KEYR, KEY1);
215 if (retval != ERROR_OK)
216 return retval;
217
218 retval = target_write_u32(target, EM357_FLASH_KEYR, KEY2);
219 if (retval != ERROR_OK)
220 return retval;
221
222 /* unlock option flash registers */
223 retval = target_write_u32(target, EM357_FLASH_OPTKEYR, KEY1);
224 if (retval != ERROR_OK)
225 return retval;
226 retval = target_write_u32(target, EM357_FLASH_OPTKEYR, KEY2);
227 if (retval != ERROR_OK)
228 return retval;
229
230 /* erase option bytes */
231 retval = target_write_u32(target, EM357_FLASH_CR, FLASH_OPTER | FLASH_OPTWRE);
232 if (retval != ERROR_OK)
233 return retval;
234 retval = target_write_u32(target, EM357_FLASH_CR, FLASH_OPTER | FLASH_STRT | FLASH_OPTWRE);
235 if (retval != ERROR_OK)
236 return retval;
237
238 retval = em357_wait_status_busy(bank, 10);
239 if (retval != ERROR_OK)
240 return retval;
241
242 /* clear readout protection and complementary option bytes
243 * this will also force a device unlock if set */
244 em357_info->option_bytes.RDP = 0x5AA5;
245
246 return ERROR_OK;
247 }
248
249 static int em357_write_options(struct flash_bank *bank)
250 {
251 struct em357_flash_bank *em357_info = NULL;
252 struct target *target = bank->target;
253
254 em357_info = bank->driver_priv;
255
256 /* unlock flash registers */
257 int retval = target_write_u32(target, EM357_FLASH_KEYR, KEY1);
258 if (retval != ERROR_OK)
259 return retval;
260 retval = target_write_u32(target, EM357_FLASH_KEYR, KEY2);
261 if (retval != ERROR_OK)
262 return retval;
263
264 /* unlock option flash registers */
265 retval = target_write_u32(target, EM357_FLASH_OPTKEYR, KEY1);
266 if (retval != ERROR_OK)
267 return retval;
268 retval = target_write_u32(target, EM357_FLASH_OPTKEYR, KEY2);
269 if (retval != ERROR_OK)
270 return retval;
271
272 /* program option bytes */
273 retval = target_write_u32(target, EM357_FLASH_CR, FLASH_OPTPG | FLASH_OPTWRE);
274 if (retval != ERROR_OK)
275 return retval;
276
277 retval = em357_wait_status_busy(bank, 10);
278 if (retval != ERROR_OK)
279 return retval;
280
281 /* write protection byte 1 */
282 retval = target_write_u16(target, EM357_OB_WRP0, em357_info->option_bytes.protection[0]);
283 if (retval != ERROR_OK)
284 return retval;
285
286 retval = em357_wait_status_busy(bank, 10);
287 if (retval != ERROR_OK)
288 return retval;
289
290 /* write protection byte 2 */
291 retval = target_write_u16(target, EM357_OB_WRP1, em357_info->option_bytes.protection[1]);
292 if (retval != ERROR_OK)
293 return retval;
294
295 retval = em357_wait_status_busy(bank, 10);
296 if (retval != ERROR_OK)
297 return retval;
298
299 /* write protection byte 3 */
300 retval = target_write_u16(target, EM357_OB_WRP2, em357_info->option_bytes.protection[2]);
301 if (retval != ERROR_OK)
302 return retval;
303
304 retval = em357_wait_status_busy(bank, 10);
305 if (retval != ERROR_OK)
306 return retval;
307
308 /* write readout protection bit */
309 retval = target_write_u16(target, EM357_OB_RDP, em357_info->option_bytes.RDP);
310 if (retval != ERROR_OK)
311 return retval;
312
313 retval = em357_wait_status_busy(bank, 10);
314 if (retval != ERROR_OK)
315 return retval;
316
317 retval = target_write_u32(target, EM357_FLASH_CR, FLASH_LOCK);
318 if (retval != ERROR_OK)
319 return retval;
320
321 return ERROR_OK;
322 }
323
324 static int em357_protect_check(struct flash_bank *bank)
325 {
326 struct target *target = bank->target;
327 struct em357_flash_bank *em357_info = bank->driver_priv;
328
329 uint32_t protection;
330 int i, s;
331 int num_bits;
332 int set;
333
334 if (target->state != TARGET_HALTED)
335 {
336 LOG_ERROR("Target not halted");
337 return ERROR_TARGET_NOT_HALTED;
338 }
339
340 /* each bit refers to a 4bank protection (bit 0-23) */
341 int retval = target_read_u32(target, EM357_FLASH_WRPR, &protection);
342 if (retval != ERROR_OK)
343 return retval;
344
345 /* each protection bit is for 4 * 2K pages */
346 num_bits = (bank->num_sectors / em357_info->ppage_size);
347
348 for (i = 0; i < num_bits; i++)
349 {
350 set = 1;
351 if (protection & (1 << i))
352 set = 0;
353
354 for (s = 0; s < em357_info->ppage_size; s++)
355 bank->sectors[(i * em357_info->ppage_size) + s].is_protected = set;
356 }
357
358 return ERROR_OK;
359 }
360
361 static int em357_erase(struct flash_bank *bank, int first, int last)
362 {
363 struct target *target = bank->target;
364 int i;
365
366 if (bank->target->state != TARGET_HALTED)
367 {
368 LOG_ERROR("Target not halted");
369 return ERROR_TARGET_NOT_HALTED;
370 }
371
372 if ((first == 0) && (last == (bank->num_sectors - 1)))
373 {
374 return em357_mass_erase(bank);
375 }
376
377 /* unlock flash registers */
378 int retval = target_write_u32(target, EM357_FLASH_KEYR, KEY1);
379 if (retval != ERROR_OK)
380 return retval;
381 retval = target_write_u32(target, EM357_FLASH_KEYR, KEY2);
382 if (retval != ERROR_OK)
383 return retval;
384
385 for (i = first; i <= last; i++)
386 {
387 retval = target_write_u32(target, EM357_FLASH_CR, FLASH_PER);
388 if (retval != ERROR_OK)
389 return retval;
390 retval = target_write_u32(target, EM357_FLASH_AR,
391 bank->base + bank->sectors[i].offset);
392 if (retval != ERROR_OK)
393 return retval;
394 retval = target_write_u32(target, EM357_FLASH_CR, FLASH_PER | FLASH_STRT);
395 if (retval != ERROR_OK)
396 return retval;
397
398 retval = em357_wait_status_busy(bank, 100);
399 if (retval != ERROR_OK)
400 return retval;
401
402 bank->sectors[i].is_erased = 1;
403 }
404
405 retval = target_write_u32(target, EM357_FLASH_CR, FLASH_LOCK);
406 if (retval != ERROR_OK)
407 return retval;
408
409 return ERROR_OK;
410 }
411
412 static int em357_protect(struct flash_bank *bank, int set, int first, int last)
413 {
414 struct em357_flash_bank *em357_info = NULL;
415 struct target *target = bank->target;
416 uint16_t prot_reg[4] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
417 int i, reg, bit;
418 int status;
419 uint32_t protection;
420
421 em357_info = bank->driver_priv;
422
423 if (target->state != TARGET_HALTED)
424 {
425 LOG_ERROR("Target not halted");
426 return ERROR_TARGET_NOT_HALTED;
427 }
428
429 if ((first % em357_info->ppage_size) != 0)
430 {
431 LOG_WARNING("aligned start protect sector to a %d sector boundary",
432 em357_info->ppage_size);
433 first = first - (first % em357_info->ppage_size);
434 }
435 if (((last + 1) % em357_info->ppage_size) != 0)
436 {
437 LOG_WARNING("aligned end protect sector to a %d sector boundary",
438 em357_info->ppage_size);
439 last++;
440 last = last - (last % em357_info->ppage_size);
441 last--;
442 }
443
444 /* each bit refers to a 4bank protection */
445 int retval = target_read_u32(target, EM357_FLASH_WRPR, &protection);
446 if (retval != ERROR_OK)
447 return retval;
448
449 prot_reg[0] = (uint16_t)protection;
450 prot_reg[1] = (uint16_t)(protection >> 8);
451 prot_reg[2] = (uint16_t)(protection >> 16);
452
453 for (i = first; i <= last; i++)
454 {
455 reg = (i / em357_info->ppage_size) / 8;
456 bit = (i / em357_info->ppage_size) - (reg * 8);
457
458 LOG_WARNING("reg, bit: %d, %d", reg, bit);
459 if (set)
460 prot_reg[reg] &= ~(1 << bit);
461 else
462 prot_reg[reg] |= (1 << bit);
463 }
464
465 if ((status = em357_erase_options(bank)) != ERROR_OK)
466 return status;
467
468 em357_info->option_bytes.protection[0] = prot_reg[0];
469 em357_info->option_bytes.protection[1] = prot_reg[1];
470 em357_info->option_bytes.protection[2] = prot_reg[2];
471
472 return em357_write_options(bank);
473 }
474
475 static int em357_write_block(struct flash_bank *bank, uint8_t *buffer,
476 uint32_t offset, uint32_t count)
477 {
478 struct em357_flash_bank *em357_info = bank->driver_priv;
479 struct target *target = bank->target;
480 uint32_t buffer_size = 16384;
481 struct working_area *source;
482 uint32_t address = bank->base + offset;
483 struct reg_param reg_params[4];
484 struct armv7m_algorithm armv7m_info;
485 int retval = ERROR_OK;
486
487 /* see contib/loaders/flash/stm32x.s for src, the same is used here except for
488 * a modified *_FLASH_BASE */
489
490 static const uint8_t em357_flash_write_code[] = {
491 /* #define EM357_FLASH_CR_OFFSET 0x10 */
492 /* #define EM357_FLASH_SR_OFFSET 0x0C */
493 /* write: */
494 0x08, 0x4c, /* ldr r4, EM357_FLASH_BASE */
495 0x1c, 0x44, /* add r4, r3 */
496 /* write_half_word: */
497 0x01, 0x23, /* movs r3, #0x01 */
498 0x23, 0x61, /* str r3, [r4, #EM357_FLASH_CR_OFFSET] */
499 0x30, 0xf8, 0x02, 0x3b, /* ldrh r3, [r0], #0x02 */
500 0x21, 0xf8, 0x02, 0x3b, /* strh r3, [r1], #0x02 */
501 /* busy: */
502 0xe3, 0x68, /* ldr r3, [r4, #EM357_FLASH_SR_OFFSET] */
503 0x13, 0xf0, 0x01, 0x0f, /* tst r3, #0x01 */
504 0xfb, 0xd0, /* beq busy */
505 0x13, 0xf0, 0x14, 0x0f, /* tst r3, #0x14 */
506 0x01, 0xd1, /* bne exit */
507 0x01, 0x3a, /* subs r2, r2, #0x01 */
508 0xf0, 0xd1, /* bne write_half_word */
509 /* exit: */
510 0x00, 0xbe, /* bkpt #0x00 */
511 0x00, 0x80, 0x00, 0x40, /* EM357_FLASH_BASE: .word 0x40008000 */
512 };
513
514 /* flash write code */
515 if (target_alloc_working_area(target, sizeof(em357_flash_write_code),
516 &em357_info->write_algorithm) != ERROR_OK)
517 {
518 LOG_WARNING("no working area available, can't do block memory writes");
519 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
520 };
521
522 if ((retval = target_write_buffer(target, em357_info->write_algorithm->address,
523 sizeof(em357_flash_write_code),
524 (uint8_t*)em357_flash_write_code)) != ERROR_OK)
525 return retval;
526
527 /* memory buffer */
528 while (target_alloc_working_area_try(target, buffer_size, &source) != ERROR_OK)
529 {
530 buffer_size /= 2;
531 if (buffer_size <= 256)
532 {
533 /* if we already allocated the writing code, but failed to get a
534 * buffer, free the algorithm */
535 if (em357_info->write_algorithm)
536 target_free_working_area(target, em357_info->write_algorithm);
537
538 LOG_WARNING("no large enough working area available, can't do block memory writes");
539 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
540 }
541 };
542
543 armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
544 armv7m_info.core_mode = ARMV7M_MODE_ANY;
545
546 init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
547 init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
548 init_reg_param(&reg_params[2], "r2", 32, PARAM_OUT);
549 init_reg_param(&reg_params[3], "r3", 32, PARAM_IN_OUT);
550
551 while (count > 0)
552 {
553 uint32_t thisrun_count = (count > (buffer_size / 2)) ?
554 (buffer_size / 2) : count;
555
556 if ((retval = target_write_buffer(target, source->address,
557 thisrun_count * 2, buffer)) != ERROR_OK)
558 break;
559
560 buf_set_u32(reg_params[0].value, 0, 32, source->address);
561 buf_set_u32(reg_params[1].value, 0, 32, address);
562 buf_set_u32(reg_params[2].value, 0, 32, thisrun_count);
563 buf_set_u32(reg_params[3].value, 0, 32, 0);
564
565 if ((retval = target_run_algorithm(target, 0, NULL, 4, reg_params,
566 em357_info->write_algorithm->address,
567 0,
568 10000, &armv7m_info)) != ERROR_OK)
569 {
570 LOG_ERROR("error executing em357 flash write algorithm");
571 break;
572 }
573
574 if (buf_get_u32(reg_params[3].value, 0, 32) & FLASH_PGERR)
575 {
576 LOG_ERROR("flash memory not erased before writing");
577 /* Clear but report errors */
578 target_write_u32(target, EM357_FLASH_SR, FLASH_PGERR);
579 retval = ERROR_FAIL;
580 break;
581 }
582
583 if (buf_get_u32(reg_params[3].value, 0, 32) & FLASH_WRPRTERR)
584 {
585 LOG_ERROR("flash memory write protected");
586 /* Clear but report errors */
587 target_write_u32(target, EM357_FLASH_SR, FLASH_WRPRTERR);
588 retval = ERROR_FAIL;
589 break;
590 }
591
592 buffer += thisrun_count * 2;
593 address += thisrun_count * 2;
594 count -= thisrun_count;
595 }
596
597 target_free_working_area(target, source);
598 target_free_working_area(target, em357_info->write_algorithm);
599
600 destroy_reg_param(&reg_params[0]);
601 destroy_reg_param(&reg_params[1]);
602 destroy_reg_param(&reg_params[2]);
603 destroy_reg_param(&reg_params[3]);
604
605 return retval;
606 }
607
608 static int em357_write(struct flash_bank *bank, uint8_t *buffer,
609 uint32_t offset, uint32_t count)
610 {
611 struct target *target = bank->target;
612 uint32_t words_remaining = (count / 2);
613 uint32_t bytes_remaining = (count & 0x00000001);
614 uint32_t address = bank->base + offset;
615 uint32_t bytes_written = 0;
616 int retval;
617
618 if (bank->target->state != TARGET_HALTED)
619 {
620 LOG_ERROR("Target not halted");
621 return ERROR_TARGET_NOT_HALTED;
622 }
623
624 if (offset & 0x1)
625 {
626 LOG_WARNING("offset 0x%" PRIx32 " breaks required 2-byte alignment", offset);
627 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
628 }
629
630 /* unlock flash registers */
631 retval = target_write_u32(target, EM357_FLASH_KEYR, KEY1);
632 if (retval != ERROR_OK)
633 return retval;
634 retval = target_write_u32(target, EM357_FLASH_KEYR, KEY2);
635 if (retval != ERROR_OK)
636 return retval;
637
638 /* multiple half words (2-byte) to be programmed? */
639 if (words_remaining > 0)
640 {
641 /* try using a block write */
642 if ((retval = em357_write_block(bank, buffer, offset, words_remaining)) != ERROR_OK)
643 {
644 if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
645 {
646 /* if block write failed (no sufficient working area),
647 * we use normal (slow) single dword accesses */
648 LOG_WARNING("couldn't use block writes, falling back to single memory accesses");
649 }
650 }
651 else
652 {
653 buffer += words_remaining * 2;
654 address += words_remaining * 2;
655 words_remaining = 0;
656 }
657 }
658
659 if ((retval != ERROR_OK) && (retval != ERROR_TARGET_RESOURCE_NOT_AVAILABLE))
660 return retval;
661
662 while (words_remaining > 0)
663 {
664 uint16_t value;
665 memcpy(&value, buffer + bytes_written, sizeof(uint16_t));
666
667 retval = target_write_u32(target, EM357_FLASH_CR, FLASH_PG);
668 if (retval != ERROR_OK)
669 return retval;
670 retval = target_write_u16(target, address, value);
671 if (retval != ERROR_OK)
672 return retval;
673
674 retval = em357_wait_status_busy(bank, 5);
675 if (retval != ERROR_OK)
676 return retval;
677
678 bytes_written += 2;
679 words_remaining--;
680 address += 2;
681 }
682
683 if (bytes_remaining)
684 {
685 uint16_t value = 0xffff;
686 memcpy(&value, buffer + bytes_written, bytes_remaining);
687
688 retval = target_write_u32(target, EM357_FLASH_CR, FLASH_PG);
689 if (retval != ERROR_OK)
690 return retval;
691 retval = target_write_u16(target, address, value);
692 if (retval != ERROR_OK)
693 return retval;
694
695 retval = em357_wait_status_busy(bank, 5);
696 if (retval != ERROR_OK)
697 return retval;
698 }
699
700 return target_write_u32(target, EM357_FLASH_CR, FLASH_LOCK);
701 }
702
703 static int em357_probe(struct flash_bank *bank)
704 {
705 struct target *target = bank->target;
706 struct em357_flash_bank *em357_info = bank->driver_priv;
707 int i;
708 uint16_t num_pages;
709 int page_size;
710 uint32_t base_address = 0x08000000;
711
712 em357_info->probed = 0;
713
714 /* Enable FPEC CLK */
715 int retval = target_write_u32(target, EM357_FPEC_CLK, 0x00000001);
716 if (retval != ERROR_OK)
717 return retval;
718
719 page_size = 2048;
720 em357_info->ppage_size = 4;
721 num_pages = 96;
722
723 LOG_INFO("flash size = %dkbytes", num_pages*page_size/1024);
724
725 if (bank->sectors)
726 {
727 free(bank->sectors);
728 bank->sectors = NULL;
729 }
730
731 bank->base = base_address;
732 bank->size = (num_pages * page_size);
733 bank->num_sectors = num_pages;
734 bank->sectors = malloc(sizeof(struct flash_sector) * num_pages);
735
736 for (i = 0; i < num_pages; i++)
737 {
738 bank->sectors[i].offset = i * page_size;
739 bank->sectors[i].size = page_size;
740 bank->sectors[i].is_erased = -1;
741 bank->sectors[i].is_protected = 1;
742 }
743
744 em357_info->probed = 1;
745
746 return ERROR_OK;
747 }
748
749 static int em357_auto_probe(struct flash_bank *bank)
750 {
751 struct em357_flash_bank *em357_info = bank->driver_priv;
752 if (em357_info->probed)
753 return ERROR_OK;
754 return em357_probe(bank);
755 }
756
757
758 static int get_em357_info(struct flash_bank *bank, char *buf, int buf_size)
759 {
760 snprintf(buf, buf_size, "em357\n");
761 return ERROR_OK;
762 }
763
764 COMMAND_HANDLER(em357_handle_lock_command)
765 {
766 struct target *target = NULL;
767 struct em357_flash_bank *em357_info = NULL;
768
769 if (CMD_ARGC < 1)
770 {
771 command_print(CMD_CTX, "em357 lock <bank>");
772 return ERROR_OK;
773 }
774
775 struct flash_bank *bank;
776 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
777 if (ERROR_OK != retval)
778 return retval;
779
780 em357_info = bank->driver_priv;
781
782 target = bank->target;
783
784 if (target->state != TARGET_HALTED)
785 {
786 LOG_ERROR("Target not halted");
787 return ERROR_TARGET_NOT_HALTED;
788 }
789
790 if (em357_erase_options(bank) != ERROR_OK)
791 {
792 command_print(CMD_CTX, "em357 failed to erase options");
793 return ERROR_OK;
794 }
795
796 /* set readout protection */
797 em357_info->option_bytes.RDP = 0;
798
799 if (em357_write_options(bank) != ERROR_OK)
800 {
801 command_print(CMD_CTX, "em357 failed to lock device");
802 return ERROR_OK;
803 }
804
805 command_print(CMD_CTX, "em357 locked");
806
807 return ERROR_OK;
808 }
809
810 COMMAND_HANDLER(em357_handle_unlock_command)
811 {
812 struct target *target = NULL;
813
814 if (CMD_ARGC < 1)
815 {
816 command_print(CMD_CTX, "em357 unlock <bank>");
817 return ERROR_OK;
818 }
819
820 struct flash_bank *bank;
821 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
822 if (ERROR_OK != retval)
823 return retval;
824
825 target = bank->target;
826
827 if (target->state != TARGET_HALTED)
828 {
829 LOG_ERROR("Target not halted");
830 return ERROR_TARGET_NOT_HALTED;
831 }
832
833 if (em357_erase_options(bank) != ERROR_OK)
834 {
835 command_print(CMD_CTX, "em357 failed to unlock device");
836 return ERROR_OK;
837 }
838
839 if (em357_write_options(bank) != ERROR_OK)
840 {
841 command_print(CMD_CTX, "em357 failed to lock device");
842 return ERROR_OK;
843 }
844
845 command_print(CMD_CTX, "em357 unlocked.\n"
846 "INFO: a reset or power cycle is required "
847 "for the new settings to take effect.");
848
849 return ERROR_OK;
850 }
851
852 static int em357_mass_erase(struct flash_bank *bank)
853 {
854 struct target *target = bank->target;
855
856 if (target->state != TARGET_HALTED)
857 {
858 LOG_ERROR("Target not halted");
859 return ERROR_TARGET_NOT_HALTED;
860 }
861
862 /* unlock option flash registers */
863 int retval = target_write_u32(target, EM357_FLASH_KEYR, KEY1);
864 if (retval != ERROR_OK)
865 return retval;
866 retval = target_write_u32(target, EM357_FLASH_KEYR, KEY2);
867 if (retval != ERROR_OK)
868 return retval;
869
870 /* mass erase flash memory */
871 retval = target_write_u32(target, EM357_FLASH_CR, FLASH_MER);
872 if (retval != ERROR_OK)
873 return retval;
874 retval = target_write_u32(target, EM357_FLASH_CR, FLASH_MER | FLASH_STRT);
875 if (retval != ERROR_OK)
876 return retval;
877
878 retval = em357_wait_status_busy(bank, 100);
879 if (retval != ERROR_OK)
880 return retval;
881
882 retval = target_write_u32(target, EM357_FLASH_CR, FLASH_LOCK);
883 if (retval != ERROR_OK)
884 return retval;
885
886 return ERROR_OK;
887 }
888
889 COMMAND_HANDLER(em357_handle_mass_erase_command)
890 {
891 int i;
892
893 if (CMD_ARGC < 1)
894 {
895 command_print(CMD_CTX, "em357 mass_erase <bank>");
896 return ERROR_OK;
897 }
898
899 struct flash_bank *bank;
900 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
901 if (ERROR_OK != retval)
902 return retval;
903
904 retval = em357_mass_erase(bank);
905 if (retval == ERROR_OK)
906 {
907 /* set all sectors as erased */
908 for (i = 0; i < bank->num_sectors; i++)
909 {
910 bank->sectors[i].is_erased = 1;
911 }
912
913 command_print(CMD_CTX, "em357 mass erase complete");
914 }
915 else
916 {
917 command_print(CMD_CTX, "em357 mass erase failed");
918 }
919
920 return retval;
921 }
922
923 static const struct command_registration em357_exec_command_handlers[] = {
924 {
925 .name = "lock",
926 .handler = em357_handle_lock_command,
927 .mode = COMMAND_EXEC,
928 .usage = "bank_id",
929 .help = "Lock entire flash device.",
930 },
931 {
932 .name = "unlock",
933 .handler = em357_handle_unlock_command,
934 .mode = COMMAND_EXEC,
935 .usage = "bank_id",
936 .help = "Unlock entire protected flash device.",
937 },
938 {
939 .name = "mass_erase",
940 .handler = em357_handle_mass_erase_command,
941 .mode = COMMAND_EXEC,
942 .usage = "bank_id",
943 .help = "Erase entire flash device.",
944 },
945 COMMAND_REGISTRATION_DONE
946 };
947
948 static const struct command_registration em357_command_handlers[] = {
949 {
950 .name = "em357",
951 .mode = COMMAND_ANY,
952 .help = "em357 flash command group",
953 .chain = em357_exec_command_handlers,
954 },
955 COMMAND_REGISTRATION_DONE
956 };
957
958 struct flash_driver em357_flash = {
959 .name = "em357",
960 .commands = em357_command_handlers,
961 .flash_bank_command = em357_flash_bank_command,
962 .erase = em357_erase,
963 .protect = em357_protect,
964 .write = em357_write,
965 .read = default_flash_read,
966 .probe = em357_probe,
967 .auto_probe = em357_auto_probe,
968 .erase_check = default_flash_mem_blank_check,
969 .protect_check = em357_protect_check,
970 .info = get_em357_info,
971 };
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)