73 #define FCF_ADDRESS 0x00000400
77 #define FCF_FDPROT 0xf
80 #define FLEXRAM 0x14000000
82 #define MSCM_OCMDR0 0x40001400
83 #define FMC_PFB01CR 0x4001f004
84 #define FTFX_FSTAT 0x40020000
85 #define FTFX_FCNFG 0x40020001
86 #define FTFX_FCCOB3 0x40020004
87 #define FTFX_FPROT3 0x40020010
88 #define FTFX_FDPROT 0x40020017
89 #define SIM_BASE 0x40047000
90 #define SIM_BASE_KL28 0x40074000
91 #define SIM_COPC 0x40048100
93 #define WDOG_BASE 0x40052000
94 #define WDOG32_KE1X 0x40052000
95 #define WDOG32_KL28 0x40076000
96 #define SMC_PMCTRL 0x4007E001
97 #define SMC_PMSTAT 0x4007E003
98 #define SMC32_PMCTRL 0x4007E00C
99 #define SMC32_PMSTAT 0x4007E014
100 #define PMC_REGSC 0x4007D002
101 #define MC_PMCTRL 0x4007E003
102 #define MCM_PLACR 0xF000300C
105 #define SIM_SOPT1_OFFSET 0x0000
106 #define SIM_SDID_OFFSET 0x1024
107 #define SIM_FCFG1_OFFSET 0x104c
108 #define SIM_FCFG2_OFFSET 0x1050
110 #define WDOG_STCTRLH_OFFSET 0
111 #define WDOG32_CS_OFFSET 0
114 #define PM_STAT_RUN 0x01
115 #define PM_STAT_VLPR 0x04
116 #define PM_CTRL_RUNM_RUN 0x00
119 #define FTFX_CMD_BLOCKSTAT 0x00
120 #define FTFX_CMD_SECTSTAT 0x01
121 #define FTFX_CMD_LWORDPROG 0x06
122 #define FTFX_CMD_SECTERASE 0x09
123 #define FTFX_CMD_SECTWRITE 0x0b
124 #define FTFX_CMD_MASSERASE 0x44
125 #define FTFX_CMD_PGMPART 0x80
126 #define FTFX_CMD_SETFLEXRAM 0x81
148 #define KINETIS_SOPT1_RAMSIZE_MASK 0x0000F000
149 #define KINETIS_SOPT1_RAMSIZE_K24FN1M 0x0000B000
151 #define KINETIS_SDID_K_SERIES_MASK 0x0000FFFF
153 #define KINETIS_SDID_DIEID_MASK 0x00000F80
155 #define KINETIS_SDID_DIEID_K22FN128 0x00000680
156 #define KINETIS_SDID_DIEID_K22FN256 0x00000A80
157 #define KINETIS_SDID_DIEID_K22FN512 0x00000E80
158 #define KINETIS_SDID_DIEID_K24FN256 0x00000700
160 #define KINETIS_SDID_DIEID_K24FN1M 0x00000300
167 #define KINETIS_K_SDID_TYPE_MASK 0x00000FF0
168 #define KINETIS_K_SDID_K10_M50 0x00000000
169 #define KINETIS_K_SDID_K10_M72 0x00000080
170 #define KINETIS_K_SDID_K10_M100 0x00000100
171 #define KINETIS_K_SDID_K10_M120 0x00000180
172 #define KINETIS_K_SDID_K11 0x00000220
173 #define KINETIS_K_SDID_K12 0x00000200
174 #define KINETIS_K_SDID_K20_M50 0x00000010
175 #define KINETIS_K_SDID_K20_M72 0x00000090
176 #define KINETIS_K_SDID_K20_M100 0x00000110
177 #define KINETIS_K_SDID_K20_M120 0x00000190
178 #define KINETIS_K_SDID_K21_M50 0x00000230
179 #define KINETIS_K_SDID_K21_M120 0x00000330
180 #define KINETIS_K_SDID_K22_M50 0x00000210
181 #define KINETIS_K_SDID_K22_M120 0x00000310
182 #define KINETIS_K_SDID_K30_M72 0x000000A0
183 #define KINETIS_K_SDID_K30_M100 0x00000120
184 #define KINETIS_K_SDID_K40_M72 0x000000B0
185 #define KINETIS_K_SDID_K40_M100 0x00000130
186 #define KINETIS_K_SDID_K50_M72 0x000000E0
187 #define KINETIS_K_SDID_K51_M72 0x000000F0
188 #define KINETIS_K_SDID_K53 0x00000170
189 #define KINETIS_K_SDID_K60_M100 0x00000140
190 #define KINETIS_K_SDID_K60_M150 0x000001C0
191 #define KINETIS_K_SDID_K70_M150 0x000001D0
193 #define KINETIS_K_REVID_MASK 0x0000F000
194 #define KINETIS_K_REVID_SHIFT 12
196 #define KINETIS_SDID_SERIESID_MASK 0x00F00000
197 #define KINETIS_SDID_SERIESID_K 0x00000000
198 #define KINETIS_SDID_SERIESID_KL 0x00100000
199 #define KINETIS_SDID_SERIESID_KE 0x00200000
200 #define KINETIS_SDID_SERIESID_KW 0x00500000
201 #define KINETIS_SDID_SERIESID_KV 0x00600000
203 #define KINETIS_SDID_SUBFAMID_SHIFT 24
204 #define KINETIS_SDID_SUBFAMID_MASK 0x0F000000
205 #define KINETIS_SDID_SUBFAMID_KX0 0x00000000
206 #define KINETIS_SDID_SUBFAMID_KX1 0x01000000
207 #define KINETIS_SDID_SUBFAMID_KX2 0x02000000
208 #define KINETIS_SDID_SUBFAMID_KX3 0x03000000
209 #define KINETIS_SDID_SUBFAMID_KX4 0x04000000
210 #define KINETIS_SDID_SUBFAMID_KX5 0x05000000
211 #define KINETIS_SDID_SUBFAMID_KX6 0x06000000
212 #define KINETIS_SDID_SUBFAMID_KX7 0x07000000
213 #define KINETIS_SDID_SUBFAMID_KX8 0x08000000
215 #define KINETIS_SDID_FAMILYID_SHIFT 28
216 #define KINETIS_SDID_FAMILYID_MASK 0xF0000000
217 #define KINETIS_SDID_FAMILYID_K0X 0x00000000
218 #define KINETIS_SDID_FAMILYID_K1X 0x10000000
219 #define KINETIS_SDID_FAMILYID_K2X 0x20000000
220 #define KINETIS_SDID_FAMILYID_K3X 0x30000000
221 #define KINETIS_SDID_FAMILYID_K4X 0x40000000
222 #define KINETIS_SDID_FAMILYID_K5X 0x50000000
223 #define KINETIS_SDID_FAMILYID_K6X 0x60000000
224 #define KINETIS_SDID_FAMILYID_K7X 0x70000000
225 #define KINETIS_SDID_FAMILYID_K8X 0x80000000
226 #define KINETIS_SDID_FAMILYID_KL8X 0x90000000
229 #define KINETIS_SDID_PROJECTID_MASK KINETIS_SDID_DIEID_MASK
230 #define KINETIS_SDID_PROJECTID_KE1XF 0x00000080
231 #define KINETIS_SDID_PROJECTID_KE1XZ 0x00000100
253 #define KINETIS_MAX_BANKS 4u
356 #define MDM_REG_STAT 0x00
357 #define MDM_REG_CTRL 0x04
358 #define MDM_REG_ID 0xfc
360 #define MDM_STAT_FMEACK (1<<0)
361 #define MDM_STAT_FREADY (1<<1)
362 #define MDM_STAT_SYSSEC (1<<2)
363 #define MDM_STAT_SYSRES (1<<3)
364 #define MDM_STAT_FMEEN (1<<5)
365 #define MDM_STAT_BACKDOOREN (1<<6)
366 #define MDM_STAT_LPEN (1<<7)
367 #define MDM_STAT_VLPEN (1<<8)
368 #define MDM_STAT_LLSMODEXIT (1<<9)
369 #define MDM_STAT_VLLSXMODEXIT (1<<10)
370 #define MDM_STAT_CORE_HALTED (1<<16)
371 #define MDM_STAT_CORE_SLEEPDEEP (1<<17)
372 #define MDM_STAT_CORESLEEPING (1<<18)
374 #define MDM_CTRL_FMEIP (1<<0)
375 #define MDM_CTRL_DBG_DIS (1<<1)
376 #define MDM_CTRL_DBG_REQ (1<<2)
377 #define MDM_CTRL_SYS_RES_REQ (1<<3)
378 #define MDM_CTRL_CORE_HOLD_RES (1<<4)
379 #define MDM_CTRL_VLLSX_DBG_REQ (1<<5)
380 #define MDM_CTRL_VLLSX_DBG_ACK (1<<6)
381 #define MDM_CTRL_VLLSX_STAT_ACK (1<<7)
383 #define MDM_ACCESS_TIMEOUT 500
410 LOG_DEBUG(
"MDM: failed to queue a write request");
436 LOG_DEBUG(
"MDM: failed to queue a read request");
453 uint32_t
mask, uint32_t value, uint32_t timeout_ms)
457 int64_t ms_timeout =
timeval_ms() + timeout_ms;
488 LOG_ERROR(
"Cannot perform halt with a high-level adapter");
501 LOG_DEBUG(
"MDM: failed to read MDM_REG_STAT");
518 LOG_DEBUG(
"MDM: halt succeeded after %d attempts.", tries);
531 LOG_ERROR(
"MDM: failed to clear MDM_REG_CTRL");
548 LOG_ERROR(
"Cannot perform reset with a high-level adapter");
554 LOG_ERROR(
"MDM: failed to write MDM_REG_CTRL");
560 LOG_ERROR(
"MDM: failed to assert reset");
566 LOG_ERROR(
"MDM: failed to clear MDM_REG_CTRL");
588 LOG_ERROR(
"Cannot perform mass erase with a high-level adapter");
608 if (retval !=
ERROR_OK && !has_srst) {
609 LOG_ERROR(
"MDM: failed to assert reset");
610 goto deassert_reset_and_exit;
627 int cnt_mass_erase_disabled = 0;
630 bool man_reset_requested =
false;
636 if (!man_reset_requested && ms_elapsed > 100) {
637 LOG_INFO(
"MDM: Press RESET button now if possible.");
638 man_reset_requested =
true;
641 if (ms_elapsed > 3000) {
642 LOG_ERROR(
"MDM: waiting for mass erase conditions timed out.");
643 LOG_INFO(
"Mass erase of a secured MCU is not possible without hardware reset.");
644 LOG_INFO(
"Connect SRST, use 'reset_config srst_only' and retry.");
645 goto deassert_reset_and_exit;
655 cnt_mass_erase_disabled++;
656 if (cnt_mass_erase_disabled > 10) {
657 LOG_ERROR(
"MDM: mass erase is disabled");
658 goto deassert_reset_and_exit;
668 }
while (cnt_ready < 32);
677 LOG_ERROR(
"MDM: failed to start mass erase");
678 goto deassert_reset_and_exit;
690 goto deassert_reset_and_exit;
708 LOG_ERROR(
"MDM: failed to clear MDM_REG_CTRL");
714 deassert_reset_and_exit:
740 LOG_WARNING(
"Cannot check flash security status with a high-level adapter");
756 LOG_ERROR(
"MDM: failed to read ID register");
783 LOG_ERROR(
"MDM: failed to read MDM_REG_STAT");
794 int secured_score = 0, flash_not_ready_score = 0;
804 for (
unsigned int i = 0; i < 32; i++) {
811 LOG_DEBUG(
"MDM: dap_run failed when validating secured state");
814 for (
unsigned int i = 0; i < 32; i++) {
818 flash_not_ready_score++;
822 if (flash_not_ready_score <= 8 && secured_score > 24) {
825 LOG_WARNING(
"*********** ATTENTION! ATTENTION! ATTENTION! ATTENTION! **********");
827 LOG_WARNING(
"**** Your Kinetis MCU is in secured state, which means that, ****");
828 LOG_WARNING(
"**** with exception for very basic communication, JTAG/SWD ****");
829 LOG_WARNING(
"**** interface will NOT work. In order to restore its ****");
830 LOG_WARNING(
"**** functionality please issue 'kinetis mdm mass_erase' ****");
831 LOG_WARNING(
"**** command, power cycle the MCU and restart OpenOCD. ****");
833 LOG_WARNING(
"*********** ATTENTION! ATTENTION! ATTENTION! ATTENTION! **********");
835 }
else if (flash_not_ready_score > 24) {
837 LOG_WARNING(
"**** Your Kinetis MCU is probably locked-up in RESET/WDOG loop. ****");
838 LOG_WARNING(
"**** Common reason is a blank flash (at least a reset vector). ****");
839 LOG_WARNING(
"**** Issue 'kinetis mdm halt' command or if SRST is connected ****");
840 LOG_WARNING(
"**** and configured, use 'reset halt' ****");
841 LOG_WARNING(
"**** If MCU cannot be halted, it is likely secured and running ****");
842 LOG_WARNING(
"**** in RESET/WDOG loop. Issue 'kinetis mdm mass_erase' ****");
845 LOG_INFO(
"MDM: Chip is unsecured. Continuing.");
876 for (
int i = 0; i < argc; i++) {
877 if (strcmp(argv[i],
"-sim-base") == 0) {
881 LOG_ERROR(
"Unsupported flash bank option %s", argv[i]);
951 char base_name[69],
name[87], num[11];
962 strncpy(base_name,
bank->name,
sizeof(base_name) - 1);
963 base_name[
sizeof(base_name) - 1] =
'\0';
964 p = strstr(base_name,
".pflash");
969 snprintf(
name,
sizeof(
name),
"%s.pflash0", base_name);
976 base_name[
sizeof(base_name) - 1] =
'\0';
977 p = strstr(base_name,
".cpu");
982 for (
unsigned int bank_idx = 1; bank_idx < num_blocks; bank_idx++) {
983 k_bank = &(k_chip->
banks[bank_idx]);
991 if (bank_idx < k_chip->num_pflash_blocks) {
994 snprintf(num,
sizeof(num),
"%u", bank_idx);
998 snprintf(num,
sizeof(num),
"%u",
1008 bank->default_padded_value =
bank->erased_value = 0xff;
1010 snprintf(
name,
sizeof(
name),
"%s.%s%s",
1011 base_name,
class, num);
1054 wdog_algorithm->
address + code_size - 2,
1060 LOG_ERROR(
"Error executing Kinetis WDOG unlock algorithm");
1077 static const uint8_t kinetis_unlock_wdog_code[] = {
1078 #include "../../../contrib/loaders/watchdog/armv7m_kinetis_wdog.inc"
1085 if ((wdog & 0x1) == 0) {
1089 LOG_INFO(
"Disabling Kinetis watchdog (initial WDOG_STCTRLH = 0x%04" PRIx16
")", wdog);
1099 LOG_INFO(
"WDOG_STCTRLH = 0x%04" PRIx16, wdog);
1108 static const uint8_t kinetis_unlock_wdog_code[] = {
1109 #include "../../../contrib/loaders/watchdog/armv7m_kinetis_wdog32.inc"
1116 if ((wdog_cs & 0x80) == 0)
1119 LOG_INFO(
"Disabling Kinetis watchdog (initial WDOG_CS 0x%08" PRIx32
")", wdog_cs);
1129 if ((wdog_cs & 0x80) == 0)
1132 LOG_ERROR(
"Cannot disable Kinetis watchdog (WDOG_CS 0x%08" PRIx32
"), issue 'reset init'", wdog_cs);
1149 case KINETIS_WDOG_K:
1152 case KINETIS_WDOG_COP:
1157 if ((sim_copc & 0xc) == 0)
1160 LOG_INFO(
"Disabling Kinetis watchdog (initial SIM_COPC 0x%02" PRIx8
")", sim_copc);
1169 if ((sim_copc & 0xc) == 0)
1172 LOG_ERROR(
"Cannot disable Kinetis watchdog (SIM_COPC 0x%02" PRIx8
"), issue 'reset init'", sim_copc);
1175 case KINETIS_WDOG32_KE1X:
1178 case KINETIS_WDOG32_KL28:
1206 LOG_ERROR(
"Flash operation failed, illegal command");
1209 }
else if (fstat & 0x10)
1210 LOG_ERROR(
"Flash operation failed, protection violated");
1212 else if (fstat & 0x40)
1213 LOG_ERROR(
"Flash operation failed, read collision");
1215 else if (fstat & 0x80)
1237 for (
unsigned int i = 0; i < 50; i++) {
1246 if ((fstat & 0x80) == 0) {
1250 if (fstat != 0x80) {
1259 #include "../../../contrib/loaders/flash/kinetis/kinetis_flash.inc"
1264 uint32_t
offset, uint32_t wcount)
1267 uint32_t buffer_size;
1272 uint32_t end_address;
1281 LOG_WARNING(
"no working area available, can't do block memory writes");
1292 if (buffer_size < 256) {
1293 LOG_WARNING(
"large enough working area not available, can't do block memory writes");
1295 }
else if (buffer_size > 16384) {
1297 buffer_size = 16384;
1301 LOG_ERROR(
"allocating working area failed");
1328 end_address =
buf_get_u32(reg_params[0].value, 0, 32);
1330 LOG_ERROR(
"Error writing flash at %08" PRIx32, end_address);
1340 LOG_ERROR(
"Error executing kinetis Flash programming algorithm");
1358 LOG_ERROR(
"Protection setting is possible with 'kinetis fcf_source protection' only!");
1362 if (!
bank->prot_blocks ||
bank->num_prot_blocks == 0) {
1363 LOG_ERROR(
"No protection possible for current bank!");
1367 for (
unsigned int i = first; i <
bank->num_prot_blocks && i <= last; i++)
1368 bank->prot_blocks[i].is_protected = set;
1370 LOG_INFO(
"Protection bits will be written at the next FCF sector erase or write.");
1371 LOG_INFO(
"Do not issue 'flash info' command until protection is written,");
1372 LOG_INFO(
"doing so would re-read protection status from MCU.");
1404 LOG_ERROR(
"Protection checks for FlexRAM not supported");
1409 for (
unsigned int i = 0; i <
bank->num_prot_blocks; i++) {
1410 if ((fprot >> b) & 1)
1411 bank->prot_blocks[i].is_protected = 0;
1413 bank->prot_blocks[i].is_protected = 1;
1424 uint32_t fprot = 0xffffffff;
1425 uint8_t fsec = 0xfe;
1426 uint8_t fdprot = 0xff;
1427 unsigned num_blocks;
1428 uint32_t pflash_bit;
1442 for (
unsigned int bank_idx = 0; bank_idx < num_blocks; bank_idx++) {
1443 k_bank = &(k_chip->
banks[bank_idx]);
1444 bank_iter = k_bank->
bank;
1447 LOG_WARNING(
"Missing bank %u configuration, FCF protection flags may be incomplete", bank_idx);
1458 fprot &= ~pflash_bit;
1466 fdprot &= ~dflash_bit;
1482 uint8_t fccob4, uint8_t fccob5, uint8_t fccob6, uint8_t fccob7,
1483 uint8_t fccob8, uint8_t fccob9, uint8_t fccoba, uint8_t fccobb,
1484 uint8_t *ftfx_fstat)
1486 uint8_t
command[12] = {faddr & 0xff, (faddr >> 8) & 0xff, (faddr >> 16) & 0xff, fcmd,
1487 fccob7, fccob6, fccob5, fccob4,
1488 fccobb, fccoba, fccob9, fccob8};
1515 *ftfx_fstat = fstat;
1517 if ((fstat & 0xf0) != 0x80) {
1518 LOG_DEBUG(
"ftfx command failed FSTAT: %02X FCCOB: %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X",
1544 *pmstat = stat32 & 0xff;
1587 LOG_INFO(
"Switching from VLPR to RUN mode.");
1605 for (
unsigned int i = 100; i > 0; i--) {
1615 LOG_ERROR(
"Flash operation not possible in current run mode: SMC_PMSTAT: 0x%x", pmstat);
1616 LOG_ERROR(
"Issue a 'reset init' command.");
1626 case KINETIS_CACHE_K:
1632 case KINETIS_CACHE_L:
1637 case KINETIS_CACHE_MSCM:
1664 if ((first >
bank->num_sectors) || (last >
bank->num_sectors))
1672 for (
unsigned int i = first; i <= last; i++) {
1675 0, 0, 0, 0, 0, 0, 0, 0,
NULL);
1686 LOG_WARNING(
"Flash Configuration Field erased, DO NOT reset or power off the device");
1687 LOG_WARNING(
"until correct FCF is programmed or MCU gets security lock.");
1694 LOG_WARNING(
"Flash Configuration Field write failed");
1716 if (ftfx_fcnfg & (1 << 1))
1721 0, 0, 0, 0, 0, 0, 0, 0,
NULL);
1730 if (ftfx_fcnfg & (1 << 1))
1743 uint8_t *buffer_aligned =
NULL;
1750 uint32_t prog_section_chunk_bytes = k_bank->
sector_size >> 8;
1754 uint32_t
size = prog_size_bytes -
offset % prog_size_bytes;
1755 uint32_t align_begin =
offset % prog_section_chunk_bytes;
1757 uint32_t size_aligned;
1758 uint16_t chunk_count;
1764 align_end = (align_begin +
size) % prog_section_chunk_bytes;
1766 align_end = prog_section_chunk_bytes - align_end;
1768 size_aligned = align_begin +
size + align_end;
1769 chunk_count = size_aligned / prog_section_chunk_bytes;
1771 if (
size != size_aligned) {
1773 if (!buffer_aligned)
1774 buffer_aligned = malloc(prog_size_bytes);
1776 memset(buffer_aligned, 0xff, size_aligned);
1777 memcpy(buffer_aligned + align_begin,
buffer,
size);
1780 4, size_aligned / 4, buffer_aligned);
1784 bank->base +
offset, align_begin, align_end);
1787 4, size_aligned / 4,
buffer);
1794 LOG_ERROR(
"target_write_memory failed");
1801 chunk_count>>8, chunk_count, 0, 0,
1802 0, 0, 0, 0, &ftfx_fstat);
1810 if (ftfx_fstat & 0x01) {
1815 LOG_ERROR(
"Flash write immediately after the end of Flash Config Field shows error");
1816 LOG_ERROR(
"because the flash memory is 256 bits wide (data were written correctly).");
1817 LOG_ERROR(
"Either change the linker script to add a gap of 16 bytes after FCF");
1818 LOG_ERROR(
"or set 'kinetis fcf_source write'");
1829 free(buffer_aligned);
1838 bool fallback =
false;
1845 LOG_INFO(
"This device supports Program Longword execution only.");
1850 LOG_WARNING(
"FlexRAM not ready, fallback to slow longword write.");
1861 uint8_t *new_buffer =
NULL;
1865 LOG_ERROR(
"offset 0x%" PRIx32
" breaks the required alignment",
offset);
1870 uint32_t old_count =
count;
1871 count = (old_count | 3) + 1;
1872 new_buffer = malloc(
count);
1874 LOG_ERROR(
"odd number of bytes to write and no memory "
1875 "for padding buffer");
1878 LOG_INFO(
"odd number of bytes to write (%" PRIu32
"), extending to %" PRIu32
" "
1879 "and padding with 0xff", old_count,
count);
1880 memset(new_buffer + old_count, 0xff,
count - old_count);
1884 uint32_t words_remaining =
count / 4;
1894 LOG_WARNING(
"couldn't use block writes, falling back to single "
1897 while (words_remaining) {
1904 0, 0, 0, 0, &ftfx_fstat);
1912 if (ftfx_fstat & 0x01)
1925 LOG_ERROR(
"Flash write strategy not implemented");
1938 bool set_fcf =
false;
1939 bool fcf_in_data_valid =
false;
1940 bool fcf_differs =
false;
1961 if (offset < bank->sectors[sect].
offset +
bank->sectors[sect].size
1971 if (fcf_in_data_valid) {
1973 if (memcmp(fcf_in_data, fcf_buffer, 8)) {
1975 LOG_INFO(
"Setting of backdoor key is not supported in mode 'kinetis fcf_source protection'.");
1979 LOG_INFO(
"Flash protection requested in the programmed file differs from current setting.");
1983 LOG_INFO(
"Data flash protection requested in the programmed file differs from current setting.");
1985 if ((fcf_in_data[
FCF_FSEC] & 3) != 2) {
1986 fcf_in_data_valid =
false;
1987 LOG_INFO(
"Device security requested in the programmed file! Write denied.");
1990 LOG_INFO(
"Strange unsecure mode 0x%02" PRIx8
1991 " requested in the programmed file, set FSEC = 0x%02" PRIx8
1992 " in the startup code!",
1997 LOG_INFO(
"FOPT requested in the programmed file differs from current setting, set 'kinetis fopt 0x%02"
1998 PRIx8
"'.", fcf_in_data[
FCF_FOPT]);
2004 fcf_in_data_valid =
false;
2005 LOG_INFO(
"Cannot re-program FCF. Expect verify errors at FCF (0x400-0x40f).");
2007 LOG_INFO(
"Trying to re-program FCF.");
2009 LOG_INFO(
"Flash re-programming may fail on this device!");
2015 if (set_fcf && !fcf_in_data_valid) {
2034 LOG_WARNING(
"Flash Configuration Field written.");
2035 LOG_WARNING(
"Reset or power off the device to make settings effective.");
2054 uint8_t fcfg1_nvmsize, fcfg1_pfsize, fcfg1_eesize, fcfg1_depart;
2055 uint8_t fcfg2_pflsh;
2056 uint32_t ee_size = 0;
2057 uint32_t pflash_size_k, nvm_size_k, dflash_size_k;
2058 uint32_t pflash_size_m;
2059 unsigned num_blocks = 0;
2060 unsigned maxaddr_shift = 13;
2063 unsigned familyid = 0, subfamid = 0;
2064 unsigned cpu_mhz = 120;
2065 bool use_nvm_marking =
false;
2066 char flash_marking[12], nvm_marking[2];
2105 k_chip->
flash_support = FS_PROGRAM_LONGWORD | FS_PROGRAM_SECTOR;
2118 k_chip->
flash_support = FS_PROGRAM_LONGWORD | FS_PROGRAM_SECTOR;
2134 k_chip->
flash_support = FS_PROGRAM_LONGWORD | FS_PROGRAM_SECTOR;
2143 k_chip->
flash_support = FS_PROGRAM_PHRASE | FS_PROGRAM_SECTOR;
2153 k_chip->
flash_support = FS_PROGRAM_PHRASE | FS_PROGRAM_SECTOR;
2156 LOG_ERROR(
"Unsupported K-family FAMID");
2162 use_nvm_marking =
true;
2179 strcat(
name,
" Rev 1.x");
2192 use_nvm_marking =
true;
2217 k_chip->
flash_support = FS_PROGRAM_PHRASE | FS_PROGRAM_SECTOR;
2231 LOG_ERROR(
"Unsupported Kinetis K22 DIEID");
2244 k_chip->
flash_support = FS_PROGRAM_PHRASE | FS_PROGRAM_SECTOR;
2260 k_chip->
flash_support = FS_PROGRAM_PHRASE | FS_PROGRAM_SECTOR;
2271 k_chip->
flash_support = FS_PROGRAM_PHRASE | FS_PROGRAM_SECTOR | FS_ECC;
2282 k_chip->
flash_support = FS_PROGRAM_PHRASE | FS_PROGRAM_SECTOR | FS_ECC;
2292 k_chip->
flash_support = FS_PROGRAM_LONGWORD | FS_NO_CMD_BLOCKSTAT;
2301 k_chip->
flash_support = FS_PROGRAM_LONGWORD | FS_NO_CMD_BLOCKSTAT;
2304 use_nvm_marking =
false;
2305 snprintf(
name,
sizeof(
name),
"MKL8%uZ%%s7",
2310 LOG_ERROR(
"Unsupported Kinetis FAMILYID SUBFAMID");
2313 if (
name[0] ==
'\0')
2314 snprintf(
name,
sizeof(
name),
"MK%u%uF%%s%u",
2315 familyid, subfamid, cpu_mhz / 10);
2343 snprintf(
name,
sizeof(
name),
"MKL%u%uZ%%s%u",
2344 familyid, subfamid, cpu_mhz / 10);
2380 LOG_ERROR(
"Unsupported KW FAMILYID SUBFAMID");
2382 snprintf(
name,
sizeof(
name),
"MKW%u%uZ%%s%u",
2383 familyid, subfamid, cpu_mhz / 10);
2396 strcpy(
name,
"MKV10Z%s7");
2405 strcpy(
name,
"MKV11Z%s7");
2436 k_chip->
flash_support = FS_PROGRAM_PHRASE | FS_PROGRAM_SECTOR | FS_WIDTH_256BIT | FS_ECC;
2443 LOG_ERROR(
"Unsupported KV FAMILYID SUBFAMID");
2446 if (
name[0] ==
'\0')
2447 snprintf(
name,
sizeof(
name),
"MKV%u%uF%%s%u",
2448 familyid, subfamid, cpu_mhz / 10);
2463 k_chip->
flash_support = FS_PROGRAM_PHRASE | FS_PROGRAM_SECTOR;
2467 snprintf(
name,
sizeof(
name),
"MKE%u%uZ%%s%u",
2468 familyid, subfamid, cpu_mhz / 10);
2479 k_chip->
flash_support = FS_PROGRAM_PHRASE | FS_PROGRAM_SECTOR;
2483 snprintf(
name,
sizeof(
name),
"MKE%u%uF%%s%u",
2484 familyid, subfamid, cpu_mhz / 10);
2488 LOG_ERROR(
"Unsupported KE FAMILYID SUBFAMID");
2510 LOG_DEBUG(
"SDID: 0x%08" PRIX32
" FCFG1: 0x%08" PRIX32
" FCFG2: 0x%08" PRIX32, k_chip->
sim_sdid,
2513 fcfg1_nvmsize = (uint8_t)((k_chip->
sim_fcfg1 >> 28) & 0x0f);
2514 fcfg1_pfsize = (uint8_t)((k_chip->
sim_fcfg1 >> 24) & 0x0f);
2515 fcfg1_eesize = (uint8_t)((k_chip->
sim_fcfg1 >> 16) & 0x0f);
2516 fcfg1_depart = (uint8_t)((k_chip->
sim_fcfg1 >> 8) & 0x0f);
2518 fcfg2_pflsh = (uint8_t)((k_chip->
sim_fcfg2 >> 23) & 0x01);
2522 if (num_blocks == 0)
2528 LOG_WARNING(
"MAXADDR1 is zero, number of flash banks adjusted to 1");
2531 LOG_WARNING(
"MAXADDR1 is non zero, number of flash banks adjusted to 2");
2536 switch (fcfg1_nvmsize) {
2542 k_chip->
nvm_size = 1 << (14 + (fcfg1_nvmsize >> 1));
2556 switch (fcfg1_eesize) {
2567 ee_size = (16 << (10 - fcfg1_eesize));
2574 switch (fcfg1_depart) {
2592 k_chip->
dflash_size = 4096 << (fcfg1_depart & 0x7);
2600 switch (fcfg1_pfsize) {
2611 k_chip->
pflash_size = 1 << (14 + (fcfg1_pfsize >> 1));
2629 LOG_WARNING(
"SIM_FCFG1 PFSIZE = 0xf: please check if pflash is %" PRIu32
" KB", k_chip->
pflash_size>>10);
2650 if (use_nvm_marking) {
2652 nvm_marking[1] =
'\0';
2654 nvm_marking[0] =
'\0';
2657 pflash_size_m = pflash_size_k / 1024;
2659 snprintf(flash_marking,
sizeof(flash_marking),
"%s%" PRIu32
"M0xxx", nvm_marking, pflash_size_m);
2661 snprintf(flash_marking,
sizeof(flash_marking),
"%s%" PRIu32
"xxx", nvm_marking, pflash_size_k);
2663 snprintf(k_chip->
name,
sizeof(k_chip->
name),
name, flash_marking);
2664 LOG_INFO(
"Kinetis %s detected: %u flash blocks", k_chip->
name, num_blocks);
2667 nvm_size_k = k_chip->
nvm_size / 1024;
2669 LOG_INFO(
"%u FlexNVM banks: %" PRIu32
" KiB total, %" PRIu32
" KiB available as data flash, %"
2670 PRIu32
" bytes FlexRAM", k_chip->
num_nvm_blocks, nvm_size_k, dflash_size_k, ee_size);
2684 uint8_t fcfg2_maxaddr0, fcfg2_pflsh, fcfg2_maxaddr1;
2685 unsigned num_blocks, first_nvm_bank;
2718 size_k =
bank->size / 1024;
2719 LOG_DEBUG(
"Kinetis bank %u: %" PRIu32
"k PFlash, FTFx base 0x%08" PRIx32
", sect %" PRIu32,
2724 unsigned nvm_ord = k_bank->
bank_number - first_nvm_bank;
2752 if (
bank->size > limit) {
2754 LOG_DEBUG(
"FlexNVM bank %u limited to 0x%08" PRIx32
" due to active EEPROM backup",
2758 size_k =
bank->size / 1024;
2759 LOG_DEBUG(
"Kinetis bank %u: %" PRIu32
"k FlexNVM, FTFx base 0x%08" PRIx32
", sect %" PRIu32,
2763 LOG_ERROR(
"Cannot determine parameters for bank %u, only %u banks on device",
2768 fcfg2_pflsh = (uint8_t)((k_chip->
sim_fcfg2 >> 23) & 0x01);
2769 fcfg2_maxaddr0 = (uint8_t)((k_chip->
sim_fcfg2 >> 24) & 0x7f);
2770 fcfg2_maxaddr1 = (uint8_t)((k_chip->
sim_fcfg2 >> 16) & 0x7f);
2773 LOG_WARNING(
"MAXADDR0 0x%02" PRIx8
" check failed,"
2774 " please report to OpenOCD mailing list", fcfg2_maxaddr0);
2778 LOG_WARNING(
"MAXADDR1 0x%02" PRIx8
" check failed,"
2779 " please report to OpenOCD mailing list", fcfg2_maxaddr1);
2783 LOG_WARNING(
"FlexNVM MAXADDR1 0x%02" PRIx8
" check failed,"
2784 " please report to OpenOCD mailing list", fcfg2_maxaddr1);
2787 free(
bank->sectors);
2790 free(
bank->prot_blocks);
2794 LOG_ERROR(
"Unknown sector size for bank %u",
bank->bank_number);
2800 if (
bank->num_sectors > 0) {
2807 if (!
bank->prot_blocks)
2811 bank->num_prot_blocks = 0;
2823 if (k_bank && k_bank->
probed)
2831 const char *bank_class_names[] = {
2832 "(ANY)",
"PFlash",
"FlexNVM",
"FlexRAM"
2837 uint32_t size_k =
bank->size / 1024;
2865 bool block_dirty =
true;
2869 if (use_block_cmd && k_bank->
flash_class == FC_FLEX_NVM) {
2870 uint8_t fcfg1_depart = (uint8_t)((k_chip->
sim_fcfg1 >> 8) & 0x0f);
2872 if (fcfg1_depart != 0xf && fcfg1_depart != 0)
2873 use_block_cmd =
false;
2876 if (use_block_cmd) {
2879 0, 0, 0, 0, 0, 0, 0, 0, &ftfx_fstat);
2883 else if ((ftfx_fstat & 0x01) == 0)
2884 block_dirty =
false;
2889 for (
unsigned int i = 0; i <
bank->num_sectors; i++) {
2893 1, 0, 0, 0, 0, 0, 0, 0, &ftfx_fstat);
2896 bank->sectors[i].is_erased = !(ftfx_fstat & 0x01);
2898 LOG_DEBUG(
"Ignoring error on PFlash sector blank-check");
2900 bank->sectors[i].is_erased = -1;
2905 for (
unsigned int i = 0; i <
bank->num_sectors; i++)
2906 bank->sectors[i].is_erased = 1;
2909 LOG_WARNING(
"kinetis_blank_check not supported yet for FlexRAM");
2921 unsigned num_blocks, first_nvm_bank;
2922 unsigned long par, log2 = 0, ee1 = 0, ee2 = 0;
2923 enum { SHOW_INFO, DF_SIZE, EEBKP_SIZE } sz_type = SHOW_INFO;
2925 uint8_t load_flex_ram = 1;
2926 uint8_t ee_size_code = 0x3f;
2927 uint8_t flex_nvm_partition_code = 0;
2928 uint8_t ee_split = 3;
2936 if (strcmp(
CMD_ARGV[0],
"dataflash") == 0)
2938 else if (strcmp(
CMD_ARGV[0],
"eebkp") == 0)
2939 sz_type = EEBKP_SIZE;
2942 while (par >> (log2 + 3))
2955 flex_nvm_partition_code = (uint8_t)((
sim_fcfg1 >> 8) & 0x0f);
2956 switch (flex_nvm_partition_code) {
2977 command_print(
CMD,
"data flash %d KB", 4 << (flex_nvm_partition_code & 7));
2983 command_print(
CMD,
"Unsupported EEPROM backup size code 0x%02" PRIx8, flex_nvm_partition_code);
2988 flex_nvm_partition_code = 0x8 | log2;
2992 flex_nvm_partition_code = log2;
2999 ee1 = ee2 = eex / 2;
3005 enable = ee1 + ee2 > 0;
3007 for (log2 = 2; ; log2++) {
3008 if (ee1 + ee2 == (16u << 10) >> log2)
3010 if (ee1 + ee2 > (16u << 10) >> log2 || log2 >= 9) {
3018 else if (ee1 * 7 == ee2)
3020 else if (ee1 != ee2) {
3021 LOG_ERROR(
"Unsupported EEPROM sizes ratio");
3025 ee_size_code = log2 | ee_split << 4;
3033 LOG_INFO(
"DEPART 0x%" PRIx8
", EEPROM size code 0x%" PRIx8,
3034 flex_nvm_partition_code, ee_size_code);
3046 ee_size_code, flex_nvm_partition_code, 0, 0,
3056 for (bank_idx = first_nvm_bank; bank_idx < num_blocks; bank_idx++)
3061 command_print(
CMD,
"FlexNVM banks will be re-probed to set new data flash size.");
3071 if (strcmp(
CMD_ARGV[0],
"write") == 0)
3073 else if (strcmp(
CMD_ARGV[0],
"protection") == 0)
3082 LOG_WARNING(
"BEWARE: incorrect flash configuration may permanently lock the device.");
3084 command_print(
CMD,
"Protection info writes to Flash Configuration Field enabled.");
3085 command_print(
CMD,
"Arbitrary FCF writes disabled. Mode safe from unwanted locking of the device.");
3118 .
name =
"check_security",
3120 .help =
"Check status of device security lock",
3122 .handler = kinetis_check_flash_security_status,
3127 .help =
"Issue a halt via the MDM-AP",
3129 .handler = kinetis_mdm_halt,
3132 .name =
"mass_erase",
3134 .help =
"Issue a complete flash erase via the MDM-AP",
3136 .handler = kinetis_mdm_mass_erase,
3141 .help =
"Issue a reset via the MDM-AP",
3143 .handler = kinetis_mdm_reset,
3152 .help =
"MDM-AP command group",
3157 .
name =
"disable_wdog",
3159 .help =
"Disable the watchdog timer",
3161 .handler = kinetis_disable_wdog_handler,
3164 .name =
"nvm_partition",
3166 .help =
"Show/set data flash or EEPROM backup size in kilobytes,"
3167 " set two EEPROM sizes in bytes and FlexRAM loading during reset",
3168 .usage =
"('info'|'dataflash' size|'eebkp' size) [eesize1 eesize2] ['on'|'off']",
3169 .handler = kinetis_nvm_partition,
3172 .name =
"fcf_source",
3174 .help =
"Use protection as a source for Flash Configuration Field or allow writing arbitrary values to the FCF"
3175 " Mode 'protection' is safe from unwanted locking of the device.",
3176 .usage =
"['protection'|'write']",
3177 .handler = kinetis_fcf_source_handler,
3182 .help =
"FCF_FOPT value source in 'kinetis fcf_source protection' mode",
3184 .handler = kinetis_fopt_handler,
3187 .name =
"create_banks",
3189 .help =
"Driver creates additional banks if device with two/four flash blocks is probed",
3190 .handler = kinetis_create_banks_handler,
3200 .help =
"Kinetis flash controller commands",
3212 .flash_bank_command = kinetis_flash_bank_command,
void init_reg_param(struct reg_param *param, char *reg_name, uint32_t size, enum param_direction direction)
void destroy_reg_param(struct reg_param *param)
struct adiv5_ap * dap_get_ap(struct adiv5_dap *dap, uint64_t ap_num)
int dap_put_ap(struct adiv5_ap *ap)
This defines formats and data structures used to talk to ADIv5 entities.
static int dap_queue_ap_write(struct adiv5_ap *ap, unsigned reg, uint32_t data)
Queue an AP register write.
static int dap_queue_ap_read(struct adiv5_ap *ap, unsigned reg, uint32_t *data)
Queue an AP register read.
static int dap_run(struct adiv5_dap *dap)
Perform all queued DAP operations, and clear any errors posted in the CTRL_STAT register when they ar...
#define ARMV7M_COMMON_MAGIC
Support functions to access arbitrary bits in a byte array.
static uint32_t buf_get_u32(const uint8_t *_buffer, unsigned first, unsigned num)
Retrieves num bits from _buffer, starting at the first bit, returning the bits in a 32-bit word.
static void buf_set_u32(uint8_t *_buffer, unsigned first, unsigned num, uint32_t value)
Sets num bits in _buffer, starting at the first bit, using the bits in value.
void command_print_sameline(struct command_invocation *cmd, const char *format,...)
void command_print(struct command_invocation *cmd, const char *format,...)
#define CMD
Use this macro to access the command being handled, rather than accessing the variable directly.
#define CMD_ARGV
Use this macro to access the arguments for the command being handled, rather than accessing the varia...
#define COMMAND_PARSE_ON_OFF(in, out)
parses an on/off command argument
#define ERROR_COMMAND_SYNTAX_ERROR
#define CMD_ARGC
Use this macro to access the number of arguments for the command being handled, rather than accessing...
#define COMMAND_PARSE_NUMBER(type, in, out)
parses the string in into out as a type, or prints a command error and passes the error code to the c...
#define CMD_CTX
Use this macro to access the context of the command being handled, rather than accessing the variable...
#define COMMAND_REGISTRATION_DONE
Use this as the last entry in an array of command_registration records.
static struct cortex_m_common * target_to_cm(struct target *target)
#define ERROR_FLASH_OPER_UNSUPPORTED
#define ERROR_FLASH_BANK_INVALID
#define ERROR_FLASH_OPERATION_FAILED
#define ERROR_FLASH_DST_BREAKS_ALIGNMENT
struct flash_sector * alloc_block_array(uint32_t offset, uint32_t size, unsigned int num_blocks)
Allocate and fill an array of sectors or protection blocks.
void flash_bank_add(struct flash_bank *bank)
Adds a new NOR bank to the global list of banks.
int default_flash_read(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
Provides default read implementation for flash memory.
struct flash_bank * flash_bank_list(void)
void jtag_poll_set_enabled(bool value)
Assign flag reporting whether JTAG polling is disallowed.
int adapter_deassert_reset(void)
enum reset_types jtag_get_reset_config(void)
int adapter_assert_reset(void)
#define KINETIS_SOPT1_RAMSIZE_K24FN1M
#define KINETIS_K_SDID_K60_M100
#define KINETIS_SDID_DIEID_K22FN256
#define KINETIS_SDID_SERIESID_MASK
static int kinetis_protect_check(struct flash_bank *bank)
#define KINETIS_K_SDID_K22_M50
#define KINETIS_SDID_PROJECTID_KE1XF
#define KINETIS_SDID_FAMILYID_SHIFT
#define FTFX_CMD_SECTERASE
static int kinetis_create_missing_banks(struct kinetis_chip *k_chip)
#define KINETIS_SDID_SUBFAMID_MASK
static int kinetis_info(struct flash_bank *bank, struct command_invocation *cmd)
#define KINETIS_SDID_SERIESID_KL
static int kinetis_blank_check(struct flash_bank *bank)
#define KINETIS_K_SDID_K21_M120
#define KINETIS_K_SDID_K30_M100
#define KINETIS_K_SDID_K12
#define KINETIS_K_SDID_K40_M72
static int kinetis_write_block(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t wcount)
#define FTFX_CMD_SETFLEXRAM
static int kinetis_probe(struct flash_bank *bank)
#define KINETIS_SDID_FAMILYID_K1X
#define KINETIS_SDID_SUBFAMID_KX6
#define KINETIS_MAX_BANKS
#define MDM_CTRL_CORE_HOLD_RES
static int kinetis_chip_options(struct kinetis_chip *k_chip, int argc, const char *argv[])
static int kinetis_disable_wdog32(struct target *target, uint32_t wdog_base)
#define KINETIS_SDID_FAMILYID_K3X
#define KINETIS_K_SDID_K60_M150
static int kinetis_mdm_read_register(struct adiv5_dap *dap, unsigned reg, uint32_t *result)
#define KINETIS_SDID_DIEID_K24FN1M
#define KINETIS_SDID_FAMILYID_MASK
#define KINETIS_K_REVID_MASK
#define KINETIS_K_SDID_K20_M100
static int kinetis_protect(struct flash_bank *bank, int set, unsigned int first, unsigned int last)
#define KINETIS_K_SDID_K22_M120
#define KINETIS_SDID_PROJECTID_MASK
static const uint8_t kinetis_flash_write_code[]
static const struct kinetis_type kinetis_types_old[]
#define KINETIS_SDID_FAMILYID_KL8X
#define KINETIS_SDID_FAMILYID_K5X
COMMAND_HANDLER(kinetis_mdm_halt)
static int kinetis_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
static int kinetis_fill_fcf(struct flash_bank *bank, uint8_t *fcf)
#define KINETIS_K_SDID_K40_M100
#define KINETIS_SDID_SERIESID_K
#define KINETIS_SDID_SERIESID_KV
static const struct command_registration kinetis_exec_command_handlers[]
#define KINETIS_SDID_SUBFAMID_KX2
#define FTFX_CMD_BLOCKSTAT
#define KINETIS_K_SDID_TYPE_MASK
#define KINETIS_K_SDID_K70_M150
static int kinetis_make_ram_ready(struct target *target)
#define KINETIS_SDID_FAMILYID_K4X
#define KINETIS_K_SDID_K53
static int kinetis_probe_chip(struct kinetis_chip *k_chip)
#define KINETIS_SDID_DIEID_MASK
#define KINETIS_K_REVID_SHIFT
#define KINETIS_SDID_PROJECTID_KE1XZ
static int kinetis_disable_wdog_kx(struct target *target)
static int kinetis_ftfx_clear_error(struct target *target)
#define KINETIS_SDID_SERIESID_KW
static int kinetis_check_run_mode(struct kinetis_chip *k_chip)
#define KINETIS_SDID_K_SERIES_MASK
#define KINETIS_SDID_SUBFAMID_KX8
#define KINETIS_K_SDID_K10_M100
#define KINETIS_SDID_SUBFAMID_KX7
static int kinetis_write_inner(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
#define KINETIS_SDID_FAMILYID_K8X
static int kinetis_auto_probe(struct flash_bank *bank)
static int kinetis_mdm_write_register(struct adiv5_dap *dap, unsigned reg, uint32_t value)
#define KINETIS_K_SDID_K20_M120
#define KINETIS_SDID_SUBFAMID_SHIFT
#define KINETIS_SDID_SUBFAMID_KX0
static int kinetis_ftfx_command(struct target *target, uint8_t fcmd, uint32_t faddr, uint8_t fccob4, uint8_t fccob5, uint8_t fccob6, uint8_t fccob7, uint8_t fccob8, uint8_t fccob9, uint8_t fccoba, uint8_t fccobb, uint8_t *ftfx_fstat)
#define KINETIS_SDID_SUBFAMID_KX3
#define KINETIS_K_SDID_K10_M120
#define KINETIS_SDID_FAMILYID_K0X
static void kinetis_invalidate_flash_cache(struct kinetis_chip *k_chip)
#define KINETIS_SDID_FAMILYID_K2X
static int kinetis_write_sections(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
const struct flash_driver kinetis_flash
#define KINETIS_K_SDID_K30_M72
static const uint32_t kinetis_known_mdm_ids[]
#define KINETIS_SDID_SUBFAMID_KX5
FLASH_BANK_COMMAND_HANDLER(kinetis_flash_bank_command)
static void kinetis_free_driver_priv(struct flash_bank *bank)
#define KINETIS_SDID_SUBFAMID_KX1
#define KINETIS_K_SDID_K11
#define KINETIS_K_SDID_K20_M72
static int kinetis_ftfx_prepare(struct target *target)
#define KINETIS_SDID_DIEID_K22FN128
#define KINETIS_K_SDID_K10_M50
#define FTFX_CMD_SECTSTAT
static bool allow_fcf_writes
static struct kinetis_chip * kinetis_get_chip(struct target *target)
#define FTFX_CMD_LWORDPROG
#define KINETIS_K_SDID_K10_M72
static int kinetis_disable_wdog(struct kinetis_chip *k_chip)
#define KINETIS_SDID_DIEID_K22FN512
#define KINETIS_SDID_DIEID_K24FN256
#define KINETIS_SDID_SERIESID_KE
#define MDM_ACCESS_TIMEOUT
static int kinetis_erase(struct flash_bank *bank, unsigned int first, unsigned int last)
#define KINETIS_K_SDID_K51_M72
static const struct command_registration kinetis_command_handler[]
static int kinetis_read_pmstat(struct kinetis_chip *k_chip, uint8_t *pmstat)
#define KINETIS_SOPT1_RAMSIZE_MASK
static int kinetis_disable_wdog_algo(struct target *target, size_t code_size, const uint8_t *code, uint32_t wdog_base)
#define KINETIS_SDID_FAMILYID_K6X
static int kinetis_ftfx_decode_error(uint8_t fstat)
#define KINETIS_K_SDID_K50_M72
#define FTFX_CMD_SECTWRITE
#define KINETIS_K_SDID_K21_M50
static const struct command_registration kinetis_security_command_handlers[]
static int kinetis_mdm_poll_register(struct adiv5_dap *dap, unsigned reg, uint32_t mask, uint32_t value, uint32_t timeout_ms)
#define KINETIS_K_SDID_K20_M50
#define MDM_CTRL_SYS_RES_REQ
#define WDOG_STCTRLH_OFFSET
#define KINETIS_SDID_SUBFAMID_KX4
void alive_sleep(uint64_t ms)
#define LOG_WARNING(expr ...)
#define LOG_ERROR(expr ...)
#define LOG_INFO(expr ...)
#define LOG_DEBUG(expr ...)
size_t size
Size of the control block search area.
This represents an ARM Debug Interface (v5) Access Port (AP).
struct adiv5_dap * dap
DAP this AP belongs to.
This represents an ARM Debug Interface (v5) Debug Access Port (DAP).
const struct dap_ops * ops
struct adiv5_dap * dap
For targets conforming to ARM Debug Interface v5, this handle references the Debug Access Port (DAP) ...
unsigned int common_magic
When run_command is called, a new instance will be created on the stack, filled with the proper value...
struct armv7m_common armv7m
Provides details of a flash bank, available either on-chip or through a major interface.
unsigned int num_prot_blocks
The number of protection blocks in this bank.
const struct flash_driver * driver
Driver for this bank.
void * driver_priv
Private driver storage pointer.
struct flash_sector * prot_blocks
Array of protection blocks, allocated and initialized by the flash driver.
struct flash_bank * next
The next flash bank on this chip.
struct target * target
Target to which this bank belongs.
Provides the implementation-independent structure that defines all of the callbacks required by OpenO...
const char * name
Gives a human-readable name of this flash driver, This field is used to select and initialize the dri...
int is_protected
Indication of protection status: 0 = unprotected/unlocked, 1 = protected/locked, other = unknown.
struct kinetis_flash_bank banks[KINETIS_MAX_BANKS]
unsigned max_flash_prog_size
enum kinetis_chip::@7 flash_support
enum kinetis_chip::@10 sysmodectrlr_type
unsigned num_pflash_blocks
unsigned pflash_sector_size
enum kinetis_chip::@9 watchdog_type
uint32_t fcfg2_maxaddr0_shifted
uint32_t fcfg2_maxaddr1_shifted
enum kinetis_chip::@8 cache_type
struct kinetis_chip * k_chip
enum kinetis_flash_bank::@6 flash_class
uint32_t protection_block
int(* deassert_reset)(struct target *target)
The implementation is responsible for polling the target such that target->state reflects the state c...
int(* assert_reset)(struct target *target)
struct target_type * type
void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value)
int target_write_buffer(struct target *target, target_addr_t address, uint32_t size, const uint8_t *buffer)
int target_write_u8(struct target *target, target_addr_t address, uint8_t value)
int target_read_u8(struct target *target, target_addr_t address, uint8_t *value)
int target_write_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
Write count items of size bytes to the memory of target at the address given.
uint32_t target_get_working_area_avail(struct target *target)
int target_alloc_working_area(struct target *target, uint32_t size, struct working_area **area)
int target_write_u32(struct target *target, target_addr_t address, uint32_t value)
int target_poll(struct target *target)
int target_free_working_area(struct target *target, struct working_area *area)
Free a working area.
int target_run_algorithm(struct target *target, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_param, target_addr_t entry_point, target_addr_t exit_point, int timeout_ms, void *arch_info)
Downloads a target-specific native code algorithm to the target, and executes it.
int target_read_u16(struct target *target, target_addr_t address, uint16_t *value)
int target_run_flash_async_algorithm(struct target *target, const uint8_t *buffer, uint32_t count, int block_size, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_params, uint32_t buffer_start, uint32_t buffer_size, uint32_t entry_point, uint32_t exit_point, void *arch_info)
Streams data to a circular buffer on target intended for consumption by code running asynchronously o...
int target_read_u32(struct target *target, target_addr_t address, uint32_t *value)
int target_read_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
Read count items of size bytes from the memory of target at the address given.
struct target * get_current_target(struct command_context *cmd_ctx)
#define ERROR_TARGET_NOT_HALTED
static const char * target_name(struct target *target)
Returns the instance-specific name of the specified target.
#define ERROR_TARGET_RESOURCE_NOT_AVAILABLE
#define ARRAY_SIZE(x)
Compute the number of elements of a variable length array.