Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
flash/nor/stm32: Eliminate working area leak
[openocd.git] / src / flash / nor / at91sam4.c
1 /***************************************************************************
2 * Copyright (C) 2009 by Duane Ellis *
3 * openocd@duaneellis.com *
4 * *
5 * Copyright (C) 2010 by Olaf Lüke (at91sam3s* support) *
6 * olaf@uni-paderborn.de *
7 * *
8 * Copyright (C) 2011 by Olivier Schonken, Jim Norris *
9 * (at91sam3x* & at91sam4 support)* *
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 /* Some of the the lower level code was based on code supplied by
26 * ATMEL under this copyright. */
27
28 /* BEGIN ATMEL COPYRIGHT */
29 /* ----------------------------------------------------------------------------
30 * ATMEL Microcontroller Software Support
31 * ----------------------------------------------------------------------------
32 * Copyright (c) 2009, Atmel Corporation
33 *
34 * All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions are met:
38 *
39 * - Redistributions of source code must retain the above copyright notice,
40 * this list of conditions and the disclaimer below.
41 *
42 * Atmel's name may not be used to endorse or promote products derived from
43 * this software without specific prior written permission.
44 *
45 * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
46 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
47 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
48 * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
49 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
50 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
51 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
52 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
53 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
54 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
55 * ----------------------------------------------------------------------------
56 */
57 /* END ATMEL COPYRIGHT */
58
59 #ifdef HAVE_CONFIG_H
60 #include "config.h"
61 #endif
62
63 #include "imp.h"
64 #include <helper/time_support.h>
65
66 #define REG_NAME_WIDTH (12)
67
68 /* at91sam4s/at91sam4e/at91sam4c series (has always one flash bank)*/
69 #define FLASH_BANK_BASE_S 0x00400000
70 #define FLASH_BANK_BASE_C 0x01000000
71
72 /* at91sam4sd series (two one flash banks), first bank address */
73 #define FLASH_BANK0_BASE_SD FLASH_BANK_BASE_S
74 /* at91sam4sd16x, second bank address */
75 #define FLASH_BANK1_BASE_1024K_SD (FLASH_BANK0_BASE_SD+(1024*1024/2))
76 /* at91sam4sd32x, second bank address */
77 #define FLASH_BANK1_BASE_2048K_SD (FLASH_BANK0_BASE_SD+(2048*1024/2))
78
79 /* at91sam4c32x, first and second bank address */
80 #define FLASH_BANK0_BASE_C32 FLASH_BANK_BASE_C
81 #define FLASH_BANK1_BASE_C32 (FLASH_BANK_BASE_C+(2048*1024/2))
82
83 #define AT91C_EFC_FCMD_GETD (0x0) /* (EFC) Get Flash Descriptor */
84 #define AT91C_EFC_FCMD_WP (0x1) /* (EFC) Write Page */
85 #define AT91C_EFC_FCMD_WPL (0x2) /* (EFC) Write Page and Lock */
86 #define AT91C_EFC_FCMD_EWP (0x3) /* (EFC) Erase Page and Write Page */
87 #define AT91C_EFC_FCMD_EWPL (0x4) /* (EFC) Erase Page and Write Page then Lock */
88 #define AT91C_EFC_FCMD_EA (0x5) /* (EFC) Erase All */
89 /* cmd6 is not present in the at91sam4u4/2/1 data sheet table 19-2 */
90 /* #define AT91C_EFC_FCMD_EPL (0x6) // (EFC) Erase plane? */
91 #define AT91C_EFC_FCMD_EPA (0x7) /* (EFC) Erase pages */
92 #define AT91C_EFC_FCMD_SLB (0x8) /* (EFC) Set Lock Bit */
93 #define AT91C_EFC_FCMD_CLB (0x9) /* (EFC) Clear Lock Bit */
94 #define AT91C_EFC_FCMD_GLB (0xA) /* (EFC) Get Lock Bit */
95 #define AT91C_EFC_FCMD_SFB (0xB) /* (EFC) Set Fuse Bit */
96 #define AT91C_EFC_FCMD_CFB (0xC) /* (EFC) Clear Fuse Bit */
97 #define AT91C_EFC_FCMD_GFB (0xD) /* (EFC) Get Fuse Bit */
98 #define AT91C_EFC_FCMD_STUI (0xE) /* (EFC) Start Read Unique ID */
99 #define AT91C_EFC_FCMD_SPUI (0xF) /* (EFC) Stop Read Unique ID */
100
101 #define offset_EFC_FMR 0
102 #define offset_EFC_FCR 4
103 #define offset_EFC_FSR 8
104 #define offset_EFC_FRR 12
105
106 extern struct flash_driver at91sam4_flash;
107
108 static float _tomhz(uint32_t freq_hz)
109 {
110 float f;
111
112 f = ((float)(freq_hz)) / 1000000.0;
113 return f;
114 }
115
116 /* How the chip is configured. */
117 struct sam4_cfg {
118 uint32_t unique_id[4];
119
120 uint32_t slow_freq;
121 uint32_t rc_freq;
122 uint32_t mainosc_freq;
123 uint32_t plla_freq;
124 uint32_t mclk_freq;
125 uint32_t cpu_freq;
126 uint32_t fclk_freq;
127 uint32_t pclk0_freq;
128 uint32_t pclk1_freq;
129 uint32_t pclk2_freq;
130
131
132 #define SAM4_CHIPID_CIDR (0x400E0740)
133 uint32_t CHIPID_CIDR;
134 #define SAM4_CHIPID_EXID (0x400E0744)
135 uint32_t CHIPID_EXID;
136
137 #define SAM4_PMC_BASE (0x400E0400)
138 #define SAM4_PMC_SCSR (SAM4_PMC_BASE + 0x0008)
139 uint32_t PMC_SCSR;
140 #define SAM4_PMC_PCSR (SAM4_PMC_BASE + 0x0018)
141 uint32_t PMC_PCSR;
142 #define SAM4_CKGR_UCKR (SAM4_PMC_BASE + 0x001c)
143 uint32_t CKGR_UCKR;
144 #define SAM4_CKGR_MOR (SAM4_PMC_BASE + 0x0020)
145 uint32_t CKGR_MOR;
146 #define SAM4_CKGR_MCFR (SAM4_PMC_BASE + 0x0024)
147 uint32_t CKGR_MCFR;
148 #define SAM4_CKGR_PLLAR (SAM4_PMC_BASE + 0x0028)
149 uint32_t CKGR_PLLAR;
150 #define SAM4_PMC_MCKR (SAM4_PMC_BASE + 0x0030)
151 uint32_t PMC_MCKR;
152 #define SAM4_PMC_PCK0 (SAM4_PMC_BASE + 0x0040)
153 uint32_t PMC_PCK0;
154 #define SAM4_PMC_PCK1 (SAM4_PMC_BASE + 0x0044)
155 uint32_t PMC_PCK1;
156 #define SAM4_PMC_PCK2 (SAM4_PMC_BASE + 0x0048)
157 uint32_t PMC_PCK2;
158 #define SAM4_PMC_SR (SAM4_PMC_BASE + 0x0068)
159 uint32_t PMC_SR;
160 #define SAM4_PMC_IMR (SAM4_PMC_BASE + 0x006c)
161 uint32_t PMC_IMR;
162 #define SAM4_PMC_FSMR (SAM4_PMC_BASE + 0x0070)
163 uint32_t PMC_FSMR;
164 #define SAM4_PMC_FSPR (SAM4_PMC_BASE + 0x0074)
165 uint32_t PMC_FSPR;
166 };
167
168 struct sam4_bank_private {
169 int probed;
170 /* DANGER: THERE ARE DRAGONS HERE.. */
171 /* NOTE: If you add more 'ghost' pointers */
172 /* be aware that you must *manually* update */
173 /* these pointers in the function sam4_GetDetails() */
174 /* See the comment "Here there be dragons" */
175
176 /* so we can find the chip we belong to */
177 struct sam4_chip *pChip;
178 /* so we can find the original bank pointer */
179 struct flash_bank *pBank;
180 unsigned bank_number;
181 uint32_t controller_address;
182 uint32_t base_address;
183 uint32_t flash_wait_states;
184 bool present;
185 unsigned size_bytes;
186 unsigned nsectors;
187 unsigned sector_size;
188 unsigned page_size;
189 };
190
191 struct sam4_chip_details {
192 /* THERE ARE DRAGONS HERE.. */
193 /* note: If you add pointers here */
194 /* be careful about them as they */
195 /* may need to be updated inside */
196 /* the function: "sam4_GetDetails() */
197 /* which copy/overwrites the */
198 /* 'runtime' copy of this structure */
199 uint32_t chipid_cidr;
200 const char *name;
201
202 unsigned n_gpnvms;
203 #define SAM4_N_NVM_BITS 3
204 unsigned gpnvm[SAM4_N_NVM_BITS];
205 unsigned total_flash_size;
206 unsigned total_sram_size;
207 unsigned n_banks;
208 #define SAM4_MAX_FLASH_BANKS 2
209 /* these are "initialized" from the global const data */
210 struct sam4_bank_private bank[SAM4_MAX_FLASH_BANKS];
211 };
212
213 struct sam4_chip {
214 struct sam4_chip *next;
215 int probed;
216
217 /* this is "initialized" from the global const structure */
218 struct sam4_chip_details details;
219 struct target *target;
220 struct sam4_cfg cfg;
221 };
222
223
224 struct sam4_reg_list {
225 uint32_t address; size_t struct_offset; const char *name;
226 void (*explain_func)(struct sam4_chip *pInfo);
227 };
228
229 static struct sam4_chip *all_sam4_chips;
230
231 static struct sam4_chip *get_current_sam4(struct command_context *cmd_ctx)
232 {
233 struct target *t;
234 static struct sam4_chip *p;
235
236 t = get_current_target(cmd_ctx);
237 if (!t) {
238 command_print(cmd_ctx, "No current target?");
239 return NULL;
240 }
241
242 p = all_sam4_chips;
243 if (!p) {
244 /* this should not happen */
245 /* the command is not registered until the chip is created? */
246 command_print(cmd_ctx, "No SAM4 chips exist?");
247 return NULL;
248 }
249
250 while (p) {
251 if (p->target == t)
252 return p;
253 p = p->next;
254 }
255 command_print(cmd_ctx, "Cannot find SAM4 chip?");
256 return NULL;
257 }
258
259 /*The actual sector size of the SAM4S flash memory is 65536 bytes. 16 sectors for a 1024KB device*/
260 /*The lockregions are 8KB per lock region, with a 1024KB device having 128 lock regions. */
261 /*For the best results, nsectors are thus set to the amount of lock regions, and the sector_size*/
262 /*set to the lock region size. Page erases are used to erase 8KB sections when programming*/
263
264 /* these are used to *initialize* the "pChip->details" structure. */
265 static const struct sam4_chip_details all_sam4_details[] = {
266 /* Start at91sam4c* series */
267 /* at91sam4c32e - LQFP144 */
268 {
269 .chipid_cidr = 0xA66D0EE0,
270 .name = "at91sam4c32e",
271 .total_flash_size = 2024 * 1024,
272 .total_sram_size = 256 * 1024,
273 .n_gpnvms = 3,
274 .n_banks = 2,
275 /* .bank[0] = { */
276 {
277 {
278 .probed = 0,
279 .pChip = NULL,
280 .pBank = NULL,
281 .bank_number = 0,
282 .base_address = FLASH_BANK0_BASE_C32,
283 .controller_address = 0x400e0a00,
284 .flash_wait_states = 5,
285 .present = 1,
286 .size_bytes = 1024 * 1024,
287 .nsectors = 128,
288 .sector_size = 8192,
289 .page_size = 512,
290 },
291 /* .bank[1] = { */
292 {
293 .probed = 0,
294 .pChip = NULL,
295 .pBank = NULL,
296 .bank_number = 1,
297 .base_address = FLASH_BANK1_BASE_C32,
298 .controller_address = 0x400e0c00,
299 .flash_wait_states = 5,
300 .present = 1,
301 .size_bytes = 1024 * 1024,
302 .nsectors = 128,
303 .sector_size = 8192,
304 .page_size = 512,
305 },
306 },
307 },
308 /* at91sam4c32c - LQFP100 */
309 {
310 .chipid_cidr = 0xA64D0EE0,
311 .name = "at91sam4c32c",
312 .total_flash_size = 2024 * 1024,
313 .total_sram_size = 256 * 1024,
314 .n_gpnvms = 3,
315 .n_banks = 2,
316 /* .bank[0] = { */
317 {
318 {
319 .probed = 0,
320 .pChip = NULL,
321 .pBank = NULL,
322 .bank_number = 0,
323 .base_address = FLASH_BANK0_BASE_C32,
324 .controller_address = 0x400e0a00,
325 .flash_wait_states = 5,
326 .present = 1,
327 .size_bytes = 1024 * 1024,
328 .nsectors = 128,
329 .sector_size = 8192,
330 .page_size = 512,
331 },
332 /* .bank[1] = { */
333 {
334 .probed = 0,
335 .pChip = NULL,
336 .pBank = NULL,
337 .bank_number = 1,
338 .base_address = FLASH_BANK1_BASE_C32,
339 .controller_address = 0x400e0c00,
340 .flash_wait_states = 5,
341 .present = 1,
342 .size_bytes = 1024 * 1024,
343 .nsectors = 128,
344 .sector_size = 8192,
345 .page_size = 512,
346 },
347 },
348 },
349 /* at91sam4c16c - LQFP100 */
350 {
351 .chipid_cidr = 0xA64C0CE0,
352 .name = "at91sam4c16c",
353 .total_flash_size = 1024 * 1024,
354 .total_sram_size = 128 * 1024,
355 .n_gpnvms = 2,
356 .n_banks = 1,
357 {
358 /* .bank[0] = {*/
359 {
360 .probed = 0,
361 .pChip = NULL,
362 .pBank = NULL,
363 .bank_number = 0,
364 .base_address = FLASH_BANK_BASE_C,
365 .controller_address = 0x400e0a00,
366 .flash_wait_states = 5,
367 .present = 1,
368 .size_bytes = 1024 * 1024,
369 .nsectors = 128,
370 .sector_size = 8192,
371 .page_size = 512,
372 },
373 /* .bank[1] = {*/
374 {
375 .present = 0,
376 .probed = 0,
377 .bank_number = 1,
378
379 },
380 },
381 },
382 /* at91sam4c8c - LQFP100 */
383 {
384 .chipid_cidr = 0xA64C0AE0,
385 .name = "at91sam4c8c",
386 .total_flash_size = 512 * 1024,
387 .total_sram_size = 128 * 1024,
388 .n_gpnvms = 2,
389 .n_banks = 1,
390 {
391 /* .bank[0] = {*/
392 {
393 .probed = 0,
394 .pChip = NULL,
395 .pBank = NULL,
396 .bank_number = 0,
397 .base_address = FLASH_BANK_BASE_C,
398 .controller_address = 0x400e0a00,
399 .flash_wait_states = 5,
400 .present = 1,
401 .size_bytes = 512 * 1024,
402 .nsectors = 64,
403 .sector_size = 8192,
404 .page_size = 512,
405 },
406 /* .bank[1] = {*/
407 {
408 .present = 0,
409 .probed = 0,
410 .bank_number = 1,
411
412 },
413 },
414 },
415 /* at91sam4c4c (rev B) - LQFP100 */
416 {
417 .chipid_cidr = 0xA64C0CE5,
418 .name = "at91sam4c4c",
419 .total_flash_size = 256 * 1024,
420 .total_sram_size = 128 * 1024,
421 .n_gpnvms = 2,
422 .n_banks = 1,
423 {
424 /* .bank[0] = {*/
425 {
426 .probed = 0,
427 .pChip = NULL,
428 .pBank = NULL,
429 .bank_number = 0,
430 .base_address = FLASH_BANK_BASE_C,
431 .controller_address = 0x400e0a00,
432 .flash_wait_states = 5,
433 .present = 1,
434 .size_bytes = 256 * 1024,
435 .nsectors = 32,
436 .sector_size = 8192,
437 .page_size = 512,
438 },
439 /* .bank[1] = {*/
440 {
441 .present = 0,
442 .probed = 0,
443 .bank_number = 1,
444
445 },
446 },
447 },
448
449 /* Start at91sam4e* series */
450 /*atsam4e16e - LQFP144/LFBGA144*/
451 {
452 .chipid_cidr = 0xA3CC0CE0,
453 .name = "at91sam4e16e",
454 .total_flash_size = 1024 * 1024,
455 .total_sram_size = 128 * 1024,
456 .n_gpnvms = 2,
457 .n_banks = 1,
458 {
459 /* .bank[0] = {*/
460 {
461 .probed = 0,
462 .pChip = NULL,
463 .pBank = NULL,
464 .bank_number = 0,
465 .base_address = FLASH_BANK_BASE_S,
466 .controller_address = 0x400e0a00,
467 .flash_wait_states = 5,
468 .present = 1,
469 .size_bytes = 1024 * 1024,
470 .nsectors = 128,
471 .sector_size = 8192,
472 .page_size = 512,
473 },
474 /* .bank[1] = {*/
475 {
476 .present = 0,
477 .probed = 0,
478 .bank_number = 1,
479
480 },
481 },
482 },
483
484 /* Start at91sam4n* series */
485 /*atsam4n8a - LQFP48/QFN48*/
486 {
487 .chipid_cidr = 0x293B0AE0,
488 .name = "at91sam4n8a",
489 .total_flash_size = 512 * 1024,
490 .total_sram_size = 64 * 1024,
491 .n_gpnvms = 2,
492 .n_banks = 1,
493 {
494 /* .bank[0] = {*/
495 {
496 .probed = 0,
497 .pChip = NULL,
498 .pBank = NULL,
499 .bank_number = 0,
500 .base_address = FLASH_BANK_BASE_S,
501 .controller_address = 0x400e0a00,
502 .flash_wait_states = 5,
503 .present = 1,
504 .size_bytes = 512 * 1024,
505 .nsectors = 64,
506 .sector_size = 8192,
507 .page_size = 512,
508 },
509 /* .bank[1] = {*/
510 {
511 .present = 0,
512 .probed = 0,
513 .bank_number = 1,
514
515 },
516 },
517 },
518 /*atsam4n8b - LQFP64/QFN64*/
519 {
520 .chipid_cidr = 0x294B0AE0,
521 .name = "at91sam4n8b",
522 .total_flash_size = 512 * 1024,
523 .total_sram_size = 64 * 1024,
524 .n_gpnvms = 2,
525 .n_banks = 1,
526 {
527 /* .bank[0] = {*/
528 {
529 .probed = 0,
530 .pChip = NULL,
531 .pBank = NULL,
532 .bank_number = 0,
533 .base_address = FLASH_BANK_BASE_S,
534 .controller_address = 0x400e0a00,
535 .flash_wait_states = 5,
536 .present = 1,
537 .size_bytes = 512 * 1024,
538 .nsectors = 64,
539 .sector_size = 8192,
540 .page_size = 512,
541 },
542 /* .bank[1] = {*/
543 {
544 .present = 0,
545 .probed = 0,
546 .bank_number = 1,
547
548 },
549 },
550 },
551 /*atsam4n8c - LQFP100/TFBGA100/VFBGA100*/
552 {
553 .chipid_cidr = 0x295B0AE0,
554 .name = "at91sam4n8c",
555 .total_flash_size = 512 * 1024,
556 .total_sram_size = 64 * 1024,
557 .n_gpnvms = 2,
558 .n_banks = 1,
559 {
560 /* .bank[0] = {*/
561 {
562 .probed = 0,
563 .pChip = NULL,
564 .pBank = NULL,
565 .bank_number = 0,
566 .base_address = FLASH_BANK_BASE_S,
567 .controller_address = 0x400e0a00,
568 .flash_wait_states = 5,
569 .present = 1,
570 .size_bytes = 512 * 1024,
571 .nsectors = 64,
572 .sector_size = 8192,
573 .page_size = 512,
574 },
575 /* .bank[1] = {*/
576 {
577 .present = 0,
578 .probed = 0,
579 .bank_number = 1,
580
581 },
582 },
583 },
584 /*atsam4n16b - LQFP64/QFN64*/
585 {
586 .chipid_cidr = 0x29460CE0,
587 .name = "at91sam4n16b",
588 .total_flash_size = 1024 * 1024,
589 .total_sram_size = 80 * 1024,
590 .n_gpnvms = 2,
591 .n_banks = 1,
592 {
593 /* .bank[0] = {*/
594 {
595 .probed = 0,
596 .pChip = NULL,
597 .pBank = NULL,
598 .bank_number = 0,
599 .base_address = FLASH_BANK_BASE_S,
600 .controller_address = 0x400e0a00,
601 .flash_wait_states = 5,
602 .present = 1,
603 .size_bytes = 1024 * 1024,
604 .nsectors = 128,
605 .sector_size = 8192,
606 .page_size = 512,
607 },
608 /* .bank[1] = {*/
609 {
610 .present = 0,
611 .probed = 0,
612 .bank_number = 1,
613
614 },
615 },
616 },
617 /*atsam4n16c - LQFP100/TFBGA100/VFBGA100*/
618 {
619 .chipid_cidr = 0x29560CE0,
620 .name = "at91sam4n16c",
621 .total_flash_size = 1024 * 1024,
622 .total_sram_size = 80 * 1024,
623 .n_gpnvms = 2,
624 .n_banks = 1,
625 {
626 /* .bank[0] = {*/
627 {
628 .probed = 0,
629 .pChip = NULL,
630 .pBank = NULL,
631 .bank_number = 0,
632 .base_address = FLASH_BANK_BASE_S,
633 .controller_address = 0x400e0a00,
634 .flash_wait_states = 5,
635 .present = 1,
636 .size_bytes = 1024 * 1024,
637 .nsectors = 128,
638 .sector_size = 8192,
639 .page_size = 512,
640 },
641 /* .bank[1] = {*/
642 {
643 .present = 0,
644 .probed = 0,
645 .bank_number = 1,
646
647 },
648 },
649 },
650
651 /* Start at91sam4s* series */
652 /*atsam4s16c - LQFP100/BGA100*/
653 {
654 .chipid_cidr = 0x28AC0CE0,
655 .name = "at91sam4s16c",
656 .total_flash_size = 1024 * 1024,
657 .total_sram_size = 128 * 1024,
658 .n_gpnvms = 2,
659 .n_banks = 1,
660 {
661 /* .bank[0] = {*/
662 {
663 .probed = 0,
664 .pChip = NULL,
665 .pBank = NULL,
666 .bank_number = 0,
667 .base_address = FLASH_BANK_BASE_S,
668 .controller_address = 0x400e0a00,
669 .flash_wait_states = 5,
670 .present = 1,
671 .size_bytes = 1024 * 1024,
672 .nsectors = 128,
673 .sector_size = 8192,
674 .page_size = 512,
675 },
676 /* .bank[1] = {*/
677 {
678 .present = 0,
679 .probed = 0,
680 .bank_number = 1,
681
682 },
683 },
684 },
685 /*atsam4s16b - LQFP64/QFN64/WLCSP64*/
686 {
687 .chipid_cidr = 0x289C0CE0,
688 .name = "at91sam4s16b",
689 .total_flash_size = 1024 * 1024,
690 .total_sram_size = 128 * 1024,
691 .n_gpnvms = 2,
692 .n_banks = 1,
693 {
694 /* .bank[0] = {*/
695 {
696 .probed = 0,
697 .pChip = NULL,
698 .pBank = NULL,
699 .bank_number = 0,
700 .base_address = FLASH_BANK_BASE_S,
701 .controller_address = 0x400e0a00,
702 .flash_wait_states = 5,
703 .present = 1,
704 .size_bytes = 1024 * 1024,
705 .nsectors = 128,
706 .sector_size = 8192,
707 .page_size = 512,
708 },
709 /* .bank[1] = {*/
710 {
711 .present = 0,
712 .probed = 0,
713 .bank_number = 1,
714
715 },
716 },
717 },
718 /*atsam4sa16b - LQFP64/QFN64*/
719 {
720 .chipid_cidr = 0x28970CE0,
721 .name = "at91sam4sa16b",
722 .total_flash_size = 1024 * 1024,
723 .total_sram_size = 160 * 1024,
724 .n_gpnvms = 2,
725 .n_banks = 1,
726 {
727 /* .bank[0] = {*/
728 {
729 .probed = 0,
730 .pChip = NULL,
731 .pBank = NULL,
732 .bank_number = 0,
733 .base_address = FLASH_BANK_BASE_S,
734 .controller_address = 0x400e0a00,
735 .flash_wait_states = 5,
736 .present = 1,
737 .size_bytes = 1024 * 1024,
738 .nsectors = 128,
739 .sector_size = 8192,
740 .page_size = 512,
741 },
742 /* .bank[1] = {*/
743 {
744 .present = 0,
745 .probed = 0,
746 .bank_number = 1,
747
748 },
749 },
750 },
751 /*atsam4s16a - LQFP48/QFN48*/
752 {
753 .chipid_cidr = 0x288C0CE0,
754 .name = "at91sam4s16a",
755 .total_flash_size = 1024 * 1024,
756 .total_sram_size = 128 * 1024,
757 .n_gpnvms = 2,
758 .n_banks = 1,
759 {
760 /* .bank[0] = {*/
761 {
762 .probed = 0,
763 .pChip = NULL,
764 .pBank = NULL,
765 .bank_number = 0,
766 .base_address = FLASH_BANK_BASE_S,
767 .controller_address = 0x400e0a00,
768 .flash_wait_states = 5,
769 .present = 1,
770 .size_bytes = 1024 * 1024,
771 .nsectors = 128,
772 .sector_size = 8192,
773 .page_size = 512,
774 },
775 /* .bank[1] = {*/
776 {
777 .present = 0,
778 .probed = 0,
779 .bank_number = 1,
780
781 },
782 },
783 },
784 /*atsam4s8c - LQFP100/BGA100*/
785 {
786 .chipid_cidr = 0x28AC0AE0,
787 .name = "at91sam4s8c",
788 .total_flash_size = 512 * 1024,
789 .total_sram_size = 128 * 1024,
790 .n_gpnvms = 2,
791 .n_banks = 1,
792 {
793 /* .bank[0] = {*/
794 {
795 .probed = 0,
796 .pChip = NULL,
797 .pBank = NULL,
798 .bank_number = 0,
799 .base_address = FLASH_BANK_BASE_S,
800 .controller_address = 0x400e0a00,
801 .flash_wait_states = 5,
802 .present = 1,
803 .size_bytes = 512 * 1024,
804 .nsectors = 64,
805 .sector_size = 8192,
806 .page_size = 512,
807 },
808 /* .bank[1] = {*/
809 {
810 .present = 0,
811 .probed = 0,
812 .bank_number = 1,
813
814 },
815 },
816 },
817 /*atsam4s8b - LQFP64/QFN64/WLCSP64*/
818 {
819 .chipid_cidr = 0x289C0AE0,
820 .name = "at91sam4s8b",
821 .total_flash_size = 512 * 1024,
822 .total_sram_size = 128 * 1024,
823 .n_gpnvms = 2,
824 .n_banks = 1,
825 {
826 /* .bank[0] = {*/
827 {
828 .probed = 0,
829 .pChip = NULL,
830 .pBank = NULL,
831 .bank_number = 0,
832 .base_address = FLASH_BANK_BASE_S,
833 .controller_address = 0x400e0a00,
834 .flash_wait_states = 5,
835 .present = 1,
836 .size_bytes = 512 * 1024,
837 .nsectors = 64,
838 .sector_size = 8192,
839 .page_size = 512,
840 },
841 /* .bank[1] = {*/
842 {
843 .present = 0,
844 .probed = 0,
845 .bank_number = 1,
846
847 },
848 },
849 },
850 /*atsam4s8a - LQFP48/BGA48*/
851 {
852 .chipid_cidr = 0x288C0AE0,
853 .name = "at91sam4s8a",
854 .total_flash_size = 512 * 1024,
855 .total_sram_size = 128 * 1024,
856 .n_gpnvms = 2,
857 .n_banks = 1,
858 {
859 /* .bank[0] = {*/
860 {
861 .probed = 0,
862 .pChip = NULL,
863 .pBank = NULL,
864 .bank_number = 0,
865 .base_address = FLASH_BANK_BASE_S,
866 .controller_address = 0x400e0a00,
867 .flash_wait_states = 5,
868 .present = 1,
869 .size_bytes = 512 * 1024,
870 .nsectors = 64,
871 .sector_size = 8192,
872 .page_size = 512,
873 },
874 /* .bank[1] = {*/
875 {
876 .present = 0,
877 .probed = 0,
878 .bank_number = 1,
879
880 },
881 },
882 },
883
884 /*atsam4s4c - LQFP100/BGA100*/
885 {
886 .chipid_cidr = 0x28ab09e0,
887 .name = "at91sam4s4c",
888 .total_flash_size = 256 * 1024,
889 .total_sram_size = 64 * 1024,
890 .n_gpnvms = 2,
891 .n_banks = 1,
892 {
893 /* .bank[0] = {*/
894 {
895 .probed = 0,
896 .pChip = NULL,
897 .pBank = NULL,
898 .bank_number = 0,
899 .base_address = FLASH_BANK_BASE_S,
900 .controller_address = 0x400e0a00,
901 .flash_wait_states = 5,
902 .present = 1,
903 .size_bytes = 256 * 1024,
904 .nsectors = 32,
905 .sector_size = 8192,
906 .page_size = 512,
907 },
908 /* .bank[1] = {*/
909 {
910 .present = 0,
911 .probed = 0,
912 .bank_number = 1,
913
914 },
915 },
916 },
917
918 /*atsam4s4b - LQFP64/QFN64/WLCSP64*/
919 {
920 .chipid_cidr = 0x289b09e0,
921 .name = "at91sam4s4b",
922 .total_flash_size = 256 * 1024,
923 .total_sram_size = 64 * 1024,
924 .n_gpnvms = 2,
925 .n_banks = 1,
926 {
927 /* .bank[0] = {*/
928 {
929 .probed = 0,
930 .pChip = NULL,
931 .pBank = NULL,
932 .bank_number = 0,
933 .base_address = FLASH_BANK_BASE_S,
934 .controller_address = 0x400e0a00,
935 .flash_wait_states = 5,
936 .present = 1,
937 .size_bytes = 256 * 1024,
938 .nsectors = 32,
939 .sector_size = 8192,
940 .page_size = 512,
941 },
942 /* .bank[1] = {*/
943 {
944 .present = 0,
945 .probed = 0,
946 .bank_number = 1,
947
948 },
949 },
950 },
951
952 /*atsam4s4a - LQFP48/QFN48*/
953 {
954 .chipid_cidr = 0x288b09e0,
955 .name = "at91sam4s4a",
956 .total_flash_size = 256 * 1024,
957 .total_sram_size = 64 * 1024,
958 .n_gpnvms = 2,
959 .n_banks = 1,
960 {
961 /* .bank[0] = {*/
962 {
963 .probed = 0,
964 .pChip = NULL,
965 .pBank = NULL,
966 .bank_number = 0,
967 .base_address = FLASH_BANK_BASE_S,
968 .controller_address = 0x400e0a00,
969 .flash_wait_states = 5,
970 .present = 1,
971 .size_bytes = 256 * 1024,
972 .nsectors = 32,
973 .sector_size = 8192,
974 .page_size = 512,
975 },
976 /* .bank[1] = {*/
977 {
978 .present = 0,
979 .probed = 0,
980 .bank_number = 1,
981
982 },
983 },
984 },
985
986 /*atsam4s2c - LQFP100/BGA100*/
987 {
988 .chipid_cidr = 0x28ab07e0,
989 .name = "at91sam4s2c",
990 .total_flash_size = 128 * 1024,
991 .total_sram_size = 64 * 1024,
992 .n_gpnvms = 2,
993 .n_banks = 1,
994 {
995 /* .bank[0] = {*/
996 {
997 .probed = 0,
998 .pChip = NULL,
999 .pBank = NULL,
1000 .bank_number = 0,
1001 .base_address = FLASH_BANK_BASE_S,
1002 .controller_address = 0x400e0a00,
1003 .flash_wait_states = 5,
1004 .present = 1,
1005 .size_bytes = 128 * 1024,
1006 .nsectors = 16,
1007 .sector_size = 8192,
1008 .page_size = 512,
1009 },
1010 /* .bank[1] = {*/
1011 {
1012 .present = 0,
1013 .probed = 0,
1014 .bank_number = 1,
1015
1016 },
1017 },
1018 },
1019
1020 /*atsam4s2b - LQPF64/QFN64/WLCSP64*/
1021 {
1022 .chipid_cidr = 0x289b07e0,
1023 .name = "at91sam4s2b",
1024 .total_flash_size = 128 * 1024,
1025 .total_sram_size = 64 * 1024,
1026 .n_gpnvms = 2,
1027 .n_banks = 1,
1028 {
1029 /* .bank[0] = {*/
1030 {
1031 .probed = 0,
1032 .pChip = NULL,
1033 .pBank = NULL,
1034 .bank_number = 0,
1035 .base_address = FLASH_BANK_BASE_S,
1036 .controller_address = 0x400e0a00,
1037 .flash_wait_states = 5,
1038 .present = 1,
1039 .size_bytes = 128 * 1024,
1040 .nsectors = 16,
1041 .sector_size = 8192,
1042 .page_size = 512,
1043 },
1044 /* .bank[1] = {*/
1045 {
1046 .present = 0,
1047 .probed = 0,
1048 .bank_number = 1,
1049
1050 },
1051 },
1052 },
1053
1054 /*atsam4s2a - LQFP48/QFN48*/
1055 {
1056 .chipid_cidr = 0x288b07e0,
1057 .name = "at91sam4s2a",
1058 .total_flash_size = 128 * 1024,
1059 .total_sram_size = 64 * 1024,
1060 .n_gpnvms = 2,
1061 .n_banks = 1,
1062 {
1063 /* .bank[0] = {*/
1064 {
1065 .probed = 0,
1066 .pChip = NULL,
1067 .pBank = NULL,
1068 .bank_number = 0,
1069 .base_address = FLASH_BANK_BASE_S,
1070 .controller_address = 0x400e0a00,
1071 .flash_wait_states = 5,
1072 .present = 1,
1073 .size_bytes = 128 * 1024,
1074 .nsectors = 16,
1075 .sector_size = 8192,
1076 .page_size = 512,
1077 },
1078 /* .bank[1] = {*/
1079 {
1080 .present = 0,
1081 .probed = 0,
1082 .bank_number = 1,
1083
1084 },
1085 },
1086 },
1087
1088 /*at91sam4sd32c - LQFP100/BGA100*/
1089 {
1090 .chipid_cidr = 0x29a70ee0,
1091 .name = "at91sam4sd32c",
1092 .total_flash_size = 2048 * 1024,
1093 .total_sram_size = 160 * 1024,
1094 .n_gpnvms = 3,
1095 .n_banks = 2,
1096
1097 /* .bank[0] = { */
1098 {
1099 {
1100 .probed = 0,
1101 .pChip = NULL,
1102 .pBank = NULL,
1103 .bank_number = 0,
1104 .base_address = FLASH_BANK0_BASE_SD,
1105 .controller_address = 0x400e0a00,
1106 .flash_wait_states = 5,
1107 .present = 1,
1108 .size_bytes = 1024 * 1024,
1109 .nsectors = 128,
1110 .sector_size = 8192,
1111 .page_size = 512,
1112 },
1113
1114 /* .bank[1] = { */
1115 {
1116 .probed = 0,
1117 .pChip = NULL,
1118 .pBank = NULL,
1119 .bank_number = 1,
1120 .base_address = FLASH_BANK1_BASE_2048K_SD,
1121 .controller_address = 0x400e0c00,
1122 .flash_wait_states = 5,
1123 .present = 1,
1124 .size_bytes = 1024 * 1024,
1125 .nsectors = 128,
1126 .sector_size = 8192,
1127 .page_size = 512,
1128 },
1129 },
1130 },
1131
1132 /*at91sam4sd32b - LQFP64/BGA64*/
1133 {
1134 .chipid_cidr = 0x29970ee0,
1135 .name = "at91sam4sd32b",
1136 .total_flash_size = 2048 * 1024,
1137 .total_sram_size = 160 * 1024,
1138 .n_gpnvms = 3,
1139 .n_banks = 2,
1140
1141 /* .bank[0] = { */
1142 {
1143 {
1144 .probed = 0,
1145 .pChip = NULL,
1146 .pBank = NULL,
1147 .bank_number = 0,
1148 .base_address = FLASH_BANK0_BASE_SD,
1149 .controller_address = 0x400e0a00,
1150 .flash_wait_states = 5,
1151 .present = 1,
1152 .size_bytes = 1024 * 1024,
1153 .nsectors = 128,
1154 .sector_size = 8192,
1155 .page_size = 512,
1156 },
1157
1158 /* .bank[1] = { */
1159 {
1160 .probed = 0,
1161 .pChip = NULL,
1162 .pBank = NULL,
1163 .bank_number = 1,
1164 .base_address = FLASH_BANK1_BASE_2048K_SD,
1165 .controller_address = 0x400e0c00,
1166 .flash_wait_states = 5,
1167 .present = 1,
1168 .size_bytes = 1024 * 1024,
1169 .nsectors = 128,
1170 .sector_size = 8192,
1171 .page_size = 512,
1172 },
1173 },
1174 },
1175
1176 /*at91sam4sd16c - LQFP100/BGA100*/
1177 {
1178 .chipid_cidr = 0x29a70ce0,
1179 .name = "at91sam4sd16c",
1180 .total_flash_size = 1024 * 1024,
1181 .total_sram_size = 160 * 1024,
1182 .n_gpnvms = 3,
1183 .n_banks = 2,
1184
1185 /* .bank[0] = { */
1186 {
1187 {
1188 .probed = 0,
1189 .pChip = NULL,
1190 .pBank = NULL,
1191 .bank_number = 0,
1192 .base_address = FLASH_BANK0_BASE_SD,
1193 .controller_address = 0x400e0a00,
1194 .flash_wait_states = 5,
1195 .present = 1,
1196 .size_bytes = 512 * 1024,
1197 .nsectors = 64,
1198 .sector_size = 8192,
1199 .page_size = 512,
1200 },
1201
1202 /* .bank[1] = { */
1203 {
1204 .probed = 0,
1205 .pChip = NULL,
1206 .pBank = NULL,
1207 .bank_number = 1,
1208 .base_address = FLASH_BANK1_BASE_1024K_SD,
1209 .controller_address = 0x400e0c00,
1210 .flash_wait_states = 5,
1211 .present = 1,
1212 .size_bytes = 512 * 1024,
1213 .nsectors = 64,
1214 .sector_size = 8192,
1215 .page_size = 512,
1216 },
1217 },
1218 },
1219
1220 /*at91sam4sd16b - LQFP64/BGA64*/
1221 {
1222 .chipid_cidr = 0x29970ce0,
1223 .name = "at91sam4sd16b",
1224 .total_flash_size = 1024 * 1024,
1225 .total_sram_size = 160 * 1024,
1226 .n_gpnvms = 3,
1227 .n_banks = 2,
1228
1229 /* .bank[0] = { */
1230 {
1231 {
1232 .probed = 0,
1233 .pChip = NULL,
1234 .pBank = NULL,
1235 .bank_number = 0,
1236 .base_address = FLASH_BANK0_BASE_SD,
1237 .controller_address = 0x400e0a00,
1238 .flash_wait_states = 5,
1239 .present = 1,
1240 .size_bytes = 512 * 1024,
1241 .nsectors = 64,
1242 .sector_size = 8192,
1243 .page_size = 512,
1244 },
1245
1246 /* .bank[1] = { */
1247 {
1248 .probed = 0,
1249 .pChip = NULL,
1250 .pBank = NULL,
1251 .bank_number = 1,
1252 .base_address = FLASH_BANK1_BASE_1024K_SD,
1253 .controller_address = 0x400e0c00,
1254 .flash_wait_states = 5,
1255 .present = 1,
1256 .size_bytes = 512 * 1024,
1257 .nsectors = 64,
1258 .sector_size = 8192,
1259 .page_size = 512,
1260 },
1261 },
1262 },
1263
1264 /*at91sam4sa16c*/
1265 {
1266 .chipid_cidr = 0x28a70ce0,
1267 .name = "at91sam4sa16c",
1268 .total_flash_size = 1024 * 1024,
1269 .total_sram_size = 160 * 1024,
1270 .n_gpnvms = 3,
1271 .n_banks = 2,
1272
1273 /* .bank[0] = { */
1274 {
1275 {
1276 .probed = 0,
1277 .pChip = NULL,
1278 .pBank = NULL,
1279 .bank_number = 0,
1280 .base_address = FLASH_BANK0_BASE_SD,
1281 .controller_address = 0x400e0a00,
1282 .flash_wait_states = 5,
1283 .present = 1,
1284 .size_bytes = 512 * 1024,
1285 .nsectors = 64,
1286 .sector_size = 8192,
1287 .page_size = 512,
1288 },
1289
1290 /* .bank[1] = { */
1291 {
1292 .probed = 0,
1293 .pChip = NULL,
1294 .pBank = NULL,
1295 .bank_number = 1,
1296 .base_address = FLASH_BANK1_BASE_1024K_SD,
1297 .controller_address = 0x400e0c00,
1298 .flash_wait_states = 5,
1299 .present = 1,
1300 .size_bytes = 512 * 1024,
1301 .nsectors = 64,
1302 .sector_size = 8192,
1303 .page_size = 512,
1304 },
1305 },
1306 },
1307
1308 /* atsamg53n19 */
1309 {
1310 .chipid_cidr = 0x247e0ae0,
1311 .name = "atsamg53n19",
1312 .total_flash_size = 512 * 1024,
1313 .total_sram_size = 96 * 1024,
1314 .n_gpnvms = 2,
1315 .n_banks = 1,
1316
1317 /* .bank[0] = {*/
1318 {
1319 {
1320 .probed = 0,
1321 .pChip = NULL,
1322 .pBank = NULL,
1323 .bank_number = 0,
1324 .base_address = FLASH_BANK_BASE_S,
1325 .controller_address = 0x400e0a00,
1326 .flash_wait_states = 5,
1327 .present = 1,
1328 .size_bytes = 512 * 1024,
1329 .nsectors = 64,
1330 .sector_size = 8192,
1331 .page_size = 512,
1332 },
1333 /* .bank[1] = {*/
1334 {
1335 .present = 0,
1336 .probed = 0,
1337 .bank_number = 1,
1338
1339 },
1340 }
1341 },
1342
1343 /* atsamg55g19 */
1344 {
1345 .chipid_cidr = 0x24470ae0,
1346 .name = "atsamg55g19",
1347 .total_flash_size = 512 * 1024,
1348 .total_sram_size = 160 * 1024,
1349 .n_gpnvms = 2,
1350 .n_banks = 1,
1351
1352 {
1353 /* .bank[0] = */
1354 {
1355 .probed = 0,
1356 .pChip = NULL,
1357 .pBank = NULL,
1358 .bank_number = 0,
1359 .base_address = FLASH_BANK_BASE_S,
1360 .controller_address = 0x400e0a00,
1361 .flash_wait_states = 5,
1362 .present = 1,
1363 .size_bytes = 512 * 1024,
1364 .nsectors = 64,
1365 .sector_size = 8192,
1366 .page_size = 512,
1367 },
1368 /* .bank[1] = */
1369 {
1370 .present = 0,
1371 .probed = 0,
1372 .bank_number = 1,
1373 },
1374 }
1375 },
1376
1377 /* atsamg55j19 */
1378 {
1379 .chipid_cidr = 0x24570ae0,
1380 .name = "atsamg55j19",
1381 .total_flash_size = 512 * 1024,
1382 .total_sram_size = 160 * 1024,
1383 .n_gpnvms = 2,
1384 .n_banks = 1,
1385
1386 {
1387 /* .bank[0] = */
1388 {
1389 .probed = 0,
1390 .pChip = NULL,
1391 .pBank = NULL,
1392 .bank_number = 0,
1393 .base_address = FLASH_BANK_BASE_S,
1394 .controller_address = 0x400e0a00,
1395 .flash_wait_states = 5,
1396 .present = 1,
1397 .size_bytes = 512 * 1024,
1398 .nsectors = 64,
1399 .sector_size = 8192,
1400 .page_size = 512,
1401 },
1402 /* .bank[1] = */
1403 {
1404 .present = 0,
1405 .probed = 0,
1406 .bank_number = 1,
1407 },
1408 }
1409 },
1410
1411 /* terminate */
1412 {
1413 .chipid_cidr = 0,
1414 .name = NULL,
1415 }
1416 };
1417
1418 /* Globals above */
1419 /***********************************************************************
1420 **********************************************************************
1421 **********************************************************************
1422 **********************************************************************
1423 **********************************************************************
1424 **********************************************************************/
1425 /* *ATMEL* style code - from the SAM4 driver code */
1426
1427 /**
1428 * Get the current status of the EEFC and
1429 * the value of some status bits (LOCKE, PROGE).
1430 * @param pPrivate - info about the bank
1431 * @param v - result goes here
1432 */
1433 static int EFC_GetStatus(struct sam4_bank_private *pPrivate, uint32_t *v)
1434 {
1435 int r;
1436 r = target_read_u32(pPrivate->pChip->target,
1437 pPrivate->controller_address + offset_EFC_FSR,
1438 v);
1439 LOG_DEBUG("Status: 0x%08x (lockerror: %d, cmderror: %d, ready: %d)",
1440 (unsigned int)(*v),
1441 ((unsigned int)((*v >> 2) & 1)),
1442 ((unsigned int)((*v >> 1) & 1)),
1443 ((unsigned int)((*v >> 0) & 1)));
1444
1445 return r;
1446 }
1447
1448 /**
1449 * Get the result of the last executed command.
1450 * @param pPrivate - info about the bank
1451 * @param v - result goes here
1452 */
1453 static int EFC_GetResult(struct sam4_bank_private *pPrivate, uint32_t *v)
1454 {
1455 int r;
1456 uint32_t rv;
1457 r = target_read_u32(pPrivate->pChip->target,
1458 pPrivate->controller_address + offset_EFC_FRR,
1459 &rv);
1460 if (v)
1461 *v = rv;
1462 LOG_DEBUG("Result: 0x%08x", ((unsigned int)(rv)));
1463 return r;
1464 }
1465
1466 static int EFC_StartCommand(struct sam4_bank_private *pPrivate,
1467 unsigned command, unsigned argument)
1468 {
1469 uint32_t n, v;
1470 int r;
1471 int retry;
1472
1473 retry = 0;
1474 do_retry:
1475
1476 /* Check command & argument */
1477 switch (command) {
1478
1479 case AT91C_EFC_FCMD_WP:
1480 case AT91C_EFC_FCMD_WPL:
1481 case AT91C_EFC_FCMD_EWP:
1482 case AT91C_EFC_FCMD_EWPL:
1483 /* case AT91C_EFC_FCMD_EPL: */
1484 case AT91C_EFC_FCMD_EPA:
1485 case AT91C_EFC_FCMD_SLB:
1486 case AT91C_EFC_FCMD_CLB:
1487 n = (pPrivate->size_bytes / pPrivate->page_size);
1488 if (argument >= n)
1489 LOG_ERROR("*BUG*: Embedded flash has only %u pages", (unsigned)(n));
1490 break;
1491
1492 case AT91C_EFC_FCMD_SFB:
1493 case AT91C_EFC_FCMD_CFB:
1494 if (argument >= pPrivate->pChip->details.n_gpnvms) {
1495 LOG_ERROR("*BUG*: Embedded flash has only %d GPNVMs",
1496 pPrivate->pChip->details.n_gpnvms);
1497 }
1498 break;
1499
1500 case AT91C_EFC_FCMD_GETD:
1501 case AT91C_EFC_FCMD_EA:
1502 case AT91C_EFC_FCMD_GLB:
1503 case AT91C_EFC_FCMD_GFB:
1504 case AT91C_EFC_FCMD_STUI:
1505 case AT91C_EFC_FCMD_SPUI:
1506 if (argument != 0)
1507 LOG_ERROR("Argument is meaningless for cmd: %d", command);
1508 break;
1509 default:
1510 LOG_ERROR("Unknown command %d", command);
1511 break;
1512 }
1513
1514 if (command == AT91C_EFC_FCMD_SPUI) {
1515 /* this is a very special situation. */
1516 /* Situation (1) - error/retry - see below */
1517 /* And we are being called recursively */
1518 /* Situation (2) - normal, finished reading unique id */
1519 } else {
1520 /* it should be "ready" */
1521 EFC_GetStatus(pPrivate, &v);
1522 if (v & 1) {
1523 /* then it is ready */
1524 /* we go on */
1525 } else {
1526 if (retry) {
1527 /* we have done this before */
1528 /* the controller is not responding. */
1529 LOG_ERROR("flash controller(%d) is not ready! Error",
1530 pPrivate->bank_number);
1531 return ERROR_FAIL;
1532 } else {
1533 retry++;
1534 LOG_ERROR("Flash controller(%d) is not ready, attempting reset",
1535 pPrivate->bank_number);
1536 /* we do that by issuing the *STOP* command */
1537 EFC_StartCommand(pPrivate, AT91C_EFC_FCMD_SPUI, 0);
1538 /* above is recursive, and further recursion is blocked by */
1539 /* if (command == AT91C_EFC_FCMD_SPUI) above */
1540 goto do_retry;
1541 }
1542 }
1543 }
1544
1545 v = (0x5A << 24) | (argument << 8) | command;
1546 LOG_DEBUG("Command: 0x%08x", ((unsigned int)(v)));
1547 r = target_write_u32(pPrivate->pBank->target,
1548 pPrivate->controller_address + offset_EFC_FCR, v);
1549 if (r != ERROR_OK)
1550 LOG_DEBUG("Error Write failed");
1551 return r;
1552 }
1553
1554 /**
1555 * Performs the given command and wait until its completion (or an error).
1556 * @param pPrivate - info about the bank
1557 * @param command - Command to perform.
1558 * @param argument - Optional command argument.
1559 * @param status - put command status bits here
1560 */
1561 static int EFC_PerformCommand(struct sam4_bank_private *pPrivate,
1562 unsigned command,
1563 unsigned argument,
1564 uint32_t *status)
1565 {
1566
1567 int r;
1568 uint32_t v;
1569 int64_t ms_now, ms_end;
1570
1571 /* default */
1572 if (status)
1573 *status = 0;
1574
1575 r = EFC_StartCommand(pPrivate, command, argument);
1576 if (r != ERROR_OK)
1577 return r;
1578
1579 ms_end = 10000 + timeval_ms();
1580
1581 do {
1582 r = EFC_GetStatus(pPrivate, &v);
1583 if (r != ERROR_OK)
1584 return r;
1585 ms_now = timeval_ms();
1586 if (ms_now > ms_end) {
1587 /* error */
1588 LOG_ERROR("Command timeout");
1589 return ERROR_FAIL;
1590 }
1591 } while ((v & 1) == 0);
1592
1593 /* error bits.. */
1594 if (status)
1595 *status = (v & 0x6);
1596 return ERROR_OK;
1597
1598 }
1599
1600 /**
1601 * Read the unique ID.
1602 * @param pPrivate - info about the bank
1603 * The unique ID is stored in the 'pPrivate' structure.
1604 */
1605 static int FLASHD_ReadUniqueID(struct sam4_bank_private *pPrivate)
1606 {
1607 int r;
1608 uint32_t v;
1609 int x;
1610 /* assume 0 */
1611 pPrivate->pChip->cfg.unique_id[0] = 0;
1612 pPrivate->pChip->cfg.unique_id[1] = 0;
1613 pPrivate->pChip->cfg.unique_id[2] = 0;
1614 pPrivate->pChip->cfg.unique_id[3] = 0;
1615
1616 LOG_DEBUG("Begin");
1617 r = EFC_StartCommand(pPrivate, AT91C_EFC_FCMD_STUI, 0);
1618 if (r < 0)
1619 return r;
1620
1621 for (x = 0; x < 4; x++) {
1622 r = target_read_u32(pPrivate->pChip->target,
1623 pPrivate->pBank->base + (x * 4),
1624 &v);
1625 if (r < 0)
1626 return r;
1627 pPrivate->pChip->cfg.unique_id[x] = v;
1628 }
1629
1630 r = EFC_PerformCommand(pPrivate, AT91C_EFC_FCMD_SPUI, 0, NULL);
1631 LOG_DEBUG("End: R=%d, id = 0x%08x, 0x%08x, 0x%08x, 0x%08x",
1632 r,
1633 (unsigned int)(pPrivate->pChip->cfg.unique_id[0]),
1634 (unsigned int)(pPrivate->pChip->cfg.unique_id[1]),
1635 (unsigned int)(pPrivate->pChip->cfg.unique_id[2]),
1636 (unsigned int)(pPrivate->pChip->cfg.unique_id[3]));
1637 return r;
1638
1639 }
1640
1641 /**
1642 * Erases the entire flash.
1643 * @param pPrivate - the info about the bank.
1644 */
1645 static int FLASHD_EraseEntireBank(struct sam4_bank_private *pPrivate)
1646 {
1647 LOG_DEBUG("Here");
1648 return EFC_PerformCommand(pPrivate, AT91C_EFC_FCMD_EA, 0, NULL);
1649 }
1650
1651 /**
1652 * Erases the entire flash.
1653 * @param pPrivate - the info about the bank.
1654 */
1655 static int FLASHD_ErasePages(struct sam4_bank_private *pPrivate,
1656 int firstPage,
1657 int numPages,
1658 uint32_t *status)
1659 {
1660 LOG_DEBUG("Here");
1661 uint8_t erasePages;
1662 switch (numPages) {
1663 case 4:
1664 erasePages = 0x00;
1665 break;
1666 case 8:
1667 erasePages = 0x01;
1668 break;
1669 case 16:
1670 erasePages = 0x02;
1671 break;
1672 case 32:
1673 erasePages = 0x03;
1674 break;
1675 default:
1676 erasePages = 0x00;
1677 break;
1678 }
1679
1680 /* AT91C_EFC_FCMD_EPA
1681 * According to the datasheet FARG[15:2] defines the page from which
1682 * the erase will start.This page must be modulo 4, 8, 16 or 32
1683 * according to the number of pages to erase. FARG[1:0] defines the
1684 * number of pages to be erased. Previously (firstpage << 2) was used
1685 * to conform to this, seems it should not be shifted...
1686 */
1687 return EFC_PerformCommand(pPrivate,
1688 /* send Erase Page */
1689 AT91C_EFC_FCMD_EPA,
1690 (firstPage) | erasePages,
1691 status);
1692 }
1693
1694 /**
1695 * Gets current GPNVM state.
1696 * @param pPrivate - info about the bank.
1697 * @param gpnvm - GPNVM bit index.
1698 * @param puthere - result stored here.
1699 */
1700 /* ------------------------------------------------------------------------------ */
1701 static int FLASHD_GetGPNVM(struct sam4_bank_private *pPrivate, unsigned gpnvm, unsigned *puthere)
1702 {
1703 uint32_t v;
1704 int r;
1705
1706 LOG_DEBUG("Here");
1707 if (pPrivate->bank_number != 0) {
1708 LOG_ERROR("GPNVM only works with Bank0");
1709 return ERROR_FAIL;
1710 }
1711
1712 if (gpnvm >= pPrivate->pChip->details.n_gpnvms) {
1713 LOG_ERROR("Invalid GPNVM %d, max: %d, ignored",
1714 gpnvm, pPrivate->pChip->details.n_gpnvms);
1715 return ERROR_FAIL;
1716 }
1717
1718 /* Get GPNVMs status */
1719 r = EFC_PerformCommand(pPrivate, AT91C_EFC_FCMD_GFB, 0, NULL);
1720 if (r != ERROR_OK) {
1721 LOG_ERROR("Failed");
1722 return r;
1723 }
1724
1725 r = EFC_GetResult(pPrivate, &v);
1726
1727 if (puthere) {
1728 /* Check if GPNVM is set */
1729 /* get the bit and make it a 0/1 */
1730 *puthere = (v >> gpnvm) & 1;
1731 }
1732
1733 return r;
1734 }
1735
1736 /**
1737 * Clears the selected GPNVM bit.
1738 * @param pPrivate info about the bank
1739 * @param gpnvm GPNVM index.
1740 * @returns 0 if successful; otherwise returns an error code.
1741 */
1742 static int FLASHD_ClrGPNVM(struct sam4_bank_private *pPrivate, unsigned gpnvm)
1743 {
1744 int r;
1745 unsigned v;
1746
1747 LOG_DEBUG("Here");
1748 if (pPrivate->bank_number != 0) {
1749 LOG_ERROR("GPNVM only works with Bank0");
1750 return ERROR_FAIL;
1751 }
1752
1753 if (gpnvm >= pPrivate->pChip->details.n_gpnvms) {
1754 LOG_ERROR("Invalid GPNVM %d, max: %d, ignored",
1755 gpnvm, pPrivate->pChip->details.n_gpnvms);
1756 return ERROR_FAIL;
1757 }
1758
1759 r = FLASHD_GetGPNVM(pPrivate, gpnvm, &v);
1760 if (r != ERROR_OK) {
1761 LOG_DEBUG("Failed: %d", r);
1762 return r;
1763 }
1764 r = EFC_PerformCommand(pPrivate, AT91C_EFC_FCMD_CFB, gpnvm, NULL);
1765 LOG_DEBUG("End: %d", r);
1766 return r;
1767 }
1768
1769 /**
1770 * Sets the selected GPNVM bit.
1771 * @param pPrivate info about the bank
1772 * @param gpnvm GPNVM index.
1773 */
1774 static int FLASHD_SetGPNVM(struct sam4_bank_private *pPrivate, unsigned gpnvm)
1775 {
1776 int r;
1777 unsigned v;
1778
1779 if (pPrivate->bank_number != 0) {
1780 LOG_ERROR("GPNVM only works with Bank0");
1781 return ERROR_FAIL;
1782 }
1783
1784 if (gpnvm >= pPrivate->pChip->details.n_gpnvms) {
1785 LOG_ERROR("Invalid GPNVM %d, max: %d, ignored",
1786 gpnvm, pPrivate->pChip->details.n_gpnvms);
1787 return ERROR_FAIL;
1788 }
1789
1790 r = FLASHD_GetGPNVM(pPrivate, gpnvm, &v);
1791 if (r != ERROR_OK)
1792 return r;
1793 if (v) {
1794 /* already set */
1795 r = ERROR_OK;
1796 } else {
1797 /* set it */
1798 r = EFC_PerformCommand(pPrivate, AT91C_EFC_FCMD_SFB, gpnvm, NULL);
1799 }
1800 return r;
1801 }
1802
1803 /**
1804 * Returns a bit field (at most 64) of locked regions within a page.
1805 * @param pPrivate info about the bank
1806 * @param v where to store locked bits
1807 */
1808 static int FLASHD_GetLockBits(struct sam4_bank_private *pPrivate, uint32_t *v)
1809 {
1810 int r;
1811 LOG_DEBUG("Here");
1812 r = EFC_PerformCommand(pPrivate, AT91C_EFC_FCMD_GLB, 0, NULL);
1813 if (r == ERROR_OK) {
1814 EFC_GetResult(pPrivate, v);
1815 EFC_GetResult(pPrivate, v);
1816 EFC_GetResult(pPrivate, v);
1817 r = EFC_GetResult(pPrivate, v);
1818 }
1819 LOG_DEBUG("End: %d", r);
1820 return r;
1821 }
1822
1823 /**
1824 * Unlocks all the regions in the given address range.
1825 * @param pPrivate info about the bank
1826 * @param start_sector first sector to unlock
1827 * @param end_sector last (inclusive) to unlock
1828 */
1829
1830 static int FLASHD_Unlock(struct sam4_bank_private *pPrivate,
1831 unsigned start_sector,
1832 unsigned end_sector)
1833 {
1834 int r;
1835 uint32_t status;
1836 uint32_t pg;
1837 uint32_t pages_per_sector;
1838
1839 pages_per_sector = pPrivate->sector_size / pPrivate->page_size;
1840
1841 /* Unlock all pages */
1842 while (start_sector <= end_sector) {
1843 pg = start_sector * pages_per_sector;
1844
1845 r = EFC_PerformCommand(pPrivate, AT91C_EFC_FCMD_CLB, pg, &status);
1846 if (r != ERROR_OK)
1847 return r;
1848 start_sector++;
1849 }
1850
1851 return ERROR_OK;
1852 }
1853
1854 /**
1855 * Locks regions
1856 * @param pPrivate - info about the bank
1857 * @param start_sector - first sector to lock
1858 * @param end_sector - last sector (inclusive) to lock
1859 */
1860 static int FLASHD_Lock(struct sam4_bank_private *pPrivate,
1861 unsigned start_sector,
1862 unsigned end_sector)
1863 {
1864 uint32_t status;
1865 uint32_t pg;
1866 uint32_t pages_per_sector;
1867 int r;
1868
1869 pages_per_sector = pPrivate->sector_size / pPrivate->page_size;
1870
1871 /* Lock all pages */
1872 while (start_sector <= end_sector) {
1873 pg = start_sector * pages_per_sector;
1874
1875 r = EFC_PerformCommand(pPrivate, AT91C_EFC_FCMD_SLB, pg, &status);
1876 if (r != ERROR_OK)
1877 return r;
1878 start_sector++;
1879 }
1880 return ERROR_OK;
1881 }
1882
1883 /****** END SAM4 CODE ********/
1884
1885 /* begin helpful debug code */
1886 /* print the fieldname, the field value, in dec & hex, and return field value */
1887 static uint32_t sam4_reg_fieldname(struct sam4_chip *pChip,
1888 const char *regname,
1889 uint32_t value,
1890 unsigned shift,
1891 unsigned width)
1892 {
1893 uint32_t v;
1894 int hwidth, dwidth;
1895
1896
1897 /* extract the field */
1898 v = value >> shift;
1899 v = v & ((1 << width)-1);
1900 if (width <= 16) {
1901 hwidth = 4;
1902 dwidth = 5;
1903 } else {
1904 hwidth = 8;
1905 dwidth = 12;
1906 }
1907
1908 /* show the basics */
1909 LOG_USER_N("\t%*s: %*" PRId32 " [0x%0*" PRIx32 "] ",
1910 REG_NAME_WIDTH, regname,
1911 dwidth, v,
1912 hwidth, v);
1913 return v;
1914 }
1915
1916 static const char _unknown[] = "unknown";
1917 static const char *const eproc_names[] = {
1918 "Cortex-M7", /* 0 */
1919 "arm946es", /* 1 */
1920 "arm7tdmi", /* 2 */
1921 "Cortex-M3", /* 3 */
1922 "arm920t", /* 4 */
1923 "arm926ejs", /* 5 */
1924 "Cortex-A5", /* 6 */
1925 "Cortex-M4", /* 7 */
1926 _unknown, /* 8 */
1927 _unknown, /* 9 */
1928 _unknown, /* 10 */
1929 _unknown, /* 11 */
1930 _unknown, /* 12 */
1931 _unknown, /* 13 */
1932 _unknown, /* 14 */
1933 _unknown, /* 15 */
1934 };
1935
1936 #define nvpsize2 nvpsize /* these two tables are identical */
1937 static const char *const nvpsize[] = {
1938 "none", /* 0 */
1939 "8K bytes", /* 1 */
1940 "16K bytes", /* 2 */
1941 "32K bytes", /* 3 */
1942 _unknown, /* 4 */
1943 "64K bytes", /* 5 */
1944 _unknown, /* 6 */
1945 "128K bytes", /* 7 */
1946 "160K bytes", /* 8 */
1947 "256K bytes", /* 9 */
1948 "512K bytes", /* 10 */
1949 _unknown, /* 11 */
1950 "1024K bytes", /* 12 */
1951 _unknown, /* 13 */
1952 "2048K bytes", /* 14 */
1953 _unknown, /* 15 */
1954 };
1955
1956 static const char *const sramsize[] = {
1957 "48K Bytes", /* 0 */
1958 "1K Bytes", /* 1 */
1959 "2K Bytes", /* 2 */
1960 "6K Bytes", /* 3 */
1961 "112K Bytes", /* 4 */
1962 "4K Bytes", /* 5 */
1963 "80K Bytes", /* 6 */
1964 "160K Bytes", /* 7 */
1965 "8K Bytes", /* 8 */
1966 "16K Bytes", /* 9 */
1967 "32K Bytes", /* 10 */
1968 "64K Bytes", /* 11 */
1969 "128K Bytes", /* 12 */
1970 "256K Bytes", /* 13 */
1971 "96K Bytes", /* 14 */
1972 "512K Bytes", /* 15 */
1973
1974 };
1975
1976 static const struct archnames { unsigned value; const char *name; } archnames[] = {
1977 { 0x19, "AT91SAM9xx Series" },
1978 { 0x29, "AT91SAM9XExx Series" },
1979 { 0x34, "AT91x34 Series" },
1980 { 0x37, "CAP7 Series" },
1981 { 0x39, "CAP9 Series" },
1982 { 0x3B, "CAP11 Series" },
1983 { 0x3C, "ATSAM4E" },
1984 { 0x40, "AT91x40 Series" },
1985 { 0x42, "AT91x42 Series" },
1986 { 0x43, "SAMG51 Series"
1987 },
1988 { 0x44, "SAMG55 Series (49-pin WLCSP)" },
1989 { 0x45, "SAMG55 Series (64-pin)" },
1990 { 0x47, "SAMG53 Series"
1991 },
1992 { 0x55, "AT91x55 Series" },
1993 { 0x60, "AT91SAM7Axx Series" },
1994 { 0x61, "AT91SAM7AQxx Series" },
1995 { 0x63, "AT91x63 Series" },
1996 { 0x64, "SAM4CxxC (100-pin version)" },
1997 { 0x66, "SAM4CxxE (144-pin version)" },
1998 { 0x70, "AT91SAM7Sxx Series" },
1999 { 0x71, "AT91SAM7XCxx Series" },
2000 { 0x72, "AT91SAM7SExx Series" },
2001 { 0x73, "AT91SAM7Lxx Series" },
2002 { 0x75, "AT91SAM7Xxx Series" },
2003 { 0x76, "AT91SAM7SLxx Series" },
2004 { 0x80, "ATSAM3UxC Series (100-pin version)" },
2005 { 0x81, "ATSAM3UxE Series (144-pin version)" },
2006 { 0x83, "ATSAM3A/SAM4A xC Series (100-pin version)"},
2007 { 0x84, "ATSAM3X/SAM4X xC Series (100-pin version)"},
2008 { 0x85, "ATSAM3X/SAM4X xE Series (144-pin version)"},
2009 { 0x86, "ATSAM3X/SAM4X xG Series (208/217-pin version)" },
2010 { 0x88, "ATSAM3S/SAM4S xA Series (48-pin version)" },
2011 { 0x89, "ATSAM3S/SAM4S xB Series (64-pin version)" },
2012 { 0x8A, "ATSAM3S/SAM4S xC Series (100-pin version)"},
2013 { 0x92, "AT91x92 Series" },
2014 { 0x93, "ATSAM3NxA Series (48-pin version)" },
2015 { 0x94, "ATSAM3NxB Series (64-pin version)" },
2016 { 0x95, "ATSAM3NxC Series (100-pin version)" },
2017 { 0x98, "ATSAM3SDxA Series (48-pin version)" },
2018 { 0x99, "ATSAM3SDxB Series (64-pin version)" },
2019 { 0x9A, "ATSAM3SDxC Series (100-pin version)" },
2020 { 0xA5, "ATSAM5A" },
2021 { 0xF0, "AT75Cxx Series" },
2022 { -1, NULL },
2023 };
2024
2025 static const char *const nvptype[] = {
2026 "rom", /* 0 */
2027 "romless or onchip flash", /* 1 */
2028 "embedded flash memory",/* 2 */
2029 "rom(nvpsiz) + embedded flash (nvpsiz2)", /* 3 */
2030 "sram emulating flash", /* 4 */
2031 _unknown, /* 5 */
2032 _unknown, /* 6 */
2033 _unknown, /* 7 */
2034 };
2035
2036 static const char *_yes_or_no(uint32_t v)
2037 {
2038 if (v)
2039 return "YES";
2040 else
2041 return "NO";
2042 }
2043
2044 static const char *const _rc_freq[] = {
2045 "4 MHz", "8 MHz", "12 MHz", "reserved"
2046 };
2047
2048 static void sam4_explain_ckgr_mor(struct sam4_chip *pChip)
2049 {
2050 uint32_t v;
2051 uint32_t rcen;
2052
2053 v = sam4_reg_fieldname(pChip, "MOSCXTEN", pChip->cfg.CKGR_MOR, 0, 1);
2054 LOG_USER("(main xtal enabled: %s)", _yes_or_no(v));
2055 v = sam4_reg_fieldname(pChip, "MOSCXTBY", pChip->cfg.CKGR_MOR, 1, 1);
2056 LOG_USER("(main osc bypass: %s)", _yes_or_no(v));
2057 rcen = sam4_reg_fieldname(pChip, "MOSCRCEN", pChip->cfg.CKGR_MOR, 3, 1);
2058 LOG_USER("(onchip RC-OSC enabled: %s)", _yes_or_no(rcen));
2059 v = sam4_reg_fieldname(pChip, "MOSCRCF", pChip->cfg.CKGR_MOR, 4, 3);
2060 LOG_USER("(onchip RC-OSC freq: %s)", _rc_freq[v]);
2061
2062 pChip->cfg.rc_freq = 0;
2063 if (rcen) {
2064 switch (v) {
2065 default:
2066 pChip->cfg.rc_freq = 0;
2067 break;
2068 case 0:
2069 pChip->cfg.rc_freq = 4 * 1000 * 1000;
2070 break;
2071 case 1:
2072 pChip->cfg.rc_freq = 8 * 1000 * 1000;
2073 break;
2074 case 2:
2075 pChip->cfg.rc_freq = 12 * 1000 * 1000;
2076 break;
2077 }
2078 }
2079
2080 v = sam4_reg_fieldname(pChip, "MOSCXTST", pChip->cfg.CKGR_MOR, 8, 8);
2081 LOG_USER("(startup clks, time= %f uSecs)",
2082 ((float)(v * 1000000)) / ((float)(pChip->cfg.slow_freq)));
2083 v = sam4_reg_fieldname(pChip, "MOSCSEL", pChip->cfg.CKGR_MOR, 24, 1);
2084 LOG_USER("(mainosc source: %s)",
2085 v ? "external xtal" : "internal RC");
2086
2087 v = sam4_reg_fieldname(pChip, "CFDEN", pChip->cfg.CKGR_MOR, 25, 1);
2088 LOG_USER("(clock failure enabled: %s)",
2089 _yes_or_no(v));
2090 }
2091
2092 static void sam4_explain_chipid_cidr(struct sam4_chip *pChip)
2093 {
2094 int x;
2095 uint32_t v;
2096 const char *cp;
2097
2098 sam4_reg_fieldname(pChip, "Version", pChip->cfg.CHIPID_CIDR, 0, 5);
2099 LOG_USER_N("\n");
2100
2101 v = sam4_reg_fieldname(pChip, "EPROC", pChip->cfg.CHIPID_CIDR, 5, 3);
2102 LOG_USER("%s", eproc_names[v]);
2103
2104 v = sam4_reg_fieldname(pChip, "NVPSIZE", pChip->cfg.CHIPID_CIDR, 8, 4);
2105 LOG_USER("%s", nvpsize[v]);
2106
2107 v = sam4_reg_fieldname(pChip, "NVPSIZE2", pChip->cfg.CHIPID_CIDR, 12, 4);
2108 LOG_USER("%s", nvpsize2[v]);
2109
2110 v = sam4_reg_fieldname(pChip, "SRAMSIZE", pChip->cfg.CHIPID_CIDR, 16, 4);
2111 LOG_USER("%s", sramsize[v]);
2112
2113 v = sam4_reg_fieldname(pChip, "ARCH", pChip->cfg.CHIPID_CIDR, 20, 8);
2114 cp = _unknown;
2115 for (x = 0; archnames[x].name; x++) {
2116 if (v == archnames[x].value) {
2117 cp = archnames[x].name;
2118 break;
2119 }
2120 }
2121
2122 LOG_USER("%s", cp);
2123
2124 v = sam4_reg_fieldname(pChip, "NVPTYP", pChip->cfg.CHIPID_CIDR, 28, 3);
2125 LOG_USER("%s", nvptype[v]);
2126
2127 v = sam4_reg_fieldname(pChip, "EXTID", pChip->cfg.CHIPID_CIDR, 31, 1);
2128 LOG_USER("(exists: %s)", _yes_or_no(v));
2129 }
2130
2131 static void sam4_explain_ckgr_mcfr(struct sam4_chip *pChip)
2132 {
2133 uint32_t v;
2134
2135 v = sam4_reg_fieldname(pChip, "MAINFRDY", pChip->cfg.CKGR_MCFR, 16, 1);
2136 LOG_USER("(main ready: %s)", _yes_or_no(v));
2137
2138 v = sam4_reg_fieldname(pChip, "MAINF", pChip->cfg.CKGR_MCFR, 0, 16);
2139
2140 v = (v * pChip->cfg.slow_freq) / 16;
2141 pChip->cfg.mainosc_freq = v;
2142
2143 LOG_USER("(%3.03f Mhz (%" PRIu32 ".%03" PRIu32 "khz slowclk)",
2144 _tomhz(v),
2145 (uint32_t)(pChip->cfg.slow_freq / 1000),
2146 (uint32_t)(pChip->cfg.slow_freq % 1000));
2147 }
2148
2149 static void sam4_explain_ckgr_plla(struct sam4_chip *pChip)
2150 {
2151 uint32_t mula, diva;
2152
2153 diva = sam4_reg_fieldname(pChip, "DIVA", pChip->cfg.CKGR_PLLAR, 0, 8);
2154 LOG_USER_N("\n");
2155 mula = sam4_reg_fieldname(pChip, "MULA", pChip->cfg.CKGR_PLLAR, 16, 11);
2156 LOG_USER_N("\n");
2157 pChip->cfg.plla_freq = 0;
2158 if (mula == 0)
2159 LOG_USER("\tPLLA Freq: (Disabled,mula = 0)");
2160 else if (diva == 0)
2161 LOG_USER("\tPLLA Freq: (Disabled,diva = 0)");
2162 else if (diva >= 1) {
2163 pChip->cfg.plla_freq = (pChip->cfg.mainosc_freq * (mula + 1) / diva);
2164 LOG_USER("\tPLLA Freq: %3.03f MHz",
2165 _tomhz(pChip->cfg.plla_freq));
2166 }
2167 }
2168
2169 static void sam4_explain_mckr(struct sam4_chip *pChip)
2170 {
2171 uint32_t css, pres, fin = 0;
2172 int pdiv = 0;
2173 const char *cp = NULL;
2174
2175 css = sam4_reg_fieldname(pChip, "CSS", pChip->cfg.PMC_MCKR, 0, 2);
2176 switch (css & 3) {
2177 case 0:
2178 fin = pChip->cfg.slow_freq;
2179 cp = "slowclk";
2180 break;
2181 case 1:
2182 fin = pChip->cfg.mainosc_freq;
2183 cp = "mainosc";
2184 break;
2185 case 2:
2186 fin = pChip->cfg.plla_freq;
2187 cp = "plla";
2188 break;
2189 case 3:
2190 if (pChip->cfg.CKGR_UCKR & (1 << 16)) {
2191 fin = 480 * 1000 * 1000;
2192 cp = "upll";
2193 } else {
2194 fin = 0;
2195 cp = "upll (*ERROR* UPLL is disabled)";
2196 }
2197 break;
2198 default:
2199 assert(0);
2200 break;
2201 }
2202
2203 LOG_USER("%s (%3.03f Mhz)",
2204 cp,
2205 _tomhz(fin));
2206 pres = sam4_reg_fieldname(pChip, "PRES", pChip->cfg.PMC_MCKR, 4, 3);
2207 switch (pres & 0x07) {
2208 case 0:
2209 pdiv = 1;
2210 cp = "selected clock";
2211 break;
2212 case 1:
2213 pdiv = 2;
2214 cp = "clock/2";
2215 break;
2216 case 2:
2217 pdiv = 4;
2218 cp = "clock/4";
2219 break;
2220 case 3:
2221 pdiv = 8;
2222 cp = "clock/8";
2223 break;
2224 case 4:
2225 pdiv = 16;
2226 cp = "clock/16";
2227 break;
2228 case 5:
2229 pdiv = 32;
2230 cp = "clock/32";
2231 break;
2232 case 6:
2233 pdiv = 64;
2234 cp = "clock/64";
2235 break;
2236 case 7:
2237 pdiv = 6;
2238 cp = "clock/6";
2239 break;
2240 default:
2241 assert(0);
2242 break;
2243 }
2244 LOG_USER("(%s)", cp);
2245 fin = fin / pdiv;
2246 /* sam4 has a *SINGLE* clock - */
2247 /* other at91 series parts have divisors for these. */
2248 pChip->cfg.cpu_freq = fin;
2249 pChip->cfg.mclk_freq = fin;
2250 pChip->cfg.fclk_freq = fin;
2251 LOG_USER("\t\tResult CPU Freq: %3.03f",
2252 _tomhz(fin));
2253 }
2254
2255 #if 0
2256 static struct sam4_chip *target2sam4(struct target *pTarget)
2257 {
2258 struct sam4_chip *pChip;
2259
2260 if (pTarget == NULL)
2261 return NULL;
2262
2263 pChip = all_sam4_chips;
2264 while (pChip) {
2265 if (pChip->target == pTarget)
2266 break; /* return below */
2267 else
2268 pChip = pChip->next;
2269 }
2270 return pChip;
2271 }
2272 #endif
2273
2274 static uint32_t *sam4_get_reg_ptr(struct sam4_cfg *pCfg, const struct sam4_reg_list *pList)
2275 {
2276 /* this function exists to help */
2277 /* keep funky offsetof() errors */
2278 /* and casting from causing bugs */
2279
2280 /* By using prototypes - we can detect what would */
2281 /* be casting errors. */
2282
2283 return (uint32_t *)(void *)(((char *)(pCfg)) + pList->struct_offset);
2284 }
2285
2286
2287 #define SAM4_ENTRY(NAME, FUNC) { .address = SAM4_ ## NAME, .struct_offset = offsetof( \
2288 struct sam4_cfg, \
2289 NAME), # NAME, FUNC }
2290 static const struct sam4_reg_list sam4_all_regs[] = {
2291 SAM4_ENTRY(CKGR_MOR, sam4_explain_ckgr_mor),
2292 SAM4_ENTRY(CKGR_MCFR, sam4_explain_ckgr_mcfr),
2293 SAM4_ENTRY(CKGR_PLLAR, sam4_explain_ckgr_plla),
2294 SAM4_ENTRY(CKGR_UCKR, NULL),
2295 SAM4_ENTRY(PMC_FSMR, NULL),
2296 SAM4_ENTRY(PMC_FSPR, NULL),
2297 SAM4_ENTRY(PMC_IMR, NULL),
2298 SAM4_ENTRY(PMC_MCKR, sam4_explain_mckr),
2299 SAM4_ENTRY(PMC_PCK0, NULL),
2300 SAM4_ENTRY(PMC_PCK1, NULL),
2301 SAM4_ENTRY(PMC_PCK2, NULL),
2302 SAM4_ENTRY(PMC_PCSR, NULL),
2303 SAM4_ENTRY(PMC_SCSR, NULL),
2304 SAM4_ENTRY(PMC_SR, NULL),
2305 SAM4_ENTRY(CHIPID_CIDR, sam4_explain_chipid_cidr),
2306 SAM4_ENTRY(CHIPID_EXID, NULL),
2307 /* TERMINATE THE LIST */
2308 { .name = NULL }
2309 };
2310 #undef SAM4_ENTRY
2311
2312 static struct sam4_bank_private *get_sam4_bank_private(struct flash_bank *bank)
2313 {
2314 return bank->driver_priv;
2315 }
2316
2317 /**
2318 * Given a pointer to where it goes in the structure,
2319 * determine the register name, address from the all registers table.
2320 */
2321 static const struct sam4_reg_list *sam4_GetReg(struct sam4_chip *pChip, uint32_t *goes_here)
2322 {
2323 const struct sam4_reg_list *pReg;
2324
2325 pReg = &(sam4_all_regs[0]);
2326 while (pReg->name) {
2327 uint32_t *pPossible;
2328
2329 /* calculate where this one go.. */
2330 /* it is "possibly" this register. */
2331
2332 pPossible = ((uint32_t *)(void *)(((char *)(&(pChip->cfg))) + pReg->struct_offset));
2333
2334 /* well? Is it this register */
2335 if (pPossible == goes_here) {
2336 /* Jump for joy! */
2337 return pReg;
2338 }
2339
2340 /* next... */
2341 pReg++;
2342 }
2343 /* This is *TOTAL*PANIC* - we are totally screwed. */
2344 LOG_ERROR("INVALID SAM4 REGISTER");
2345 return NULL;
2346 }
2347
2348 static int sam4_ReadThisReg(struct sam4_chip *pChip, uint32_t *goes_here)
2349 {
2350 const struct sam4_reg_list *pReg;
2351 int r;
2352
2353 pReg = sam4_GetReg(pChip, goes_here);
2354 if (!pReg)
2355 return ERROR_FAIL;
2356
2357 r = target_read_u32(pChip->target, pReg->address, goes_here);
2358 if (r != ERROR_OK) {
2359 LOG_ERROR("Cannot read SAM4 register: %s @ 0x%08x, Err: %d",
2360 pReg->name, (unsigned)(pReg->address), r);
2361 }
2362 return r;
2363 }
2364
2365 static int sam4_ReadAllRegs(struct sam4_chip *pChip)
2366 {
2367 int r;
2368 const struct sam4_reg_list *pReg;
2369
2370 pReg = &(sam4_all_regs[0]);
2371 while (pReg->name) {
2372 r = sam4_ReadThisReg(pChip,
2373 sam4_get_reg_ptr(&(pChip->cfg), pReg));
2374 if (r != ERROR_OK) {
2375 LOG_ERROR("Cannot read SAM4 register: %s @ 0x%08x, Error: %d",
2376 pReg->name, ((unsigned)(pReg->address)), r);
2377 return r;
2378 }
2379 pReg++;
2380 }
2381
2382 return ERROR_OK;
2383 }
2384
2385 static int sam4_GetInfo(struct sam4_chip *pChip)
2386 {
2387 const struct sam4_reg_list *pReg;
2388 uint32_t regval;
2389
2390 pReg = &(sam4_all_regs[0]);
2391 while (pReg->name) {
2392 /* display all regs */
2393 LOG_DEBUG("Start: %s", pReg->name);
2394 regval = *sam4_get_reg_ptr(&(pChip->cfg), pReg);
2395 LOG_USER("%*s: [0x%08" PRIx32 "] -> 0x%08" PRIx32,
2396 REG_NAME_WIDTH,
2397 pReg->name,
2398 pReg->address,
2399 regval);
2400 if (pReg->explain_func)
2401 (*(pReg->explain_func))(pChip);
2402 LOG_DEBUG("End: %s", pReg->name);
2403 pReg++;
2404 }
2405 LOG_USER(" rc-osc: %3.03f MHz", _tomhz(pChip->cfg.rc_freq));
2406 LOG_USER(" mainosc: %3.03f MHz", _tomhz(pChip->cfg.mainosc_freq));
2407 LOG_USER(" plla: %3.03f MHz", _tomhz(pChip->cfg.plla_freq));
2408 LOG_USER(" cpu-freq: %3.03f MHz", _tomhz(pChip->cfg.cpu_freq));
2409 LOG_USER("mclk-freq: %3.03f MHz", _tomhz(pChip->cfg.mclk_freq));
2410
2411 LOG_USER(" UniqueId: 0x%08" PRIx32 " 0x%08" PRIx32 " 0x%08" PRIx32 " 0x%08"PRIx32,
2412 pChip->cfg.unique_id[0],
2413 pChip->cfg.unique_id[1],
2414 pChip->cfg.unique_id[2],
2415 pChip->cfg.unique_id[3]);
2416
2417 return ERROR_OK;
2418 }
2419
2420 static int sam4_protect_check(struct flash_bank *bank)
2421 {
2422 int r;
2423 uint32_t v[4] = {0};
2424 unsigned x;
2425 struct sam4_bank_private *pPrivate;
2426
2427 LOG_DEBUG("Begin");
2428 if (bank->target->state != TARGET_HALTED) {
2429 LOG_ERROR("Target not halted");
2430 return ERROR_TARGET_NOT_HALTED;
2431 }
2432
2433 pPrivate = get_sam4_bank_private(bank);
2434 if (!pPrivate) {
2435 LOG_ERROR("no private for this bank?");
2436 return ERROR_FAIL;
2437 }
2438 if (!(pPrivate->probed))
2439 return ERROR_FLASH_BANK_NOT_PROBED;
2440
2441 r = FLASHD_GetLockBits(pPrivate, v);
2442 if (r != ERROR_OK) {
2443 LOG_DEBUG("Failed: %d", r);
2444 return r;
2445 }
2446
2447 for (x = 0; x < pPrivate->nsectors; x++)
2448 bank->sectors[x].is_protected = (!!(v[x >> 5] & (1 << (x % 32))));
2449 LOG_DEBUG("Done");
2450 return ERROR_OK;
2451 }
2452
2453 FLASH_BANK_COMMAND_HANDLER(sam4_flash_bank_command)
2454 {
2455 struct sam4_chip *pChip;
2456
2457 pChip = all_sam4_chips;
2458
2459 /* is this an existing chip? */
2460 while (pChip) {
2461 if (pChip->target == bank->target)
2462 break;
2463 pChip = pChip->next;
2464 }
2465
2466 if (!pChip) {
2467 /* this is a *NEW* chip */
2468 pChip = calloc(1, sizeof(struct sam4_chip));
2469 if (!pChip) {
2470 LOG_ERROR("NO RAM!");
2471 return ERROR_FAIL;
2472 }
2473 pChip->target = bank->target;
2474 /* insert at head */
2475 pChip->next = all_sam4_chips;
2476 all_sam4_chips = pChip;
2477 pChip->target = bank->target;
2478 /* assumption is this runs at 32khz */
2479 pChip->cfg.slow_freq = 32768;
2480 pChip->probed = 0;
2481 }
2482
2483 switch (bank->base) {
2484 default:
2485 LOG_ERROR("Address 0x%08x invalid bank address (try 0x%08x"
2486 "[at91sam4s series] )",
2487 ((unsigned int)(bank->base)),
2488 ((unsigned int)(FLASH_BANK_BASE_S)));
2489 return ERROR_FAIL;
2490 break;
2491
2492 /* at91sam4s series only has bank 0*/
2493 /* at91sam4sd series has the same address for bank 0 (FLASH_BANK0_BASE_SD)*/
2494 case FLASH_BANK_BASE_S:
2495 case FLASH_BANK_BASE_C:
2496 bank->driver_priv = &(pChip->details.bank[0]);
2497 bank->bank_number = 0;
2498 pChip->details.bank[0].pChip = pChip;
2499 pChip->details.bank[0].pBank = bank;
2500 break;
2501
2502 /* Bank 1 of at91sam4sd/at91sam4c32 series */
2503 case FLASH_BANK1_BASE_1024K_SD:
2504 case FLASH_BANK1_BASE_2048K_SD:
2505 case FLASH_BANK1_BASE_C32:
2506 bank->driver_priv = &(pChip->details.bank[1]);
2507 bank->bank_number = 1;
2508 pChip->details.bank[1].pChip = pChip;
2509 pChip->details.bank[1].pBank = bank;
2510 break;
2511 }
2512
2513 /* we initialize after probing. */
2514 return ERROR_OK;
2515 }
2516
2517 /**
2518 * Remove all chips from the internal list without distingushing which one
2519 * is owned by this bank. This simplification works only for one shot
2520 * deallocation like current flash_free_all_banks()
2521 */
2522 static void sam4_free_driver_priv(struct flash_bank *bank)
2523 {
2524 struct sam4_chip *chip = all_sam4_chips;
2525 while (chip) {
2526 struct sam4_chip *next = chip->next;
2527 free(chip);
2528 chip = next;
2529 }
2530 all_sam4_chips = NULL;
2531 }
2532
2533 static int sam4_GetDetails(struct sam4_bank_private *pPrivate)
2534 {
2535 const struct sam4_chip_details *pDetails;
2536 struct sam4_chip *pChip;
2537 struct flash_bank *saved_banks[SAM4_MAX_FLASH_BANKS];
2538 unsigned x;
2539
2540 LOG_DEBUG("Begin");
2541 pDetails = all_sam4_details;
2542 while (pDetails->name) {
2543 /* Compare cidr without version bits */
2544 if (pDetails->chipid_cidr == (pPrivate->pChip->cfg.CHIPID_CIDR & 0xFFFFFFE0))
2545 break;
2546 else
2547 pDetails++;
2548 }
2549 if (pDetails->name == NULL) {
2550 LOG_ERROR("SAM4 ChipID 0x%08x not found in table (perhaps you can ID this chip?)",
2551 (unsigned int)(pPrivate->pChip->cfg.CHIPID_CIDR));
2552 /* Help the victim, print details about the chip */
2553 LOG_INFO("SAM4 CHIPID_CIDR: 0x%08" PRIx32 " decodes as follows",
2554 pPrivate->pChip->cfg.CHIPID_CIDR);
2555 sam4_explain_chipid_cidr(pPrivate->pChip);
2556 return ERROR_FAIL;
2557 }
2558
2559 /* DANGER: THERE ARE DRAGONS HERE */
2560
2561 /* get our pChip - it is going */
2562 /* to be over-written shortly */
2563 pChip = pPrivate->pChip;
2564
2565 /* Note that, in reality: */
2566 /* */
2567 /* pPrivate = &(pChip->details.bank[0]) */
2568 /* or pPrivate = &(pChip->details.bank[1]) */
2569 /* */
2570
2571 /* save the "bank" pointers */
2572 for (x = 0; x < SAM4_MAX_FLASH_BANKS; x++)
2573 saved_banks[x] = pChip->details.bank[x].pBank;
2574
2575 /* Overwrite the "details" structure. */
2576 memcpy(&(pPrivate->pChip->details),
2577 pDetails,
2578 sizeof(pPrivate->pChip->details));
2579
2580 /* now fix the ghosted pointers */
2581 for (x = 0; x < SAM4_MAX_FLASH_BANKS; x++) {
2582 pChip->details.bank[x].pChip = pChip;
2583 pChip->details.bank[x].pBank = saved_banks[x];
2584 }
2585
2586 /* update the *BANK*SIZE* */
2587
2588 LOG_DEBUG("End");
2589 return ERROR_OK;
2590 }
2591
2592 static int _sam4_probe(struct flash_bank *bank, int noise)
2593 {
2594 unsigned x;
2595 int r;
2596 struct sam4_bank_private *pPrivate;
2597
2598
2599 LOG_DEBUG("Begin: Bank: %d, Noise: %d", bank->bank_number, noise);
2600 if (bank->target->state != TARGET_HALTED) {
2601 LOG_ERROR("Target not halted");
2602 return ERROR_TARGET_NOT_HALTED;
2603 }
2604
2605 pPrivate = get_sam4_bank_private(bank);
2606 if (!pPrivate) {
2607 LOG_ERROR("Invalid/unknown bank number");
2608 return ERROR_FAIL;
2609 }
2610
2611 r = sam4_ReadAllRegs(pPrivate->pChip);
2612 if (r != ERROR_OK)
2613 return r;
2614
2615 LOG_DEBUG("Here");
2616 if (pPrivate->pChip->probed)
2617 r = sam4_GetInfo(pPrivate->pChip);
2618 else
2619 r = sam4_GetDetails(pPrivate);
2620 if (r != ERROR_OK)
2621 return r;
2622
2623 /* update the flash bank size */
2624 for (x = 0; x < SAM4_MAX_FLASH_BANKS; x++) {
2625 if (bank->base == pPrivate->pChip->details.bank[x].base_address) {
2626 bank->size = pPrivate->pChip->details.bank[x].size_bytes;
2627 break;
2628 }
2629 }
2630
2631 if (bank->sectors == NULL) {
2632 bank->sectors = calloc(pPrivate->nsectors, (sizeof((bank->sectors)[0])));
2633 if (bank->sectors == NULL) {
2634 LOG_ERROR("No memory!");
2635 return ERROR_FAIL;
2636 }
2637 bank->num_sectors = pPrivate->nsectors;
2638
2639 for (x = 0; ((int)(x)) < bank->num_sectors; x++) {
2640 bank->sectors[x].size = pPrivate->sector_size;
2641 bank->sectors[x].offset = x * (pPrivate->sector_size);
2642 /* mark as unknown */
2643 bank->sectors[x].is_erased = -1;
2644 bank->sectors[x].is_protected = -1;
2645 }
2646 }
2647
2648 pPrivate->probed = 1;
2649
2650 r = sam4_protect_check(bank);
2651 if (r != ERROR_OK)
2652 return r;
2653
2654 LOG_DEBUG("Bank = %d, nbanks = %d",
2655 pPrivate->bank_number, pPrivate->pChip->details.n_banks);
2656 if ((pPrivate->bank_number + 1) == pPrivate->pChip->details.n_banks) {
2657 /* read unique id, */
2658 /* it appears to be associated with the *last* flash bank. */
2659 FLASHD_ReadUniqueID(pPrivate);
2660 }
2661
2662 return r;
2663 }
2664
2665 static int sam4_probe(struct flash_bank *bank)
2666 {
2667 return _sam4_probe(bank, 1);
2668 }
2669
2670 static int sam4_auto_probe(struct flash_bank *bank)
2671 {
2672 return _sam4_probe(bank, 0);
2673 }
2674
2675 static int sam4_erase(struct flash_bank *bank, int first, int last)
2676 {
2677 struct sam4_bank_private *pPrivate;
2678 int r;
2679 int i;
2680 int pageCount;
2681 /*16 pages equals 8KB - Same size as a lock region*/
2682 pageCount = 16;
2683 uint32_t status;
2684
2685 LOG_DEBUG("Here");
2686 if (bank->target->state != TARGET_HALTED) {
2687 LOG_ERROR("Target not halted");
2688 return ERROR_TARGET_NOT_HALTED;
2689 }
2690
2691 r = sam4_auto_probe(bank);
2692 if (r != ERROR_OK) {
2693 LOG_DEBUG("Here,r=%d", r);
2694 return r;
2695 }
2696
2697 pPrivate = get_sam4_bank_private(bank);
2698 if (!(pPrivate->probed))
2699 return ERROR_FLASH_BANK_NOT_PROBED;
2700
2701 if ((first == 0) && ((last + 1) == ((int)(pPrivate->nsectors)))) {
2702 /* whole chip */
2703 LOG_DEBUG("Here");
2704 return FLASHD_EraseEntireBank(pPrivate);
2705 }
2706 LOG_INFO("sam4 does not auto-erase while programming (Erasing relevant sectors)");
2707 LOG_INFO("sam4 First: 0x%08x Last: 0x%08x", (unsigned int)(first), (unsigned int)(last));
2708 for (i = first; i <= last; i++) {
2709 /*16 pages equals 8KB - Same size as a lock region*/
2710 r = FLASHD_ErasePages(pPrivate, (i * pageCount), pageCount, &status);
2711 LOG_INFO("Erasing sector: 0x%08x", (unsigned int)(i));
2712 if (r != ERROR_OK)
2713 LOG_ERROR("SAM4: Error performing Erase page @ lock region number %d",
2714 (unsigned int)(i));
2715 if (status & (1 << 2)) {
2716 LOG_ERROR("SAM4: Lock Region %d is locked", (unsigned int)(i));
2717 return ERROR_FAIL;
2718 }
2719 if (status & (1 << 1)) {
2720 LOG_ERROR("SAM4: Flash Command error @lock region %d", (unsigned int)(i));
2721 return ERROR_FAIL;
2722 }
2723 }
2724
2725 return ERROR_OK;
2726 }
2727
2728 static int sam4_protect(struct flash_bank *bank, int set, int first, int last)
2729 {
2730 struct sam4_bank_private *pPrivate;
2731 int r;
2732
2733 LOG_DEBUG("Here");
2734 if (bank->target->state != TARGET_HALTED) {
2735 LOG_ERROR("Target not halted");
2736 return ERROR_TARGET_NOT_HALTED;
2737 }
2738
2739 pPrivate = get_sam4_bank_private(bank);
2740 if (!(pPrivate->probed))
2741 return ERROR_FLASH_BANK_NOT_PROBED;
2742
2743 if (set)
2744 r = FLASHD_Lock(pPrivate, (unsigned)(first), (unsigned)(last));
2745 else
2746 r = FLASHD_Unlock(pPrivate, (unsigned)(first), (unsigned)(last));
2747 LOG_DEBUG("End: r=%d", r);
2748
2749 return r;
2750
2751 }
2752
2753 static int sam4_page_read(struct sam4_bank_private *pPrivate, unsigned pagenum, uint8_t *buf)
2754 {
2755 uint32_t adr;
2756 int r;
2757
2758 adr = pagenum * pPrivate->page_size;
2759 adr = adr + pPrivate->base_address;
2760
2761 r = target_read_memory(pPrivate->pChip->target,
2762 adr,
2763 4, /* THIS*MUST*BE* in 32bit values */
2764 pPrivate->page_size / 4,
2765 buf);
2766 if (r != ERROR_OK)
2767 LOG_ERROR("SAM4: Flash program failed to read page phys address: 0x%08x",
2768 (unsigned int)(adr));
2769 return r;
2770 }
2771
2772 static int sam4_page_write(struct sam4_bank_private *pPrivate, unsigned pagenum, const uint8_t *buf)
2773 {
2774 uint32_t adr;
2775 uint32_t status;
2776 uint32_t fmr; /* EEFC Flash Mode Register */
2777 int r;
2778
2779 adr = pagenum * pPrivate->page_size;
2780 adr = (adr + pPrivate->base_address);
2781
2782 /* Get flash mode register value */
2783 r = target_read_u32(pPrivate->pChip->target, pPrivate->controller_address, &fmr);
2784 if (r != ERROR_OK)
2785 LOG_DEBUG("Error Read failed: read flash mode register");
2786
2787 /* Clear flash wait state field */
2788 fmr &= 0xfffff0ff;
2789
2790 /* set FWS (flash wait states) field in the FMR (flash mode register) */
2791 fmr |= (pPrivate->flash_wait_states << 8);
2792
2793 LOG_DEBUG("Flash Mode: 0x%08x", ((unsigned int)(fmr)));
2794 r = target_write_u32(pPrivate->pBank->target, pPrivate->controller_address, fmr);
2795 if (r != ERROR_OK)
2796 LOG_DEBUG("Error Write failed: set flash mode register");
2797
2798 /* 1st sector 8kBytes - page 0 - 15*/
2799 /* 2nd sector 8kBytes - page 16 - 30*/
2800 /* 3rd sector 48kBytes - page 31 - 127*/
2801 LOG_DEBUG("Wr Page %u @ phys address: 0x%08x", pagenum, (unsigned int)(adr));
2802 r = target_write_memory(pPrivate->pChip->target,
2803 adr,
2804 4, /* THIS*MUST*BE* in 32bit values */
2805 pPrivate->page_size / 4,
2806 buf);
2807 if (r != ERROR_OK) {
2808 LOG_ERROR("SAM4: Failed to write (buffer) page at phys address 0x%08x",
2809 (unsigned int)(adr));
2810 return r;
2811 }
2812
2813 r = EFC_PerformCommand(pPrivate,
2814 /* send Erase & Write Page */
2815 AT91C_EFC_FCMD_WP, /*AT91C_EFC_FCMD_EWP only works on first two 8kb sectors*/
2816 pagenum,
2817 &status);
2818
2819 if (r != ERROR_OK)
2820 LOG_ERROR("SAM4: Error performing Write page @ phys address 0x%08x",
2821 (unsigned int)(adr));
2822 if (status & (1 << 2)) {
2823 LOG_ERROR("SAM4: Page @ Phys address 0x%08x is locked", (unsigned int)(adr));
2824 return ERROR_FAIL;
2825 }
2826 if (status & (1 << 1)) {
2827 LOG_ERROR("SAM4: Flash Command error @phys address 0x%08x", (unsigned int)(adr));
2828 return ERROR_FAIL;
2829 }
2830 return ERROR_OK;
2831 }
2832
2833 static int sam4_write(struct flash_bank *bank,
2834 const uint8_t *buffer,
2835 uint32_t offset,
2836 uint32_t count)
2837 {
2838 int n;
2839 unsigned page_cur;
2840 unsigned page_end;
2841 int r;
2842 unsigned page_offset;
2843 struct sam4_bank_private *pPrivate;
2844 uint8_t *pagebuffer;
2845
2846 /* incase we bail further below, set this to null */
2847 pagebuffer = NULL;
2848
2849 /* ignore dumb requests */
2850 if (count == 0) {
2851 r = ERROR_OK;
2852 goto done;
2853 }
2854
2855 if (bank->target->state != TARGET_HALTED) {
2856 LOG_ERROR("Target not halted");
2857 r = ERROR_TARGET_NOT_HALTED;
2858 goto done;
2859 }
2860
2861 pPrivate = get_sam4_bank_private(bank);
2862 if (!(pPrivate->probed)) {
2863 r = ERROR_FLASH_BANK_NOT_PROBED;
2864 goto done;
2865 }
2866
2867 if ((offset + count) > pPrivate->size_bytes) {
2868 LOG_ERROR("Flash write error - past end of bank");
2869 LOG_ERROR(" offset: 0x%08x, count 0x%08x, BankEnd: 0x%08x",
2870 (unsigned int)(offset),
2871 (unsigned int)(count),
2872 (unsigned int)(pPrivate->size_bytes));
2873 r = ERROR_FAIL;
2874 goto done;
2875 }
2876
2877 pagebuffer = malloc(pPrivate->page_size);
2878 if (!pagebuffer) {
2879 LOG_ERROR("No memory for %d Byte page buffer", (int)(pPrivate->page_size));
2880 r = ERROR_FAIL;
2881 goto done;
2882 }
2883
2884 /* what page do we start & end in? */
2885 page_cur = offset / pPrivate->page_size;
2886 page_end = (offset + count - 1) / pPrivate->page_size;
2887
2888 LOG_DEBUG("Offset: 0x%08x, Count: 0x%08x", (unsigned int)(offset), (unsigned int)(count));
2889 LOG_DEBUG("Page start: %d, Page End: %d", (int)(page_cur), (int)(page_end));
2890
2891 /* Special case: all one page */
2892 /* */
2893 /* Otherwise: */
2894 /* (1) non-aligned start */
2895 /* (2) body pages */
2896 /* (3) non-aligned end. */
2897
2898 /* Handle special case - all one page. */
2899 if (page_cur == page_end) {
2900 LOG_DEBUG("Special case, all in one page");
2901 r = sam4_page_read(pPrivate, page_cur, pagebuffer);
2902 if (r != ERROR_OK)
2903 goto done;
2904
2905 page_offset = (offset & (pPrivate->page_size-1));
2906 memcpy(pagebuffer + page_offset,
2907 buffer,
2908 count);
2909
2910 r = sam4_page_write(pPrivate, page_cur, pagebuffer);
2911 if (r != ERROR_OK)
2912 goto done;
2913 r = ERROR_OK;
2914 goto done;
2915 }
2916
2917 /* non-aligned start */
2918 page_offset = offset & (pPrivate->page_size - 1);
2919 if (page_offset) {
2920 LOG_DEBUG("Not-Aligned start");
2921 /* read the partial */
2922 r = sam4_page_read(pPrivate, page_cur, pagebuffer);
2923 if (r != ERROR_OK)
2924 goto done;
2925
2926 /* over-write with new data */
2927 n = (pPrivate->page_size - page_offset);
2928 memcpy(pagebuffer + page_offset,
2929 buffer,
2930 n);
2931
2932 r = sam4_page_write(pPrivate, page_cur, pagebuffer);
2933 if (r != ERROR_OK)
2934 goto done;
2935
2936 count -= n;
2937 offset += n;
2938 buffer += n;
2939 page_cur++;
2940 }
2941
2942 /* By checking that offset is correct here, we also
2943 fix a clang warning */
2944 assert(offset % pPrivate->page_size == 0);
2945
2946 /* intermediate large pages */
2947 /* also - the final *terminal* */
2948 /* if that terminal page is a full page */
2949 LOG_DEBUG("Full Page Loop: cur=%d, end=%d, count = 0x%08x",
2950 (int)page_cur, (int)page_end, (unsigned int)(count));
2951
2952 while ((page_cur < page_end) &&
2953 (count >= pPrivate->page_size)) {
2954 r = sam4_page_write(pPrivate, page_cur, buffer);
2955 if (r != ERROR_OK)
2956 goto done;
2957 count -= pPrivate->page_size;
2958 buffer += pPrivate->page_size;
2959 page_cur += 1;
2960 }
2961
2962 /* terminal partial page? */
2963 if (count) {
2964 LOG_DEBUG("Terminal partial page, count = 0x%08x", (unsigned int)(count));
2965 /* we have a partial page */
2966 r = sam4_page_read(pPrivate, page_cur, pagebuffer);
2967 if (r != ERROR_OK)
2968 goto done;
2969 /* data goes at start */
2970 memcpy(pagebuffer, buffer, count);
2971 r = sam4_page_write(pPrivate, page_cur, pagebuffer);
2972 if (r != ERROR_OK)
2973 goto done;
2974 }
2975 LOG_DEBUG("Done!");
2976 r = ERROR_OK;
2977 done:
2978 if (pagebuffer)
2979 free(pagebuffer);
2980 return r;
2981 }
2982
2983 COMMAND_HANDLER(sam4_handle_info_command)
2984 {
2985 struct sam4_chip *pChip;
2986 pChip = get_current_sam4(CMD_CTX);
2987 if (!pChip)
2988 return ERROR_OK;
2989
2990 unsigned x;
2991 int r;
2992
2993 /* bank0 must exist before we can do anything */
2994 if (pChip->details.bank[0].pBank == NULL) {
2995 x = 0;
2996 need_define:
2997 command_print(CMD_CTX,
2998 "Please define bank %d via command: flash bank %s ... ",
2999 x,
3000 at91sam4_flash.name);
3001 return ERROR_FAIL;
3002 }
3003
3004 /* if bank 0 is not probed, then probe it */
3005 if (!(pChip->details.bank[0].probed)) {
3006 r = sam4_auto_probe(pChip->details.bank[0].pBank);
3007 if (r != ERROR_OK)
3008 return ERROR_FAIL;
3009 }
3010 /* above guarantees the "chip details" structure is valid */
3011 /* and thus, bank private areas are valid */
3012 /* and we have a SAM4 chip, what a concept! */
3013
3014 /* auto-probe other banks, 0 done above */
3015 for (x = 1; x < SAM4_MAX_FLASH_BANKS; x++) {
3016 /* skip banks not present */
3017 if (!(pChip->details.bank[x].present))
3018 continue;
3019
3020 if (pChip->details.bank[x].pBank == NULL)
3021 goto need_define;
3022
3023 if (pChip->details.bank[x].probed)
3024 continue;
3025
3026 r = sam4_auto_probe(pChip->details.bank[x].pBank);
3027 if (r != ERROR_OK)
3028 return r;
3029 }
3030
3031 r = sam4_GetInfo(pChip);
3032 if (r != ERROR_OK) {
3033 LOG_DEBUG("Sam4Info, Failed %d", r);
3034 return r;
3035 }
3036
3037 return ERROR_OK;
3038 }
3039
3040 COMMAND_HANDLER(sam4_handle_gpnvm_command)
3041 {
3042 unsigned x, v;
3043 int r, who;
3044 struct sam4_chip *pChip;
3045
3046 pChip = get_current_sam4(CMD_CTX);
3047 if (!pChip)
3048 return ERROR_OK;
3049
3050 if (pChip->target->state != TARGET_HALTED) {
3051 LOG_ERROR("sam4 - target not halted");
3052 return ERROR_TARGET_NOT_HALTED;
3053 }
3054
3055 if (pChip->details.bank[0].pBank == NULL) {
3056 command_print(CMD_CTX, "Bank0 must be defined first via: flash bank %s ...",
3057 at91sam4_flash.name);
3058 return ERROR_FAIL;
3059 }
3060 if (!pChip->details.bank[0].probed) {
3061 r = sam4_auto_probe(pChip->details.bank[0].pBank);
3062 if (r != ERROR_OK)
3063 return r;
3064 }
3065
3066 switch (CMD_ARGC) {
3067 default:
3068 return ERROR_COMMAND_SYNTAX_ERROR;
3069 break;
3070 case 0:
3071 goto showall;
3072 break;
3073 case 1:
3074 who = -1;
3075 break;
3076 case 2:
3077 if ((0 == strcmp(CMD_ARGV[0], "show")) && (0 == strcmp(CMD_ARGV[1], "all")))
3078 who = -1;
3079 else {
3080 uint32_t v32;
3081 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], v32);
3082 who = v32;
3083 }
3084 break;
3085 }
3086
3087 if (0 == strcmp("show", CMD_ARGV[0])) {
3088 if (who == -1) {
3089 showall:
3090 r = ERROR_OK;
3091 for (x = 0; x < pChip->details.n_gpnvms; x++) {
3092 r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), x, &v);
3093 if (r != ERROR_OK)
3094 break;
3095 command_print(CMD_CTX, "sam4-gpnvm%u: %u", x, v);
3096 }
3097 return r;
3098 }
3099 if ((who >= 0) && (((unsigned)(who)) < pChip->details.n_gpnvms)) {
3100 r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), who, &v);
3101 command_print(CMD_CTX, "sam4-gpnvm%u: %u", who, v);
3102 return r;
3103 } else {
3104 command_print(CMD_CTX, "sam4-gpnvm invalid GPNVM: %u", who);
3105 return ERROR_COMMAND_SYNTAX_ERROR;
3106 }
3107 }
3108
3109 if (who == -1) {
3110 command_print(CMD_CTX, "Missing GPNVM number");
3111 return ERROR_COMMAND_SYNTAX_ERROR;
3112 }
3113
3114 if (0 == strcmp("set", CMD_ARGV[0]))
3115 r = FLASHD_SetGPNVM(&(pChip->details.bank[0]), who);
3116 else if ((0 == strcmp("clr", CMD_ARGV[0])) ||
3117 (0 == strcmp("clear", CMD_ARGV[0]))) /* quietly accept both */
3118 r = FLASHD_ClrGPNVM(&(pChip->details.bank[0]), who);
3119 else {
3120 command_print(CMD_CTX, "Unknown command: %s", CMD_ARGV[0]);
3121 r = ERROR_COMMAND_SYNTAX_ERROR;
3122 }
3123 return r;
3124 }
3125
3126 COMMAND_HANDLER(sam4_handle_slowclk_command)
3127 {
3128 struct sam4_chip *pChip;
3129
3130 pChip = get_current_sam4(CMD_CTX);
3131 if (!pChip)
3132 return ERROR_OK;
3133
3134 switch (CMD_ARGC) {
3135 case 0:
3136 /* show */
3137 break;
3138 case 1:
3139 {
3140 /* set */
3141 uint32_t v;
3142 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], v);
3143 if (v > 200000) {
3144 /* absurd slow clock of 200Khz? */
3145 command_print(CMD_CTX, "Absurd/illegal slow clock freq: %d\n", (int)(v));
3146 return ERROR_COMMAND_SYNTAX_ERROR;
3147 }
3148 pChip->cfg.slow_freq = v;
3149 break;
3150 }
3151 default:
3152 /* error */
3153 command_print(CMD_CTX, "Too many parameters");
3154 return ERROR_COMMAND_SYNTAX_ERROR;
3155 break;
3156 }
3157 command_print(CMD_CTX, "Slowclk freq: %d.%03dkhz",
3158 (int)(pChip->cfg.slow_freq / 1000),
3159 (int)(pChip->cfg.slow_freq % 1000));
3160 return ERROR_OK;
3161 }
3162
3163 static const struct command_registration at91sam4_exec_command_handlers[] = {
3164 {
3165 .name = "gpnvm",
3166 .handler = sam4_handle_gpnvm_command,
3167 .mode = COMMAND_EXEC,
3168 .usage = "[('clr'|'set'|'show') bitnum]",
3169 .help = "Without arguments, shows all bits in the gpnvm "
3170 "register. Otherwise, clears, sets, or shows one "
3171 "General Purpose Non-Volatile Memory (gpnvm) bit.",
3172 },
3173 {
3174 .name = "info",
3175 .handler = sam4_handle_info_command,
3176 .mode = COMMAND_EXEC,
3177 .help = "Print information about the current at91sam4 chip"
3178 "and its flash configuration.",
3179 },
3180 {
3181 .name = "slowclk",
3182 .handler = sam4_handle_slowclk_command,
3183 .mode = COMMAND_EXEC,
3184 .usage = "[clock_hz]",
3185 .help = "Display or set the slowclock frequency "
3186 "(default 32768 Hz).",
3187 },
3188 COMMAND_REGISTRATION_DONE
3189 };
3190 static const struct command_registration at91sam4_command_handlers[] = {
3191 {
3192 .name = "at91sam4",
3193 .mode = COMMAND_ANY,
3194 .help = "at91sam4 flash command group",
3195 .usage = "",
3196 .chain = at91sam4_exec_command_handlers,
3197 },
3198 COMMAND_REGISTRATION_DONE
3199 };
3200
3201 struct flash_driver at91sam4_flash = {
3202 .name = "at91sam4",
3203 .commands = at91sam4_command_handlers,
3204 .flash_bank_command = sam4_flash_bank_command,
3205 .erase = sam4_erase,
3206 .protect = sam4_protect,
3207 .write = sam4_write,
3208 .read = default_flash_read,
3209 .probe = sam4_probe,
3210 .auto_probe = sam4_auto_probe,
3211 .erase_check = default_flash_blank_check,
3212 .protect_check = sam4_protect_check,
3213 .free_driver_priv = sam4_free_driver_priv,
3214 };
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)