?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
-Wshadow fixes
[openocd/cortex.git] / src / flash / nor / at91sam7.c
blob606cc32b02908b469ed6ff816c43df2976d0eda4
1 /***************************************************************************
2 * Copyright (C) 2006 by Magnus Lundin *
3 * lundin@mlu.mine.nu *
4 * *
5 * Copyright (C) 2008 by Gheorghe Guran (atlas) *
6 * *
7 * This program is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU General public License as published by *
9 * the Free Software Foundation; either version 2 of the License, or *
10 * (at your option) any later version. *
11 * *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS for A PARTICULAR PURPOSE. See the *
15 * GNU General public License for more details. *
16 * *
17 * You should have received a copy of the GNU General public License *
18 * along with this program; if not, write to the *
19 * Free Software Foundation, Inc., *
20 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
21 ****************************************************************************/
22
23 /***************************************************************************
24 *
25 * New flash setup command:
26 *
27 * flash bank <driver> <base_addr> <size> <chip_width> <bus_width> <target_id>
28 * [<chip_type> <banks>
29 * <sectors_per_bank> <pages_per_sector>
30 * <page_size> <num_nvmbits>
31 * <ext_freq_khz>]
32 *
33 * <ext_freq_khz> - MUST be used if clock is from external source,
34 * CAN be used if main oscillator frequency is known (recommended)
35 * Examples:
36 * ==== RECOMMENDED (covers clock speed) ============
37 * flash bank at91sam7 0x00100000 0 0 4 $_TARGETNAME AT91SAM7XC256 1 16 64 256 3 25000
38 * (if auto-detect fails; provides clock spec)
39 * flash bank at91sam7 0 0 0 0 $_TARGETNAME 0 0 0 0 0 0 25000
40 * (auto-detect everything except the clock)
41 * ==== NOT RECOMMENDED !!! (clock speed is not configured) ====
42 * flash bank at91sam7 0x00100000 0 0 4 $_TARGETNAME AT91SAM7XC256 1 16 64 256 3 0
43 * (if auto-detect fails)
44 * flash bank at91sam7 0 0 0 0 $_TARGETNAME
45 * (old style, auto-detect everything)
46 ****************************************************************************/
47
48 #ifdef HAVE_CONFIG_H
49 #include "config.h"
50 #endif
51
52 #include "imp.h"
53 #include "at91sam7.h"
54 #include <helper/binarybuffer.h>
55
56 static int at91sam7_protect_check(struct flash_bank *bank);
57 static int at91sam7_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count);
58
59 static uint32_t at91sam7_get_flash_status(struct target *target, int bank_number);
60 static void at91sam7_set_flash_mode(struct flash_bank *bank, int mode);
61 static uint32_t at91sam7_wait_status_busy(struct flash_bank *bank, uint32_t waitbits, int timeout);
62 static int at91sam7_flash_command(struct flash_bank *bank, uint8_t cmd, uint16_t pagen);
63
64 static uint32_t MC_FMR[4] = { 0xFFFFFF60, 0xFFFFFF70, 0xFFFFFF80, 0xFFFFFF90 };
65 static uint32_t MC_FCR[4] = { 0xFFFFFF64, 0xFFFFFF74, 0xFFFFFF84, 0xFFFFFF94 };
66 static uint32_t MC_FSR[4] = { 0xFFFFFF68, 0xFFFFFF78, 0xFFFFFF88, 0xFFFFFF98 };
67
68 static char * EPROC[8]= {"Unknown","ARM946-E","ARM7TDMI","Unknown","ARM920T","ARM926EJ-S","Unknown","Unknown"};
69
70 #if 0
71 static long SRAMSIZ[16] = {
72 -1,
73 0x0400, /* 1K */
74 0x0800, /* 2K */
75 -1,
76 0x1c000, /* 112K */
77 0x1000, /* 4K */
78 0x14000, /* 80K */
79 0x28000, /* 160K */
80 0x2000, /* 8K */
81 0x4000, /* 16K */
82 0x8000, /* 32K */
83 0x10000, /* 64K */
84 0x20000, /* 128K */
85 0x40000, /* 256K */
86 0x18000, /* 96K */
87 0x80000, /* 512K */
88 };
89 #endif
90
91
92 static uint32_t at91sam7_get_flash_status(struct target *target, int bank_number)
93 {
94 uint32_t fsr;
95 target_read_u32(target, MC_FSR[bank_number], &fsr);
96
97 return fsr;
98 }
99
100 /* Read clock configuration and set at91sam7_info->mck_freq */
101 static void at91sam7_read_clock_info(struct flash_bank *bank)
102 {
103 struct at91sam7_flash_bank *at91sam7_info = bank->driver_priv;
104 struct target *target = bank->target;
105 uint32_t mckr, mcfr, pllr, mor;
106 unsigned long tmp = 0, mainfreq;
107
108 /* Read Clock Generator Main Oscillator Register */
109 target_read_u32(target, CKGR_MOR, &mor);
110 /* Read Clock Generator Main Clock Frequency Register */
111 target_read_u32(target, CKGR_MCFR, &mcfr);
112 /* Read Master Clock Register*/
113 target_read_u32(target, PMC_MCKR, &mckr);
114 /* Read Clock Generator PLL Register */
115 target_read_u32(target, CKGR_PLLR, &pllr);
116
117 at91sam7_info->mck_valid = 0;
118 at91sam7_info->mck_freq = 0;
119 switch (mckr & PMC_MCKR_CSS)
120 {
121 case 0: /* Slow Clock */
122 at91sam7_info->mck_valid = 1;
123 tmp = RC_FREQ;
124 break;
125
126 case 1: /* Main Clock */
127 if ((mcfr & CKGR_MCFR_MAINRDY) &&
128 (at91sam7_info->ext_freq == 0))
129 {
130 at91sam7_info->mck_valid = 1;
131 tmp = RC_FREQ / 16ul * (mcfr & 0xffff);
132 }
133 else if (at91sam7_info->ext_freq != 0)
134 {
135 at91sam7_info->mck_valid = 1;
136 tmp = at91sam7_info->ext_freq;
137 }
138 break;
139
140 case 2: /* Reserved */
141 break;
142
143 case 3: /* PLL Clock */
144 if ((mcfr & CKGR_MCFR_MAINRDY) &&
145 (at91sam7_info->ext_freq == 0))
146 {
147 target_read_u32(target, CKGR_PLLR, &pllr);
148 if (!(pllr & CKGR_PLLR_DIV))
149 break; /* 0 Hz */
150 at91sam7_info->mck_valid = 1;
151 mainfreq = RC_FREQ / 16ul * (mcfr & 0xffff);
152 /* Integer arithmetic should have sufficient precision
153 * as long as PLL is properly configured. */
154 tmp = mainfreq / (pllr & CKGR_PLLR_DIV)*
155 (((pllr & CKGR_PLLR_MUL) >> 16) + 1);
156 }
157 else if ((at91sam7_info->ext_freq != 0) &&
158 ((pllr&CKGR_PLLR_DIV) != 0))
159 {
160 at91sam7_info->mck_valid = 1;
161 tmp = at91sam7_info->ext_freq / (pllr&CKGR_PLLR_DIV)*
162 (((pllr & CKGR_PLLR_MUL) >> 16) + 1);
163 }
164 break;
165 }
166
167 /* Prescaler adjust */
168 if ((((mckr & PMC_MCKR_PRES) >> 2) == 7) || (tmp == 0))
169 {
170 at91sam7_info->mck_valid = 0;
171 at91sam7_info->mck_freq = 0;
172 }
173 else if (((mckr & PMC_MCKR_PRES) >> 2) != 0)
174 at91sam7_info->mck_freq = tmp >> ((mckr & PMC_MCKR_PRES) >> 2);
175 else
176 at91sam7_info->mck_freq = tmp;
177 }
178
179 /* Setup the timimg registers for nvbits or normal flash */
180 static void at91sam7_set_flash_mode(struct flash_bank *bank, int mode)
181 {
182 uint32_t fmr, fmcn = 0, fws = 0;
183 struct at91sam7_flash_bank *at91sam7_info = bank->driver_priv;
184 struct target *target = bank->target;
185
186 if (mode && (mode != at91sam7_info->flashmode))
187 {
188 /* Always round up (ceil) */
189 if (mode == FMR_TIMING_NVBITS)
190 {
191 if (at91sam7_info->cidr_arch == 0x60)
192 {
193 /* AT91SAM7A3 uses master clocks in 100 ns */
194 fmcn = (at91sam7_info->mck_freq/10000000ul) + 1;
195 }
196 else
197 {
198 /* master clocks in 1uS for ARCH 0x7 types */
199 fmcn = (at91sam7_info->mck_freq/1000000ul) + 1;
200 }
201 }
202 else if (mode == FMR_TIMING_FLASH)
203 {
204 /* main clocks in 1.5uS */
205 fmcn = (at91sam7_info->mck_freq/1000000ul)+
206 (at91sam7_info->mck_freq/2000000ul) + 1;
207 }
208
209 /* hard overclocking */
210 if (fmcn > 0xFF)
211 fmcn = 0xFF;
212
213 /* Only allow fmcn = 0 if clock period is > 30 us = 33kHz. */
214 if (at91sam7_info->mck_freq <= 33333ul)
215 fmcn = 0;
216 /* Only allow fws = 0 if clock frequency is < 30 MHz. */
217 if (at91sam7_info->mck_freq > 30000000ul)
218 fws = 1;
219
220 LOG_DEBUG("fmcn[%i]: %i", bank->bank_number, (int)(fmcn));
221 fmr = fmcn << 16 | fws << 8;
222 target_write_u32(target, MC_FMR[bank->bank_number], fmr);
223 }
224
225 at91sam7_info->flashmode = mode;
226 }
227
228 static uint32_t at91sam7_wait_status_busy(struct flash_bank *bank, uint32_t waitbits, int timeout)
229 {
230 uint32_t status;
231
232 while ((!((status = at91sam7_get_flash_status(bank->target, bank->bank_number)) & waitbits)) && (timeout-- > 0))
233 {
234 LOG_DEBUG("status[%i]: 0x%" PRIx32 "", (int)bank->bank_number, status);
235 alive_sleep(1);
236 }
237
238 LOG_DEBUG("status[%i]: 0x%" PRIx32 "", bank->bank_number, status);
239
240 if (status & 0x0C)
241 {
242 LOG_ERROR("status register: 0x%" PRIx32 "", status);
243 if (status & 0x4)
244 LOG_ERROR("Lock Error Bit Detected, Operation Abort");
245 if (status & 0x8)
246 LOG_ERROR("Invalid command and/or bad keyword, Operation Abort");
247 if (status & 0x10)
248 LOG_ERROR("Security Bit Set, Operation Abort");
249 }
250
251 return status;
252 }
253
254 /* Send one command to the AT91SAM flash controller */
255 static int at91sam7_flash_command(struct flash_bank *bank, uint8_t cmd, uint16_t pagen)
256 {
257 uint32_t fcr;
258 struct at91sam7_flash_bank *at91sam7_info = bank->driver_priv;
259 struct target *target = bank->target;
260
261 fcr = (0x5A << 24) | ((pagen&0x3FF) << 8) | cmd;
262 target_write_u32(target, MC_FCR[bank->bank_number], fcr);
263 LOG_DEBUG("Flash command: 0x%" PRIx32 ", flash bank: %i, page number: %u", fcr, bank->bank_number + 1, pagen);
264
265 if ((at91sam7_info->cidr_arch == 0x60) && ((cmd == SLB) | (cmd == CLB)))
266 {
267 /* Lock bit manipulation on AT91SAM7A3 waits for FC_FSR bit 1, EOL */
268 if (at91sam7_wait_status_busy(bank, MC_FSR_EOL, 10)&0x0C)
269 {
270 return ERROR_FLASH_OPERATION_FAILED;
271 }
272 return ERROR_OK;
273 }
274
275 if (at91sam7_wait_status_busy(bank, MC_FSR_FRDY, 10)&0x0C)
276 {
277 return ERROR_FLASH_OPERATION_FAILED;
278 }
279
280 return ERROR_OK;
281 }
282
283 /* Read device id register, main clock frequency register and fill in driver info structure */
284 static int at91sam7_read_part_info(struct flash_bank *bank)
285 {
286 struct flash_bank *t_bank = bank;
287 struct at91sam7_flash_bank *at91sam7_info;
288 struct target *target = t_bank->target;
289
290 uint16_t bnk, sec;
291 uint16_t arch;
292 uint32_t cidr;
293 uint8_t banks_num = 0;
294 uint16_t num_nvmbits = 0;
295 uint16_t sectors_num = 0;
296 uint16_t pages_per_sector = 0;
297 uint16_t page_size = 0;
298 uint32_t ext_freq;
299 uint32_t bank_size;
300 uint32_t base_address = 0;
301 char *target_name = "Unknown";
302
303 at91sam7_info = t_bank->driver_priv;
304
305 if (at91sam7_info->cidr != 0)
306 {
307 /* flash already configured, update clock and check for protected sectors */
308 struct flash_bank *fb = bank;
309 t_bank = fb;
310
311 while (t_bank)
312 {
313 /* re-calculate master clock frequency */
314 at91sam7_read_clock_info(t_bank);
315
316 /* no timming */
317 at91sam7_set_flash_mode(t_bank, FMR_TIMING_NONE);
318
319 /* check protect state */
320 at91sam7_protect_check(t_bank);
321
322 t_bank = fb->next;
323 fb = t_bank;
324 }
325
326 return ERROR_OK;
327 }
328
329 /* Read and parse chip identification register */
330 target_read_u32(target, DBGU_CIDR, &cidr);
331 if (cidr == 0)
332 {
333 LOG_WARNING("Cannot identify target as an AT91SAM");
334 return ERROR_FLASH_OPERATION_FAILED;
335 }
336
337 if (at91sam7_info->flash_autodetection == 0)
338 {
339 /* banks and sectors are already created, based on data from input file */
340 struct flash_bank *fb = bank;
341 t_bank = fb;
342 while (t_bank)
343 {
344 at91sam7_info = t_bank->driver_priv;
345
346 at91sam7_info->cidr = cidr;
347 at91sam7_info->cidr_ext = (cidr >> 31)&0x0001;
348 at91sam7_info->cidr_nvptyp = (cidr >> 28)&0x0007;
349 at91sam7_info->cidr_arch = (cidr >> 20)&0x00FF;
350 at91sam7_info->cidr_sramsiz = (cidr >> 16)&0x000F;
351 at91sam7_info->cidr_nvpsiz2 = (cidr >> 12)&0x000F;
352 at91sam7_info->cidr_nvpsiz = (cidr >> 8)&0x000F;
353 at91sam7_info->cidr_eproc = (cidr >> 5)&0x0007;
354 at91sam7_info->cidr_version = cidr&0x001F;
355
356 /* calculate master clock frequency */
357 at91sam7_read_clock_info(t_bank);
358
359 /* no timming */
360 at91sam7_set_flash_mode(t_bank, FMR_TIMING_NONE);
361
362 /* check protect state */
363 at91sam7_protect_check(t_bank);
364
365 t_bank = fb->next;
366 fb = t_bank;
367 }
368
369 return ERROR_OK;
370 }
371
372 arch = (cidr >> 20)&0x00FF;
373
374 /* check flash size */
375 switch ((cidr >> 8)&0x000F)
376 {
377 case FLASH_SIZE_8KB:
378 break;
379
380 case FLASH_SIZE_16KB:
381 banks_num = 1;
382 sectors_num = 8;
383 pages_per_sector = 32;
384 page_size = 64;
385 base_address = 0x00100000;
386 if (arch == 0x70)
387 {
388 num_nvmbits = 2;
389 target_name = "AT91SAM7S161/16";
390 }
391 break;
392
393 case FLASH_SIZE_32KB:
394 banks_num = 1;
395 sectors_num = 8;
396 pages_per_sector = 32;
397 page_size = 128;
398 base_address = 0x00100000;
399 if (arch == 0x70)
400 {
401 num_nvmbits = 2;
402 target_name = "AT91SAM7S321/32";
403 }
404 if (arch == 0x72)
405 {
406 num_nvmbits = 3;
407 target_name = "AT91SAM7SE32";
408 }
409 break;
410
411 case FLASH_SIZE_64KB:
412 banks_num = 1;
413 sectors_num = 16;
414 pages_per_sector = 32;
415 page_size = 128;
416 base_address = 0x00100000;
417 if (arch == 0x70)
418 {
419 num_nvmbits = 2;
420 target_name = "AT91SAM7S64";
421 }
422 break;
423
424 case FLASH_SIZE_128KB:
425 banks_num = 1;
426 sectors_num = 8;
427 pages_per_sector = 64;
428 page_size = 256;
429 base_address = 0x00100000;
430 if (arch == 0x70)
431 {
432 num_nvmbits = 2;
433 target_name = "AT91SAM7S128";
434 }
435 if (arch == 0x71)
436 {
437 num_nvmbits = 3;
438 target_name = "AT91SAM7XC128";
439 }
440 if (arch == 0x72)
441 {
442 num_nvmbits = 3;
443 target_name = "AT91SAM7SE128";
444 }
445 if (arch == 0x75)
446 {
447 num_nvmbits = 3;
448 target_name = "AT91SAM7X128";
449 }
450 break;
451
452 case FLASH_SIZE_256KB:
453 banks_num = 1;
454 sectors_num = 16;
455 pages_per_sector = 64;
456 page_size = 256;
457 base_address = 0x00100000;
458 if (arch == 0x60)
459 {
460 num_nvmbits = 3;
461 target_name = "AT91SAM7A3";
462 }
463 if (arch == 0x70)
464 {
465 num_nvmbits = 2;
466 target_name = "AT91SAM7S256";
467 }
468 if (arch == 0x71)
469 {
470 num_nvmbits = 3;
471 target_name = "AT91SAM7XC256";
472 }
473 if (arch == 0x72)
474 {
475 num_nvmbits = 3;
476 target_name = "AT91SAM7SE256";
477 }
478 if (arch == 0x75)
479 {
480 num_nvmbits = 3;
481 target_name = "AT91SAM7X256";
482 }
483 break;
484
485 case FLASH_SIZE_512KB:
486 banks_num = 2;
487 sectors_num = 16;
488 pages_per_sector = 64;
489 page_size = 256;
490 base_address = 0x00100000;
491 if (arch == 0x70)
492 {
493 num_nvmbits = 2;
494 target_name = "AT91SAM7S512";
495 }
496 if (arch == 0x71)
497 {
498 num_nvmbits = 3;
499 target_name = "AT91SAM7XC512";
500 }
501 if (arch == 0x72)
502 {
503 num_nvmbits = 3;
504 target_name = "AT91SAM7SE512";
505 }
506 if (arch == 0x75)
507 {
508 num_nvmbits = 3;
509 target_name = "AT91SAM7X512";
510 }
511 break;
512
513 case FLASH_SIZE_1024KB:
514 break;
515
516 case FLASH_SIZE_2048KB:
517 break;
518 }
519
520 if (strcmp(target_name, "Unknown") == 0)
521 {
522 LOG_ERROR("Target autodetection failed! Please specify target parameters in configuration file");
523 return ERROR_FLASH_OPERATION_FAILED;
524 }
525
526 ext_freq = at91sam7_info->ext_freq;
527
528 /* calculate bank size */
529 bank_size = sectors_num * pages_per_sector * page_size;
530
531 for (bnk = 0; bnk < banks_num; bnk++)
532 {
533 if (bnk > 0)
534 {
535 /* create a new flash bank element */
536 struct flash_bank *fb = malloc(sizeof(struct flash_bank));
537 fb->target = target;
538 fb->driver = bank->driver;
539 fb->driver_priv = malloc(sizeof(struct at91sam7_flash_bank));
540 fb->next = NULL;
541
542 /* link created bank in 'flash_banks' list and redirect t_bank */
543 t_bank->next = fb;
544 t_bank = fb;
545 }
546
547 t_bank->bank_number = bnk;
548 t_bank->base = base_address + bnk * bank_size;
549 t_bank->size = bank_size;
550 t_bank->chip_width = 0;
551 t_bank->bus_width = 4;
552 t_bank->num_sectors = sectors_num;
553
554 /* allocate sectors */
555 t_bank->sectors = malloc(sectors_num * sizeof(struct flash_sector));
556 for (sec = 0; sec < sectors_num; sec++)
557 {
558 t_bank->sectors[sec].offset = sec * pages_per_sector * page_size;
559 t_bank->sectors[sec].size = pages_per_sector * page_size;
560 t_bank->sectors[sec].is_erased = -1;
561 t_bank->sectors[sec].is_protected = -1;
562 }
563
564 at91sam7_info = t_bank->driver_priv;
565
566 at91sam7_info->cidr = cidr;
567 at91sam7_info->cidr_ext = (cidr >> 31)&0x0001;
568 at91sam7_info->cidr_nvptyp = (cidr >> 28)&0x0007;
569 at91sam7_info->cidr_arch = (cidr >> 20)&0x00FF;
570 at91sam7_info->cidr_sramsiz = (cidr >> 16)&0x000F;
571 at91sam7_info->cidr_nvpsiz2 = (cidr >> 12)&0x000F;
572 at91sam7_info->cidr_nvpsiz = (cidr >> 8)&0x000F;
573 at91sam7_info->cidr_eproc = (cidr >> 5)&0x0007;
574 at91sam7_info->cidr_version = cidr&0x001F;
575
576 at91sam7_info->target_name = target_name;
577 at91sam7_info->flashmode = 0;
578 at91sam7_info->ext_freq = ext_freq;
579 at91sam7_info->num_nvmbits = num_nvmbits;
580 at91sam7_info->num_nvmbits_on = 0;
581 at91sam7_info->pagesize = page_size;
582 at91sam7_info->pages_per_sector = pages_per_sector;
583
584 /* calculate master clock frequency */
585 at91sam7_read_clock_info(t_bank);
586
587 /* no timming */
588 at91sam7_set_flash_mode(t_bank, FMR_TIMING_NONE);
589
590 /* check protect state */
591 at91sam7_protect_check(t_bank);
592 }
593
594 LOG_DEBUG("nvptyp: 0x%3.3x, arch: 0x%4.4x", at91sam7_info->cidr_nvptyp, at91sam7_info->cidr_arch);
595
596 return ERROR_OK;
597 }
598
599 static int at91sam7_erase_check(struct flash_bank *bank)
600 {
601 struct target *target = bank->target;
602 uint16_t retval;
603 uint32_t blank;
604 uint16_t fast_check;
605 uint8_t *buffer;
606 uint16_t nSector;
607 uint16_t nByte;
608
609 if (bank->target->state != TARGET_HALTED)
610 {
611 LOG_ERROR("Target not halted");
612 return ERROR_TARGET_NOT_HALTED;
613 }
614
615 /* Configure the flash controller timing */
616 at91sam7_read_clock_info(bank);
617 at91sam7_set_flash_mode(bank, FMR_TIMING_FLASH);
618
619 fast_check = 1;
620 for (nSector = 0; nSector < bank->num_sectors; nSector++)
621 {
622 retval = target_blank_check_memory(target, bank->base + bank->sectors[nSector].offset,
623 bank->sectors[nSector].size, &blank);
624 if (retval != ERROR_OK)
625 {
626 fast_check = 0;
627 break;
628 }
629 if (blank == 0xFF)
630 bank->sectors[nSector].is_erased = 1;
631 else
632 bank->sectors[nSector].is_erased = 0;
633 }
634
635 if (fast_check)
636 {
637 return ERROR_OK;
638 }
639
640 LOG_USER("Running slow fallback erase check - add working memory");
641
642 buffer = malloc(bank->sectors[0].size);
643 for (nSector = 0; nSector < bank->num_sectors; nSector++)
644 {
645 bank->sectors[nSector].is_erased = 1;
646 retval = target_read_memory(target, bank->base + bank->sectors[nSector].offset, 4,
647 bank->sectors[nSector].size/4, buffer);
648 if (retval != ERROR_OK)
649 return retval;
650
651 for (nByte = 0; nByte < bank->sectors[nSector].size; nByte++)
652 {
653 if (buffer[nByte] != 0xFF)
654 {
655 bank->sectors[nSector].is_erased = 0;
656 break;
657 }
658 }
659 }
660 free(buffer);
661
662 return ERROR_OK;
663 }
664
665 static int at91sam7_protect_check(struct flash_bank *bank)
666 {
667 uint8_t lock_pos, gpnvm_pos;
668 uint32_t status;
669
670 struct at91sam7_flash_bank *at91sam7_info = bank->driver_priv;
671
672 if (at91sam7_info->cidr == 0)
673 {
674 return ERROR_FLASH_BANK_NOT_PROBED;
675 }
676 if (bank->target->state != TARGET_HALTED)
677 {
678 LOG_ERROR("Target not halted");
679 return ERROR_TARGET_NOT_HALTED;
680 }
681
682 status = at91sam7_get_flash_status(bank->target, bank->bank_number);
683 at91sam7_info->lockbits = (status >> 16);
684
685 at91sam7_info->num_lockbits_on = 0;
686 for (lock_pos = 0; lock_pos < bank->num_sectors; lock_pos++)
687 {
688 if (((status >> (16 + lock_pos))&(0x0001)) == 1)
689 {
690 at91sam7_info->num_lockbits_on++;
691 bank->sectors[lock_pos].is_protected = 1;
692 }
693 else
694 bank->sectors[lock_pos].is_protected = 0;
695 }
696
697 /* GPNVM and SECURITY bits apply only for MC_FSR of EFC0 */
698 status = at91sam7_get_flash_status(bank->target, 0);
699
700 at91sam7_info->securitybit = (status >> 4)&0x01;
701 at91sam7_info->nvmbits = (status >> 8)&0xFF;
702
703 at91sam7_info->num_nvmbits_on = 0;
704 for (gpnvm_pos = 0; gpnvm_pos < at91sam7_info->num_nvmbits; gpnvm_pos++)
705 {
706 if (((status >> (8 + gpnvm_pos))&(0x01)) == 1)
707 {
708 at91sam7_info->num_nvmbits_on++;
709 }
710 }
711
712 return ERROR_OK;
713 }
714
715 FLASH_BANK_COMMAND_HANDLER(at91sam7_flash_bank_command)
716 {
717 struct flash_bank *t_bank = bank;
718 struct at91sam7_flash_bank *at91sam7_info;
719 struct target *target = t_bank->target;
720
721 uint32_t base_address;
722 uint32_t bank_size;
723 uint32_t ext_freq = 0;
724
725 int chip_width;
726 int bus_width;
727 int banks_num;
728 int num_sectors;
729
730 uint16_t pages_per_sector;
731 uint16_t page_size;
732 uint16_t num_nvmbits;
733
734 char *target_name;
735
736 int bnk, sec;
737
738 at91sam7_info = malloc(sizeof(struct at91sam7_flash_bank));
739 t_bank->driver_priv = at91sam7_info;
740
741 /* part wasn't probed for info yet */
742 at91sam7_info->cidr = 0;
743 at91sam7_info->flashmode = 0;
744 at91sam7_info->ext_freq = 0;
745 at91sam7_info->flash_autodetection = 0;
746
747 if (CMD_ARGC < 13)
748 {
749 at91sam7_info->flash_autodetection = 1;
750 return ERROR_OK;
751 }
752
753 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], base_address);
754
755 COMMAND_PARSE_NUMBER(int, CMD_ARGV[3], chip_width);
756 COMMAND_PARSE_NUMBER(int, CMD_ARGV[4], bus_width);
757
758 COMMAND_PARSE_NUMBER(int, CMD_ARGV[8], banks_num);
759 COMMAND_PARSE_NUMBER(int, CMD_ARGV[9], num_sectors);
760 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[10], pages_per_sector);
761 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[11], page_size);
762 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[12], num_nvmbits);
763
764 if (CMD_ARGC == 14) {
765 unsigned long freq;
766 COMMAND_PARSE_NUMBER(ulong, CMD_ARGV[13], freq);
767 ext_freq = freq * 1000;
768 at91sam7_info->ext_freq = ext_freq;
769 }
770
771 if ((bus_width == 0) || (banks_num == 0) || (num_sectors == 0) ||
772 (pages_per_sector == 0) || (page_size == 0) || (num_nvmbits == 0))
773 {
774 at91sam7_info->flash_autodetection = 1;
775 return ERROR_OK;
776 }
777
778 target_name = calloc(strlen(CMD_ARGV[7]) + 1, sizeof(char));
779 strcpy(target_name, CMD_ARGV[7]);
780
781 /* calculate bank size */
782 bank_size = num_sectors * pages_per_sector * page_size;
783
784 for (bnk = 0; bnk < banks_num; bnk++)
785 {
786 if (bnk > 0)
787 {
788 /* create a new bank element */
789 struct flash_bank *fb = malloc(sizeof(struct flash_bank));
790 fb->target = target;
791 fb->driver = bank->driver;
792 fb->driver_priv = malloc(sizeof(struct at91sam7_flash_bank));
793 fb->next = NULL;
794
795 /* link created bank in 'flash_banks' list and redirect t_bank */
796 t_bank->next = fb;
797 t_bank = fb;
798 }
799
800 t_bank->bank_number = bnk;
801 t_bank->base = base_address + bnk * bank_size;
802 t_bank->size = bank_size;
803 t_bank->chip_width = chip_width;
804 t_bank->bus_width = bus_width;
805 t_bank->num_sectors = num_sectors;
806
807 /* allocate sectors */
808 t_bank->sectors = malloc(num_sectors * sizeof(struct flash_sector));
809 for (sec = 0; sec < num_sectors; sec++)
810 {
811 t_bank->sectors[sec].offset = sec * pages_per_sector * page_size;
812 t_bank->sectors[sec].size = pages_per_sector * page_size;
813 t_bank->sectors[sec].is_erased = -1;
814 t_bank->sectors[sec].is_protected = -1;
815 }
816
817 at91sam7_info = t_bank->driver_priv;
818
819 at91sam7_info->target_name = target_name;
820 at91sam7_info->flashmode = 0;
821 at91sam7_info->ext_freq = ext_freq;
822 at91sam7_info->num_nvmbits = num_nvmbits;
823 at91sam7_info->num_nvmbits_on = 0;
824 at91sam7_info->pagesize = page_size;
825 at91sam7_info->pages_per_sector = pages_per_sector;
826 }
827
828 return ERROR_OK;
829 }
830
831 static int at91sam7_erase(struct flash_bank *bank, int first, int last)
832 {
833 struct at91sam7_flash_bank *at91sam7_info = bank->driver_priv;
834 int sec;
835 uint32_t nbytes, pos;
836 uint8_t *buffer;
837 uint8_t erase_all;
838
839 if (at91sam7_info->cidr == 0)
840 {
841 return ERROR_FLASH_BANK_NOT_PROBED;
842 }
843
844 if (bank->target->state != TARGET_HALTED)
845 {
846 LOG_ERROR("Target not halted");
847 return ERROR_TARGET_NOT_HALTED;
848 }
849
850 if ((first < 0) || (last < first) || (last >= bank->num_sectors))
851 {
852 return ERROR_FLASH_SECTOR_INVALID;
853 }
854
855 erase_all = 0;
856 if ((first == 0) && (last == (bank->num_sectors-1)))
857 {
858 erase_all = 1;
859 }
860
861 /* Configure the flash controller timing */
862 at91sam7_read_clock_info(bank);
863 at91sam7_set_flash_mode(bank, FMR_TIMING_FLASH);
864
865 if (erase_all)
866 {
867 if (at91sam7_flash_command(bank, EA, 0) != ERROR_OK)
868 {
869 return ERROR_FLASH_OPERATION_FAILED;
870 }
871 }
872 else
873 {
874 /* allocate and clean buffer */
875 nbytes = (last - first + 1) * bank->sectors[first].size;
876 buffer = malloc(nbytes * sizeof(uint8_t));
877 for (pos = 0; pos < nbytes; pos++)
878 {
879 buffer[pos] = 0xFF;
880 }
881
882 if (at91sam7_write(bank, buffer, bank->sectors[first].offset, nbytes) != ERROR_OK)
883 {
884 return ERROR_FLASH_OPERATION_FAILED;
885 }
886
887 free(buffer);
888 }
889
890 /* mark erased sectors */
891 for (sec = first; sec <= last; sec++)
892 {
893 bank->sectors[sec].is_erased = 1;
894 }
895
896 return ERROR_OK;
897 }
898
899 static int at91sam7_protect(struct flash_bank *bank, int set, int first, int last)
900 {
901 uint32_t cmd;
902 int sector;
903 uint32_t pagen;
904
905 struct at91sam7_flash_bank *at91sam7_info = bank->driver_priv;
906
907 if (at91sam7_info->cidr == 0)
908 {
909 return ERROR_FLASH_BANK_NOT_PROBED;
910 }
911
912 if (bank->target->state != TARGET_HALTED)
913 {
914 LOG_ERROR("Target not halted");
915 return ERROR_TARGET_NOT_HALTED;
916 }
917
918 if ((first < 0) || (last < first) || (last >= bank->num_sectors))
919 {
920 return ERROR_FLASH_SECTOR_INVALID;
921 }
922
923 /* Configure the flash controller timing */
924 at91sam7_read_clock_info(bank);
925 at91sam7_set_flash_mode(bank, FMR_TIMING_NVBITS);
926
927 for (sector = first; sector <= last; sector++)
928 {
929 if (set)
930 cmd = SLB;
931 else
932 cmd = CLB;
933
934 /* if we lock a page from one sector then entire sector will be locked, also,
935 * if we unlock a page from a locked sector, entire sector will be unlocked */
936 pagen = sector * at91sam7_info->pages_per_sector;
937
938 if (at91sam7_flash_command(bank, cmd, pagen) != ERROR_OK)
939 {
940 return ERROR_FLASH_OPERATION_FAILED;
941 }
942 }
943
944 at91sam7_protect_check(bank);
945
946 return ERROR_OK;
947 }
948
949 static int at91sam7_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
950 {
951 int retval;
952 struct at91sam7_flash_bank *at91sam7_info = bank->driver_priv;
953 struct target *target = bank->target;
954 uint32_t dst_min_alignment, wcount, bytes_remaining = count;
955 uint32_t first_page, last_page, pagen, buffer_pos;
956
957 if (at91sam7_info->cidr == 0)
958 {
959 return ERROR_FLASH_BANK_NOT_PROBED;
960 }
961
962 if (bank->target->state != TARGET_HALTED)
963 {
964 LOG_ERROR("Target not halted");
965 return ERROR_TARGET_NOT_HALTED;
966 }
967
968 if (offset + count > bank->size)
969 return ERROR_FLASH_DST_OUT_OF_BANK;
970
971 dst_min_alignment = at91sam7_info->pagesize;
972
973 if (offset % dst_min_alignment)
974 {
975 LOG_WARNING("offset 0x%" PRIx32 " breaks required alignment 0x%" PRIx32 "", offset, dst_min_alignment);
976 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
977 }
978
979 if (at91sam7_info->cidr_arch == 0)
980 return ERROR_FLASH_BANK_NOT_PROBED;
981
982 first_page = offset/dst_min_alignment;
983 last_page = DIV_ROUND_UP(offset + count, dst_min_alignment);
984
985 LOG_DEBUG("first_page: %i, last_page: %i, count %i", (int)first_page, (int)last_page, (int)count);
986
987 /* Configure the flash controller timing */
988 at91sam7_read_clock_info(bank);
989 at91sam7_set_flash_mode(bank, FMR_TIMING_FLASH);
990
991 for (pagen = first_page; pagen < last_page; pagen++)
992 {
993 if (bytes_remaining < dst_min_alignment)
994 count = bytes_remaining;
995 else
996 count = dst_min_alignment;
997 bytes_remaining -= count;
998
999 /* Write one block to the PageWriteBuffer */
1000 buffer_pos = (pagen-first_page)*dst_min_alignment;
1001 wcount = DIV_ROUND_UP(count,4);
1002 if ((retval = target_write_memory(target, bank->base + pagen*dst_min_alignment, 4, wcount, buffer + buffer_pos)) != ERROR_OK)
1003 {
1004 return retval;
1005 }
1006
1007 /* Send Write Page command to Flash Controller */
1008 if (at91sam7_flash_command(bank, WP, pagen) != ERROR_OK)
1009 {
1010 return ERROR_FLASH_OPERATION_FAILED;
1011 }
1012 LOG_DEBUG("Write flash bank:%i page number:%" PRIi32 "", bank->bank_number, pagen);
1013 }
1014
1015 return ERROR_OK;
1016 }
1017
1018 static int at91sam7_probe(struct flash_bank *bank)
1019 {
1020 /* we can't probe on an at91sam7
1021 * if this is an at91sam7, it has the configured flash */
1022 int retval;
1023
1024 if (bank->target->state != TARGET_HALTED)
1025 {
1026 LOG_ERROR("Target not halted");
1027 return ERROR_TARGET_NOT_HALTED;
1028 }
1029
1030 retval = at91sam7_read_part_info(bank);
1031 if (retval != ERROR_OK)
1032 return retval;
1033
1034 return ERROR_OK;
1035 }
1036
1037 static int at91sam7_info(struct flash_bank *bank, char *buf, int buf_size)
1038 {
1039 int printed;
1040 struct at91sam7_flash_bank *at91sam7_info = bank->driver_priv;
1041
1042 if (at91sam7_info->cidr == 0)
1043 {
1044 return ERROR_FLASH_BANK_NOT_PROBED;
1045 }
1046
1047 printed = snprintf(buf, buf_size,
1048 "\n at91sam7 driver information: Chip is %s\n",
1049 at91sam7_info->target_name);
1050
1051 buf += printed;
1052 buf_size -= printed;
1053
1054 printed = snprintf(buf,
1055 buf_size,
1056 " Cidr: 0x%8.8" PRIx32 " | Arch: 0x%4.4x | Eproc: %s | Version: 0x%3.3x | Flashsize: 0x%8.8" PRIx32 "\n",
1057 at91sam7_info->cidr,
1058 at91sam7_info->cidr_arch,
1059 EPROC[at91sam7_info->cidr_eproc],
1060 at91sam7_info->cidr_version,
1061 bank->size);
1062
1063 buf += printed;
1064 buf_size -= printed;
1065
1066 printed = snprintf(buf, buf_size,
1067 " Master clock (estimated): %u KHz | External clock: %u KHz\n",
1068 (unsigned)(at91sam7_info->mck_freq / 1000), (unsigned)(at91sam7_info->ext_freq / 1000));
1069
1070 buf += printed;
1071 buf_size -= printed;
1072
1073 printed = snprintf(buf, buf_size,
1074 " Pagesize: %i bytes | Lockbits(%i): %i 0x%4.4x | Pages in lock region: %i \n",
1075 at91sam7_info->pagesize, bank->num_sectors, at91sam7_info->num_lockbits_on,
1076 at91sam7_info->lockbits, at91sam7_info->pages_per_sector*at91sam7_info->num_lockbits_on);
1077
1078 buf += printed;
1079 buf_size -= printed;
1080
1081 printed = snprintf(buf, buf_size,
1082 " Securitybit: %i | Nvmbits(%i): %i 0x%1.1x\n",
1083 at91sam7_info->securitybit, at91sam7_info->num_nvmbits,
1084 at91sam7_info->num_nvmbits_on, at91sam7_info->nvmbits);
1085
1086 buf += printed;
1087 buf_size -= printed;
1088
1089 return ERROR_OK;
1090 }
1091
1092 /*
1093 * On AT91SAM7S: When the gpnvm bits are set with
1094 * > at91sam7 gpnvm bitnr set
1095 * the changes are not visible in the flash controller status register MC_FSR
1096 * until the processor has been reset.
1097 * On the Olimex board this requires a power cycle.
1098 * Note that the AT91SAM7S has the following errata (doc6175.pdf sec 14.1.3):
1099 * The maximum number of write/erase cycles for Non volatile Memory bits is 100. this includes
1100 * Lock Bits (LOCKx), General Purpose NVM bits (GPNVMx) and the Security Bit.
1101 */
1102 COMMAND_HANDLER(at91sam7_handle_gpnvm_command)
1103 {
1104 struct flash_bank *bank;
1105 int bit;
1106 uint8_t flashcmd;
1107 uint32_t status;
1108 struct at91sam7_flash_bank *at91sam7_info;
1109 int retval;
1110
1111 if (CMD_ARGC != 2)
1112 {
1113 command_print(CMD_CTX, "at91sam7 gpnvm <bit> <set | clear>");
1114 return ERROR_OK;
1115 }
1116
1117 bank = get_flash_bank_by_num_noprobe(0);
1118 if (bank == NULL)
1119 {
1120 return ERROR_FLASH_BANK_INVALID;
1121 }
1122 if (strcmp(bank->driver->name, "at91sam7"))
1123 {
1124 command_print(CMD_CTX, "not an at91sam7 flash bank '%s'", CMD_ARGV[0]);
1125 return ERROR_FLASH_BANK_INVALID;
1126 }
1127 if (bank->target->state != TARGET_HALTED)
1128 {
1129 LOG_ERROR("target has to be halted to perform flash operation");
1130 return ERROR_TARGET_NOT_HALTED;
1131 }
1132
1133 if (strcmp(CMD_ARGV[1], "set") == 0)
1134 {
1135 flashcmd = SGPB;
1136 }
1137 else if (strcmp(CMD_ARGV[1], "clear") == 0)
1138 {
1139 flashcmd = CGPB;
1140 }
1141 else
1142 {
1143 return ERROR_COMMAND_SYNTAX_ERROR;
1144 }
1145
1146 at91sam7_info = bank->driver_priv;
1147 if (at91sam7_info->cidr == 0)
1148 {
1149 retval = at91sam7_read_part_info(bank);
1150 if (retval != ERROR_OK)
1151 {
1152 return retval;
1153 }
1154 }
1155
1156 COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], bit);
1157 if ((bit < 0) || (bit >= at91sam7_info->num_nvmbits))
1158 {
1159 command_print(CMD_CTX, "gpnvm bit '#%s' is out of bounds for target %s", CMD_ARGV[0], at91sam7_info->target_name);
1160 return ERROR_OK;
1161 }
1162
1163 /* Configure the flash controller timing */
1164 at91sam7_read_clock_info(bank);
1165 at91sam7_set_flash_mode(bank, FMR_TIMING_NVBITS);
1166
1167 if (at91sam7_flash_command(bank, flashcmd, bit) != ERROR_OK)
1168 {
1169 return ERROR_FLASH_OPERATION_FAILED;
1170 }
1171
1172 /* GPNVM and SECURITY bits apply only for MC_FSR of EFC0 */
1173 status = at91sam7_get_flash_status(bank->target, 0);
1174 LOG_DEBUG("at91sam7_handle_gpnvm_command: cmd 0x%x, value %d, status 0x%" PRIx32 " \n", flashcmd, bit, status);
1175
1176 /* check protect state */
1177 at91sam7_protect_check(bank);
1178
1179 return ERROR_OK;
1180 }
1181
1182 static const struct command_registration at91sam7_exec_command_handlers[] = {
1183 {
1184 .name = "gpnvm",
1185 .handler = at91sam7_handle_gpnvm_command,
1186 .mode = COMMAND_EXEC,
1187 .help = "set or clear one General Purpose Non-Volatile Memory "
1188 "(gpnvm) bit",
1189 .usage = "bitnum ('set'|'clear')",
1190 },
1191 COMMAND_REGISTRATION_DONE
1192 };
1193 static const struct command_registration at91sam7_command_handlers[] = {
1194 {
1195 .name = "at91sam7",
1196 .mode = COMMAND_ANY,
1197 .help = "at91sam7 flash command group",
1198 .chain = at91sam7_exec_command_handlers,
1199 },
1200 COMMAND_REGISTRATION_DONE
1201 };
1202
1203 struct flash_driver at91sam7_flash = {
1204 .name = "at91sam7",
1205 .commands = at91sam7_command_handlers,
1206 .flash_bank_command = at91sam7_flash_bank_command,
1207 .erase = at91sam7_erase,
1208 .protect = at91sam7_protect,
1209 .write = at91sam7_write,
1210 .read = default_flash_read,
1211 .probe = at91sam7_probe,
1212 .auto_probe = at91sam7_probe,
1213 .erase_check = at91sam7_erase_check,
1214 .protect_check = at91sam7_protect_check,
1215 .info = at91sam7_info,
1216 };
Marex's Cortex A8 development branch