1 /***************************************************************************
2 * (c) Copyright 2007, 2008 by Christopher Kilgour *
3 * techie |_at_| whiterocker |_dot_| com *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
30 int tms470_register_commands(struct command_context_s
*cmd_ctx
);
31 int tms470_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
, struct flash_bank_s
*bank
);
32 int tms470_erase(struct flash_bank_s
*bank
, int first
, int last
);
33 int tms470_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
);
34 int tms470_write(struct flash_bank_s
*bank
, u8
* buffer
, u32 offset
, u32 count
);
35 int tms470_probe(struct flash_bank_s
*bank
);
36 int tms470_auto_probe(struct flash_bank_s
*bank
);
37 int tms470_erase_check(struct flash_bank_s
*bank
);
38 int tms470_protect_check(struct flash_bank_s
*bank
);
39 int tms470_info(struct flash_bank_s
*bank
, char *buf
, int buf_size
);
41 flash_driver_t tms470_flash
= {
43 .register_commands
= tms470_register_commands
,
44 .flash_bank_command
= tms470_flash_bank_command
,
45 .erase
= tms470_erase
,
46 .protect
= tms470_protect
,
47 .write
= tms470_write
,
48 .probe
= tms470_probe
,
49 .auto_probe
= tms470_auto_probe
,
50 .erase_check
= tms470_erase_check
,
51 .protect_check
= tms470_protect_check
,
55 /* ----------------------------------------------------------------------
56 Internal Support, Helpers
57 ---------------------------------------------------------------------- */
59 const flash_sector_t TMS470R1A256_SECTORS
[] = {
60 {0x00000000, 0x00002000, -1, -1},
61 {0x00002000, 0x00002000, -1, -1},
62 {0x00004000, 0x00002000, -1, -1},
63 {0x00006000, 0x00002000, -1, -1},
64 {0x00008000, 0x00008000, -1, -1},
65 {0x00010000, 0x00008000, -1, -1},
66 {0x00018000, 0x00008000, -1, -1},
67 {0x00020000, 0x00008000, -1, -1},
68 {0x00028000, 0x00008000, -1, -1},
69 {0x00030000, 0x00008000, -1, -1},
70 {0x00038000, 0x00002000, -1, -1},
71 {0x0003A000, 0x00002000, -1, -1},
72 {0x0003C000, 0x00002000, -1, -1},
73 {0x0003E000, 0x00002000, -1, -1},
76 #define TMS470R1A256_NUM_SECTORS \
77 (sizeof(TMS470R1A256_SECTORS)/sizeof(TMS470R1A256_SECTORS[0]))
79 const flash_sector_t TMS470R1A288_BANK0_SECTORS
[] = {
80 {0x00000000, 0x00002000, -1, -1},
81 {0x00002000, 0x00002000, -1, -1},
82 {0x00004000, 0x00002000, -1, -1},
83 {0x00006000, 0x00002000, -1, -1},
86 #define TMS470R1A288_BANK0_NUM_SECTORS \
87 (sizeof(TMS470R1A288_BANK0_SECTORS)/sizeof(TMS470R1A288_BANK0_SECTORS[0]))
89 const flash_sector_t TMS470R1A288_BANK1_SECTORS
[] = {
90 {0x00040000, 0x00010000, -1, -1},
91 {0x00050000, 0x00010000, -1, -1},
92 {0x00060000, 0x00010000, -1, -1},
93 {0x00070000, 0x00010000, -1, -1},
96 #define TMS470R1A288_BANK1_NUM_SECTORS \
97 (sizeof(TMS470R1A288_BANK1_SECTORS)/sizeof(TMS470R1A288_BANK1_SECTORS[0]))
99 /* ---------------------------------------------------------------------- */
101 int tms470_read_part_info(struct flash_bank_s
*bank
)
103 tms470_flash_bank_t
*tms470_info
= bank
->driver_priv
;
104 target_t
*target
= bank
->target
;
105 u32 device_ident_reg
;
107 u32 technology_family
;
112 if (target
->state
!= TARGET_HALTED
)
114 WARNING("Cannot communicate... target not halted.");
115 return ERROR_TARGET_NOT_HALTED
;
118 /* read and parse the device identification register */
119 target_read_u32(target
, 0xFFFFFFF0, &device_ident_reg
);
121 INFO("device_ident_reg=0x%08x", device_ident_reg
);
123 if ((device_ident_reg
& 7) == 0)
125 WARNING("Cannot identify target as a TMS470 family.");
126 return ERROR_FLASH_OPERATION_FAILED
;
129 silicon_version
= (device_ident_reg
>> 12) & 0xF;
130 technology_family
= (device_ident_reg
>> 11) & 1;
131 rom_flash
= (device_ident_reg
>> 10) & 1;
132 part_number
= (device_ident_reg
>> 3) & 0x7f;
135 * If the part number is known, determine if the flash bank is valid
136 * based on the base address being within the known flash bank
137 * ranges. Then fixup/complete the remaining fields of the flash
143 part_name
= "TMS470R1A256";
145 if (bank
->base
>= 0x00040000)
147 ERROR("No %s flash bank contains base address 0x%08x.", part_name
, bank
->base
);
148 return ERROR_FLASH_OPERATION_FAILED
;
150 tms470_info
->ordinal
= 0;
151 bank
->base
= 0x00000000;
152 bank
->size
= 256 * 1024;
153 bank
->num_sectors
= TMS470R1A256_NUM_SECTORS
;
154 bank
->sectors
= malloc(sizeof(TMS470R1A256_SECTORS
));
157 return ERROR_FLASH_OPERATION_FAILED
;
159 (void)memcpy(bank
->sectors
, TMS470R1A256_SECTORS
, sizeof(TMS470R1A256_SECTORS
));
163 part_name
= "TMS470R1A288";
165 if ((bank
->base
>= 0x00000000) && (bank
->base
< 0x00008000))
167 tms470_info
->ordinal
= 0;
168 bank
->base
= 0x00000000;
169 bank
->size
= 32 * 1024;
170 bank
->num_sectors
= TMS470R1A288_BANK0_NUM_SECTORS
;
171 bank
->sectors
= malloc(sizeof(TMS470R1A288_BANK0_SECTORS
));
174 return ERROR_FLASH_OPERATION_FAILED
;
176 (void)memcpy(bank
->sectors
, TMS470R1A288_BANK0_SECTORS
, sizeof(TMS470R1A288_BANK0_SECTORS
));
178 else if ((bank
->base
>= 0x00040000) && (bank
->base
< 0x00080000))
180 tms470_info
->ordinal
= 1;
181 bank
->base
= 0x00040000;
182 bank
->size
= 256 * 1024;
183 bank
->num_sectors
= TMS470R1A288_BANK1_NUM_SECTORS
;
184 bank
->sectors
= malloc(sizeof(TMS470R1A288_BANK1_SECTORS
));
187 return ERROR_FLASH_OPERATION_FAILED
;
189 (void)memcpy(bank
->sectors
, TMS470R1A288_BANK1_SECTORS
, sizeof(TMS470R1A288_BANK1_SECTORS
));
193 ERROR("No %s flash bank contains base address 0x%08x.", part_name
, bank
->base
);
194 return ERROR_FLASH_OPERATION_FAILED
;
199 WARNING("Could not identify part 0x%02x as a member of the TMS470 family.", part_number
);
200 return ERROR_FLASH_OPERATION_FAILED
;
203 /* turn off memory selects */
204 target_write_u32(target
, 0xFFFFFFE4, 0x00000000);
205 target_write_u32(target
, 0xFFFFFFE0, 0x00000000);
207 bank
->chip_width
= 32;
208 bank
->bus_width
= 32;
210 INFO("Identified %s, ver=%d, core=%s, nvmem=%s.", part_name
, silicon_version
, (technology_family
? "1.8v" : "3.3v"), (rom_flash
? "rom" : "flash"));
212 tms470_info
->device_ident_reg
= device_ident_reg
;
213 tms470_info
->silicon_version
= silicon_version
;
214 tms470_info
->technology_family
= technology_family
;
215 tms470_info
->rom_flash
= rom_flash
;
216 tms470_info
->part_number
= part_number
;
217 tms470_info
->part_name
= part_name
;
220 * Disable reset on address access violation.
222 target_write_u32(target
, 0xFFFFFFE0, 0x00004007);
227 /* ---------------------------------------------------------------------- */
232 int tms470_handle_flash_keyset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
236 command_print(cmd_ctx
, "tms470 flash_keyset <key0> <key1> <key2> <key3>");
237 return ERROR_INVALID_ARGUMENTS
;
243 for (i
= 0; i
< 4; i
++)
245 int start
= (0 == strncmp(args
[i
], "0x", 2)) ? 2 : 0;
247 if (1 != sscanf(&args
[i
][start
], "%x", &flashKeys
[i
]))
249 command_print(cmd_ctx
, "could not process flash key %s", args
[i
]);
250 ERROR("could not process flash key %s", args
[i
]);
251 return ERROR_INVALID_ARGUMENTS
;
259 command_print(cmd_ctx
, "tms470 flash_keyset <key0> <key1> <key2> <key3>");
260 return ERROR_INVALID_ARGUMENTS
;
265 command_print(cmd_ctx
, "using flash keys 0x%08x, 0x%08x, 0x%08x, 0x%08x", flashKeys
[0], flashKeys
[1], flashKeys
[2], flashKeys
[3]);
269 command_print(cmd_ctx
, "flash keys not set");
275 const u32 FLASH_KEYS_ALL_ONES
[] = { 0xFFFFFFFF, 0xFFFFFFFF,
276 0xFFFFFFFF, 0xFFFFFFFF,
279 const u32 FLASH_KEYS_ALL_ZEROS
[] = { 0x00000000, 0x00000000,
280 0x00000000, 0x00000000,
283 const u32 FLASH_KEYS_MIX1
[] = { 0xf0fff0ff, 0xf0fff0ff,
284 0xf0fff0ff, 0xf0fff0ff
287 const u32 FLASH_KEYS_MIX2
[] = { 0x0000ffff, 0x0000ffff,
288 0x0000ffff, 0x0000ffff
291 /* ---------------------------------------------------------------------- */
295 int tms470_handle_osc_megahertz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
299 command_print(cmd_ctx
, "tms470 osc_megahertz <MHz>");
300 return ERROR_INVALID_ARGUMENTS
;
304 sscanf(args
[0], "%d", &oscMHz
);
309 ERROR("osc_megahertz must be positive and non-zero!");
310 command_print(cmd_ctx
, "osc_megahertz must be positive and non-zero!");
312 return ERROR_INVALID_ARGUMENTS
;
315 command_print(cmd_ctx
, "osc_megahertz=%d", oscMHz
);
320 /* ---------------------------------------------------------------------- */
324 int tms470_handle_plldis_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
328 command_print(cmd_ctx
, "tms470 plldis <0|1>");
329 return ERROR_INVALID_ARGUMENTS
;
333 sscanf(args
[0], "%d", &plldis
);
334 plldis
= plldis
? 1 : 0;
337 command_print(cmd_ctx
, "plldis=%d", plldis
);
342 /* ---------------------------------------------------------------------- */
344 int tms470_check_flash_unlocked(target_t
* target
)
348 target_read_u32(target
, 0xFFE89C08, &fmbbusy
);
349 INFO("tms470 fmbbusy=0x%08x -> %s", fmbbusy
, fmbbusy
& 0x8000 ? "unlocked" : "LOCKED");
350 return fmbbusy
& 0x8000 ? ERROR_OK
: ERROR_FLASH_OPERATION_FAILED
;
353 /* ---------------------------------------------------------------------- */
355 int tms470_try_flash_keys(target_t
* target
, const u32
* key_set
)
357 u32 glbctrl
, fmmstat
;
358 int retval
= ERROR_FLASH_OPERATION_FAILED
;
361 target_read_u32(target
, 0xFFFFFFDC, &glbctrl
);
362 target_write_u32(target
, 0xFFFFFFDC, glbctrl
| 0x10);
364 /* only perform the key match when 3VSTAT is clear */
365 target_read_u32(target
, 0xFFE8BC0C, &fmmstat
);
366 if (!(fmmstat
& 0x08))
369 u32 fmbptr
, fmbac2
, orig_fmregopt
;
371 target_write_u32(target
, 0xFFE8BC04, fmmstat
& ~0x07);
373 /* wait for pump ready */
376 target_read_u32(target
, 0xFFE8A814, &fmbptr
);
379 while (!(fmbptr
& 0x0200));
381 /* force max wait states */
382 target_read_u32(target
, 0xFFE88004, &fmbac2
);
383 target_write_u32(target
, 0xFFE88004, fmbac2
| 0xff);
385 /* save current access mode, force normal read mode */
386 target_read_u32(target
, 0xFFE89C00, &orig_fmregopt
);
387 target_write_u32(target
, 0xFFE89C00, 0x00);
389 for (i
= 0; i
< 4; i
++)
393 /* There is no point displaying the value of tmp, it is
394 * filtered by the chip. The purpose of this read is to
395 * prime the unlocking logic rather than read out the value.
397 target_read_u32(target
, 0x00001FF0 + 4 * i
, &tmp
);
399 INFO("tms470 writing fmpkey=0x%08x", key_set
[i
]);
400 target_write_u32(target
, 0xFFE89C0C, key_set
[i
]);
403 if (ERROR_OK
== tms470_check_flash_unlocked(target
))
406 * There seems to be a side-effect of reading the FMPKEY
407 * register in that it re-enables the protection. So we
410 for (i
= 0; i
< 4; i
++)
414 target_read_u32(target
, 0x00001FF0 + 4 * i
, &tmp
);
415 target_write_u32(target
, 0xFFE89C0C, key_set
[i
]);
420 /* restore settings */
421 target_write_u32(target
, 0xFFE89C00, orig_fmregopt
);
422 target_write_u32(target
, 0xFFE88004, fmbac2
);
425 /* clear config bit */
426 target_write_u32(target
, 0xFFFFFFDC, glbctrl
);
431 /* ---------------------------------------------------------------------- */
433 int tms470_unlock_flash(struct flash_bank_s
*bank
)
435 target_t
*target
= bank
->target
;
436 const u32
*p_key_sets
[5];
437 unsigned i
, key_set_count
;
441 p_key_sets
[0] = flashKeys
;
442 p_key_sets
[1] = FLASH_KEYS_ALL_ONES
;
443 p_key_sets
[2] = FLASH_KEYS_ALL_ZEROS
;
444 p_key_sets
[3] = FLASH_KEYS_MIX1
;
445 p_key_sets
[4] = FLASH_KEYS_MIX2
;
450 p_key_sets
[0] = FLASH_KEYS_ALL_ONES
;
451 p_key_sets
[1] = FLASH_KEYS_ALL_ZEROS
;
452 p_key_sets
[2] = FLASH_KEYS_MIX1
;
453 p_key_sets
[3] = FLASH_KEYS_MIX2
;
456 for (i
= 0; i
< key_set_count
; i
++)
458 if (tms470_try_flash_keys(target
, p_key_sets
[i
]) == ERROR_OK
)
460 INFO("tms470 flash is unlocked");
465 WARNING("tms470 could not unlock flash memory protection level 2");
466 return ERROR_FLASH_OPERATION_FAILED
;
469 /* ---------------------------------------------------------------------- */
471 int tms470_flash_initialize_internal_state_machine(struct flash_bank_s
*bank
)
473 u32 fmmac2
, fmmac1
, fmmaxep
, k
, delay
, glbctrl
, sysclk
;
474 target_t
*target
= bank
->target
;
475 tms470_flash_bank_t
*tms470_info
= bank
->driver_priv
;
476 int result
= ERROR_OK
;
479 * Select the desired bank to be programmed by writing BANK[2:0] of
482 target_read_u32(target
, 0xFFE8BC04, &fmmac2
);
484 fmmac2
|= (tms470_info
->ordinal
& 7);
485 target_write_u32(target
, 0xFFE8BC04, fmmac2
);
486 DEBUG("set fmmac2=0x%04x", fmmac2
);
489 * Disable level 1 sector protection by setting bit 15 of FMMAC1.
491 target_read_u32(target
, 0xFFE8BC00, &fmmac1
);
493 target_write_u32(target
, 0xFFE8BC00, fmmac1
);
494 DEBUG("set fmmac1=0x%04x", fmmac1
);
499 target_write_u32(target
, 0xFFE8BC10, 0x2fc0);
500 DEBUG("set fmtcreg=0x2fc0");
505 target_write_u32(target
, 0xFFE8A07C, 50);
506 DEBUG("set fmmaxpp=50");
511 target_write_u32(target
, 0xFFE8A084, 0xf000 + 2000);
512 DEBUG("set fmmaxcp=0x%04x", 0xf000 + 2000);
517 target_read_u32(target
, 0xFFE8A080, &fmmaxep
);
518 if (fmmaxep
== 0xf000)
520 fmmaxep
= 0xf000 + 4095;
521 target_write_u32(target
, 0xFFE8A80C, 0x9964);
522 DEBUG("set fmptr3=0x9964");
526 fmmaxep
= 0xa000 + 4095;
527 target_write_u32(target
, 0xFFE8A80C, 0x9b64);
528 DEBUG("set fmptr3=0x9b64");
530 target_write_u32(target
, 0xFFE8A080, fmmaxep
);
531 DEBUG("set fmmaxep=0x%04x", fmmaxep
);
536 target_write_u32(target
, 0xFFE8A810, 0xa000);
537 DEBUG("set fmptr4=0xa000");
540 * FMPESETUP, delay parameter selected based on clock frequency.
542 * According to the TI App Note SPNU257 and flashing code, delay is
543 * int((sysclk(MHz) + 1) / 2), with a minimum of 5. The system
544 * clock is usually derived from the ZPLL module, and selected by
547 target_read_u32(target
, 0xFFFFFFDC, &glbctrl
);
548 sysclk
= (plldis
? 1 : (glbctrl
& 0x08) ? 4 : 8) * oscMHz
/ (1 + (glbctrl
& 7));
549 delay
= (sysclk
> 10) ? (sysclk
+ 1) / 2 : 5;
550 target_write_u32(target
, 0xFFE8A018, (delay
<< 4) | (delay
<< 8));
551 DEBUG("set fmpsetup=0x%04x", (delay
<< 4) | (delay
<< 8));
554 * FMPVEVACCESS, based on delay.
556 k
= delay
| (delay
<< 8);
557 target_write_u32(target
, 0xFFE8A05C, k
);
558 DEBUG("set fmpvevaccess=0x%04x", k
);
561 * FMPCHOLD, FMPVEVHOLD, FMPVEVSETUP, based on delay.
564 target_write_u32(target
, 0xFFE8A034, k
);
565 DEBUG("set fmpchold=0x%04x", k
);
566 target_write_u32(target
, 0xFFE8A040, k
);
567 DEBUG("set fmpvevhold=0x%04x", k
);
568 target_write_u32(target
, 0xFFE8A024, k
);
569 DEBUG("set fmpvevsetup=0x%04x", k
);
572 * FMCVACCESS, based on delay.
575 target_write_u32(target
, 0xFFE8A060, k
);
576 DEBUG("set fmcvaccess=0x%04x", k
);
579 * FMCSETUP, based on delay.
581 k
= 0x3000 | delay
* 20;
582 target_write_u32(target
, 0xFFE8A020, k
);
583 DEBUG("set fmcsetup=0x%04x", k
);
586 * FMEHOLD, based on delay.
588 k
= (delay
* 20) << 2;
589 target_write_u32(target
, 0xFFE8A038, k
);
590 DEBUG("set fmehold=0x%04x", k
);
593 * PWIDTH, CWIDTH, EWIDTH, based on delay.
595 target_write_u32(target
, 0xFFE8A050, delay
* 8);
596 DEBUG("set fmpwidth=0x%04x", delay
* 8);
597 target_write_u32(target
, 0xFFE8A058, delay
* 1000);
598 DEBUG("set fmcwidth=0x%04x", delay
* 1000);
599 target_write_u32(target
, 0xFFE8A054, delay
* 5400);
600 DEBUG("set fmewidth=0x%04x", delay
* 5400);
605 /* ---------------------------------------------------------------------- */
607 int tms470_flash_status(struct flash_bank_s
*bank
)
609 target_t
*target
= bank
->target
;
610 int result
= ERROR_OK
;
613 target_read_u32(target
, 0xFFE8BC0C, &fmmstat
);
614 DEBUG("set fmmstat=0x%04x", fmmstat
);
616 if (fmmstat
& 0x0080)
618 WARNING("tms470 flash command: erase still active after busy clear.");
619 result
= ERROR_FLASH_OPERATION_FAILED
;
622 if (fmmstat
& 0x0040)
624 WARNING("tms470 flash command: program still active after busy clear.");
625 result
= ERROR_FLASH_OPERATION_FAILED
;
628 if (fmmstat
& 0x0020)
630 WARNING("tms470 flash command: invalid data command.");
631 result
= ERROR_FLASH_OPERATION_FAILED
;
634 if (fmmstat
& 0x0010)
636 WARNING("tms470 flash command: program, erase or validate sector failed.");
637 result
= ERROR_FLASH_OPERATION_FAILED
;
640 if (fmmstat
& 0x0008)
642 WARNING("tms470 flash command: voltage instability detected.");
643 result
= ERROR_FLASH_OPERATION_FAILED
;
646 if (fmmstat
& 0x0006)
648 WARNING("tms470 flash command: command suspend detected.");
649 result
= ERROR_FLASH_OPERATION_FAILED
;
652 if (fmmstat
& 0x0001)
654 WARNING("tms470 flash command: sector was locked.");
655 result
= ERROR_FLASH_OPERATION_FAILED
;
661 /* ---------------------------------------------------------------------- */
663 int tms470_erase_sector(struct flash_bank_s
*bank
, int sector
)
665 u32 glbctrl
, orig_fmregopt
, fmbsea
, fmbseb
, fmmstat
;
666 target_t
*target
= bank
->target
;
667 u32 flashAddr
= bank
->base
+ bank
->sectors
[sector
].offset
;
668 int result
= ERROR_OK
;
671 * Set the bit GLBCTRL4 of the GLBCTRL register (in the System
672 * module) to enable writing to the flash registers }.
674 target_read_u32(target
, 0xFFFFFFDC, &glbctrl
);
675 target_write_u32(target
, 0xFFFFFFDC, glbctrl
| 0x10);
676 DEBUG("set glbctrl=0x%08x", glbctrl
| 0x10);
678 /* Force normal read mode. */
679 target_read_u32(target
, 0xFFE89C00, &orig_fmregopt
);
680 target_write_u32(target
, 0xFFE89C00, 0);
681 DEBUG("set fmregopt=0x%08x", 0);
683 (void)tms470_flash_initialize_internal_state_machine(bank
);
686 * Select one or more bits in FMBSEA or FMBSEB to disable Level 1
687 * protection for the particular sector to be erased/written.
691 target_read_u32(target
, 0xFFE88008, &fmbsea
);
692 target_write_u32(target
, 0xFFE88008, fmbsea
| (1 << sector
));
693 DEBUG("set fmbsea=0x%04x", fmbsea
| (1 << sector
));
697 target_read_u32(target
, 0xFFE8800C, &fmbseb
);
698 target_write_u32(target
, 0xFFE8800C, fmbseb
| (1 << (sector
- 16)));
699 DEBUG("set fmbseb=0x%04x", fmbseb
| (1 << (sector
- 16)));
701 bank
->sectors
[sector
].is_protected
= 0;
704 * clear status regiser, sent erase command, kickoff erase
706 target_write_u16(target
, flashAddr
, 0x0040);
707 DEBUG("write *(u16 *)0x%08x=0x0040", flashAddr
);
708 target_write_u16(target
, flashAddr
, 0x0020);
709 DEBUG("write *(u16 *)0x%08x=0x0020", flashAddr
);
710 target_write_u16(target
, flashAddr
, 0xffff);
711 DEBUG("write *(u16 *)0x%08x=0xffff", flashAddr
);
714 * Monitor FMMSTAT, busy until clear, then check and other flags for
715 * ultimate result of the operation.
719 target_read_u32(target
, 0xFFE8BC0C, &fmmstat
);
720 if (fmmstat
& 0x0100)
725 while (fmmstat
& 0x0100);
727 result
= tms470_flash_status(bank
);
731 target_write_u32(target
, 0xFFE88008, fmbsea
);
732 DEBUG("set fmbsea=0x%04x", fmbsea
);
733 bank
->sectors
[sector
].is_protected
= fmbsea
& (1 << sector
) ? 0 : 1;
737 target_write_u32(target
, 0xFFE8800C, fmbseb
);
738 DEBUG("set fmbseb=0x%04x", fmbseb
);
739 bank
->sectors
[sector
].is_protected
= fmbseb
& (1 << (sector
- 16)) ? 0 : 1;
741 target_write_u32(target
, 0xFFE89C00, orig_fmregopt
);
742 DEBUG("set fmregopt=0x%08x", orig_fmregopt
);
743 target_write_u32(target
, 0xFFFFFFDC, glbctrl
);
744 DEBUG("set glbctrl=0x%08x", glbctrl
);
746 if (result
== ERROR_OK
)
748 bank
->sectors
[sector
].is_erased
= 1;
754 /* ----------------------------------------------------------------------
755 Implementation of Flash Driver Interfaces
756 ---------------------------------------------------------------------- */
758 int tms470_register_commands(struct command_context_s
*cmd_ctx
)
760 command_t
*tms470_cmd
= register_command(cmd_ctx
, NULL
, "tms470", NULL
, COMMAND_ANY
, "applies to TI tms470 family");
762 register_command(cmd_ctx
, tms470_cmd
, "flash_keyset", tms470_handle_flash_keyset_command
, COMMAND_ANY
, "tms470 flash_keyset <key0> <key1> <key2> <key3>");
763 register_command(cmd_ctx
, tms470_cmd
, "osc_megahertz", tms470_handle_osc_megahertz_command
, COMMAND_ANY
, "tms470 osc_megahertz <MHz>");
764 register_command(cmd_ctx
, tms470_cmd
, "plldis", tms470_handle_plldis_command
, COMMAND_ANY
, "tms470 plldis <0/1>");
769 /* ---------------------------------------------------------------------- */
771 int tms470_erase(struct flash_bank_s
*bank
, int first
, int last
)
773 tms470_flash_bank_t
*tms470_info
= bank
->driver_priv
;
774 int sector
, result
= ERROR_OK
;
776 if (!tms470_info
->device_ident_reg
)
778 tms470_read_part_info(bank
);
781 if ((first
< 0) || (first
>= bank
->num_sectors
) || (last
< 0) || (last
>= bank
->num_sectors
) || (first
> last
))
783 ERROR("Sector range %d to %d invalid.", first
, last
);
784 return ERROR_FLASH_SECTOR_INVALID
;
787 result
= tms470_unlock_flash(bank
);
788 if (result
!= ERROR_OK
)
793 for (sector
= first
; sector
<= last
; sector
++)
795 INFO("Erasing tms470 bank %d sector %d...", tms470_info
->ordinal
, sector
);
797 result
= tms470_erase_sector(bank
, sector
);
799 if (result
!= ERROR_OK
)
801 ERROR("tms470 could not erase flash sector.");
806 INFO("sector erased successfully.");
813 /* ---------------------------------------------------------------------- */
815 int tms470_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
817 tms470_flash_bank_t
*tms470_info
= bank
->driver_priv
;
818 target_t
*target
= bank
->target
;
819 u32 fmmac2
, fmbsea
, fmbseb
;
822 if (!tms470_info
->device_ident_reg
)
824 tms470_read_part_info(bank
);
827 if ((first
< 0) || (first
>= bank
->num_sectors
) || (last
< 0) || (last
>= bank
->num_sectors
) || (first
> last
))
829 ERROR("Sector range %d to %d invalid.", first
, last
);
830 return ERROR_FLASH_SECTOR_INVALID
;
833 /* enable the appropriate bank */
834 target_read_u32(target
, 0xFFE8BC04, &fmmac2
);
835 target_write_u32(target
, 0xFFE8BC04, (fmmac2
& ~7) | tms470_info
->ordinal
);
837 /* get the original sector proection flags for this bank */
838 target_read_u32(target
, 0xFFE88008, &fmbsea
);
839 target_read_u32(target
, 0xFFE8800C, &fmbseb
);
841 for (sector
= 0; sector
< bank
->num_sectors
; sector
++)
845 fmbsea
= set
? fmbsea
& ~(1 << sector
) : fmbsea
| (1 << sector
);
846 bank
->sectors
[sector
].is_protected
= set
? 1 : 0;
850 fmbseb
= set
? fmbseb
& ~(1 << (sector
- 16)) : fmbseb
| (1 << (sector
- 16));
851 bank
->sectors
[sector
].is_protected
= set
? 1 : 0;
855 /* update the protection bits */
856 target_write_u32(target
, 0xFFE88008, fmbsea
);
857 target_write_u32(target
, 0xFFE8800C, fmbseb
);
862 /* ---------------------------------------------------------------------- */
864 int tms470_write(struct flash_bank_s
*bank
, u8
* buffer
, u32 offset
, u32 count
)
866 target_t
*target
= bank
->target
;
867 tms470_flash_bank_t
*tms470_info
= bank
->driver_priv
;
868 u32 glbctrl
, fmbac2
, orig_fmregopt
, fmbsea
, fmbseb
, fmmaxpp
, fmmstat
;
869 int i
, result
= ERROR_OK
;
871 if (!tms470_info
->device_ident_reg
)
873 tms470_read_part_info(bank
);
876 INFO("Writing %d bytes starting at 0x%08x", count
, bank
->base
+ offset
);
879 target_read_u32(target
, 0xFFFFFFDC, &glbctrl
);
880 target_write_u32(target
, 0xFFFFFFDC, glbctrl
| 0x10);
882 (void)tms470_flash_initialize_internal_state_machine(bank
);
884 /* force max wait states */
885 target_read_u32(target
, 0xFFE88004, &fmbac2
);
886 target_write_u32(target
, 0xFFE88004, fmbac2
| 0xff);
888 /* save current access mode, force normal read mode */
889 target_read_u32(target
, 0xFFE89C00, &orig_fmregopt
);
890 target_write_u32(target
, 0xFFE89C00, 0x00);
893 * Disable Level 1 protection for all sectors to be erased/written.
895 target_read_u32(target
, 0xFFE88008, &fmbsea
);
896 target_write_u32(target
, 0xFFE88008, 0xffff);
897 target_read_u32(target
, 0xFFE8800C, &fmbseb
);
898 target_write_u32(target
, 0xFFE8800C, 0xffff);
901 target_read_u32(target
, 0xFFE8A07C, &fmmaxpp
);
903 for (i
= 0; i
< count
; i
+= 2)
905 u32 addr
= bank
->base
+ offset
+ i
;
906 u16 word
= (((u16
) buffer
[i
]) << 8) | (u16
) buffer
[i
+ 1];
910 INFO("writing 0x%04x at 0x%08x", word
, addr
);
912 /* clear status register */
913 target_write_u16(target
, addr
, 0x0040);
914 /* program flash command */
915 target_write_u16(target
, addr
, 0x0010);
916 /* burn the 16-bit word (big-endian) */
917 target_write_u16(target
, addr
, word
);
920 * Monitor FMMSTAT, busy until clear, then check and other flags
921 * for ultimate result of the operation.
925 target_read_u32(target
, 0xFFE8BC0C, &fmmstat
);
926 if (fmmstat
& 0x0100)
931 while (fmmstat
& 0x0100);
935 ERROR("fmstat=0x%04x", fmmstat
);
936 ERROR("Could not program word 0x%04x at address 0x%08x.", word
, addr
);
937 result
= ERROR_FLASH_OPERATION_FAILED
;
943 INFO("skipping 0xffff at 0x%08x", addr
);
948 target_write_u32(target
, 0xFFE88008, fmbsea
);
949 target_write_u32(target
, 0xFFE8800C, fmbseb
);
950 target_write_u32(target
, 0xFFE88004, fmbac2
);
951 target_write_u32(target
, 0xFFE89C00, orig_fmregopt
);
952 target_write_u32(target
, 0xFFFFFFDC, glbctrl
);
957 /* ---------------------------------------------------------------------- */
959 int tms470_probe(struct flash_bank_s
*bank
)
961 tms470_flash_bank_t
*tms470_info
= bank
->driver_priv
;
963 tms470_info
->probed
= 0;
965 if (!tms470_info
->device_ident_reg
)
967 tms470_read_part_info(bank
);
970 tms470_info
->probed
= 1;
975 int tms470_auto_probe(struct flash_bank_s
*bank
)
977 tms470_flash_bank_t
*tms470_info
= bank
->driver_priv
;
979 if (tms470_info
->probed
)
981 return tms470_probe(bank
);
984 /* ---------------------------------------------------------------------- */
986 int tms470_erase_check(struct flash_bank_s
*bank
)
988 target_t
*target
= bank
->target
;
989 tms470_flash_bank_t
*tms470_info
= bank
->driver_priv
;
990 int sector
, result
= ERROR_OK
;
991 u32 fmmac2
, fmbac2
, glbctrl
, orig_fmregopt
;
992 static u8 buffer
[64 * 1024];
994 if (!tms470_info
->device_ident_reg
)
996 tms470_read_part_info(bank
);
1000 target_read_u32(target
, 0xFFFFFFDC, &glbctrl
);
1001 target_write_u32(target
, 0xFFFFFFDC, glbctrl
| 0x10);
1003 /* save current access mode, force normal read mode */
1004 target_read_u32(target
, 0xFFE89C00, &orig_fmregopt
);
1005 target_write_u32(target
, 0xFFE89C00, 0x00);
1007 /* enable the appropriate bank */
1008 target_read_u32(target
, 0xFFE8BC04, &fmmac2
);
1009 target_write_u32(target
, 0xFFE8BC04, (fmmac2
& ~7) | tms470_info
->ordinal
);
1012 target_write_u32(target
, 0xFFE8BC10, 0x2fc0);
1014 /* clear TEZ in fmbrdy */
1015 target_write_u32(target
, 0xFFE88010, 0x0b);
1017 /* save current wait states, force max */
1018 target_read_u32(target
, 0xFFE88004, &fmbac2
);
1019 target_write_u32(target
, 0xFFE88004, fmbac2
| 0xff);
1022 * The TI primitives inspect the flash memory by reading one 32-bit
1023 * word at a time. Here we read an entire sector and inspect it in
1024 * an attempt to reduce the JTAG overhead.
1026 for (sector
= 0; sector
< bank
->num_sectors
; sector
++)
1028 if (bank
->sectors
[sector
].is_erased
!= 1)
1030 u32 i
, addr
= bank
->base
+ bank
->sectors
[sector
].offset
;
1032 INFO("checking flash bank %d sector %d", tms470_info
->ordinal
, sector
);
1034 target_read_buffer(target
, addr
, bank
->sectors
[sector
].size
, buffer
);
1036 bank
->sectors
[sector
].is_erased
= 1;
1037 for (i
= 0; i
< bank
->sectors
[sector
].size
; i
++)
1039 if (buffer
[i
] != 0xff)
1041 WARNING("tms470 bank %d, sector %d, not erased.", tms470_info
->ordinal
, sector
);
1042 WARNING("at location 0x%08x: flash data is 0x%02x.", addr
+ i
, buffer
[i
]);
1044 bank
->sectors
[sector
].is_erased
= 0;
1049 if (bank
->sectors
[sector
].is_erased
!= 1)
1051 result
= ERROR_FLASH_SECTOR_NOT_ERASED
;
1056 INFO("sector erased");
1060 /* reset TEZ, wait states, read mode, GLBCTRL.4 */
1061 target_write_u32(target
, 0xFFE88010, 0x0f);
1062 target_write_u32(target
, 0xFFE88004, fmbac2
);
1063 target_write_u32(target
, 0xFFE89C00, orig_fmregopt
);
1064 target_write_u32(target
, 0xFFFFFFDC, glbctrl
);
1069 /* ---------------------------------------------------------------------- */
1071 int tms470_protect_check(struct flash_bank_s
*bank
)
1073 target_t
*target
= bank
->target
;
1074 tms470_flash_bank_t
*tms470_info
= bank
->driver_priv
;
1075 int sector
, result
= ERROR_OK
;
1076 u32 fmmac2
, fmbsea
, fmbseb
;
1078 if (!tms470_info
->device_ident_reg
)
1080 tms470_read_part_info(bank
);
1083 /* enable the appropriate bank */
1084 target_read_u32(target
, 0xFFE8BC04, &fmmac2
);
1085 target_write_u32(target
, 0xFFE8BC04, (fmmac2
& ~7) | tms470_info
->ordinal
);
1087 target_read_u32(target
, 0xFFE88008, &fmbsea
);
1088 target_read_u32(target
, 0xFFE8800C, &fmbseb
);
1090 for (sector
= 0; sector
< bank
->num_sectors
; sector
++)
1096 protected = fmbsea
& (1 << sector
) ? 0 : 1;
1097 bank
->sectors
[sector
].is_protected
= protected;
1101 protected = fmbseb
& (1 << (sector
- 16)) ? 0 : 1;
1102 bank
->sectors
[sector
].is_protected
= protected;
1105 DEBUG("bank %d sector %d is %s", tms470_info
->ordinal
, sector
, protected ? "protected" : "not protected");
1111 /* ---------------------------------------------------------------------- */
1113 int tms470_info(struct flash_bank_s
*bank
, char *buf
, int buf_size
)
1116 tms470_flash_bank_t
*tms470_info
= bank
->driver_priv
;
1118 if (!tms470_info
->device_ident_reg
)
1120 tms470_read_part_info(bank
);
1123 if (!tms470_info
->device_ident_reg
)
1125 (void)snprintf(buf
, buf_size
, "Cannot identify target as a TMS470\n");
1126 return ERROR_FLASH_OPERATION_FAILED
;
1129 used
+= snprintf(buf
, buf_size
, "\ntms470 information: Chip is %s\n", tms470_info
->part_name
);
1133 used
+= snprintf(buf
, buf_size
, "Flash protection level 2 is %s\n", tms470_check_flash_unlocked(bank
->target
) == ERROR_OK
? "disabled" : "enabled");
1140 /* ---------------------------------------------------------------------- */
1143 * flash bank tms470 <base> <size> <chip_width> <bus_width> <target>
1147 int tms470_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
, struct flash_bank_s
*bank
)
1149 bank
->driver_priv
= malloc(sizeof(tms470_flash_bank_t
));
1151 if (!bank
->driver_priv
)
1153 return ERROR_FLASH_OPERATION_FAILED
;
1156 (void)memset(bank
->driver_priv
, 0, sizeof(tms470_flash_bank_t
));
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)