OpenOCD
kinetis_ke.c
Go to the documentation of this file.
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 
3 /***************************************************************************
4  * Copyright (C) 2015 by Ivan Meleca *
5  * ivan@artekit.eu *
6  * *
7  * Modified from kinetis.c *
8  * *
9  * Copyright (C) 2011 by Mathias Kuester *
10  * kesmtp@freenet.de *
11  * *
12  * Copyright (C) 2011 sleep(5) ltd *
13  * tomas@sleepfive.com *
14  * *
15  * Copyright (C) 2012 by Christopher D. Kilgour *
16  * techie at whiterocker.com *
17  * *
18  * Copyright (C) 2013 Nemui Trinomius *
19  * nemuisan_kawausogasuki@live.jp *
20  * *
21  * Copyright (C) 2015 Tomas Vanek *
22  * vanekt@fbl.cz *
23  ***************************************************************************/
24 
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28 
29 #include "jtag/interface.h"
30 #include "imp.h"
31 #include <helper/binarybuffer.h>
32 #include <target/algorithm.h>
33 #include <target/arm_adi_v5.h>
34 #include <target/armv7m.h>
35 #include <target/cortex_m.h>
36 
37 /* Addresses */
38 #define SIM_SRSID 0x40048000
39 #define ICS_C1 0x40064000
40 #define ICS_C2 0x40064001
41 #define ICS_C3 0x40064002
42 #define ICS_C4 0x40064003
43 #define ICS_S 0x40064004
44 #define SIM_BUSDIV 0x40048018
45 #define SIM_CLKDIV_KE06 0x40048024
46 #define SIM_CLKDIV_KE04_44_64_80 0x40048024
47 #define SIM_CLKDIV_KE04_16_20_24 0x4004801C
48 #define WDOG_CS1 0x40052000
49 
50 #define ICS_C2_BDIV_MASK 0xE0
51 #define ICS_C2_BDIV_SHIFT 5
52 #define ICS_C2_BDIV(x) (((uint8_t)(((uint8_t)(x))<<ICS_C2_BDIV_SHIFT))&ICS_C2_BDIV_MASK)
53 #define ICS_S_LOCK_MASK 0x40
54 #define ICS_C4_SCFTRIM_MASK 0x1
55 #define SIM_CLKDIV_OUTDIV2_MASK 0x1000000
56 #define FTMRX_FCLKDIV_FDIV_MASK 0x3F
57 #define FTMRX_FCLKDIV_FDIV_SHIFT 0
58 #define FTMRX_FCLKDIV_FDIV(x) (((uint8_t)(((uint8_t)(x))<<FTMRX_FCLKDIV_FDIV_SHIFT))&FTMRX_FCLKDIV_FDIV_MASK)
59 #define FTMRX_FCLKDIV_FDIVLCK_MASK 0x40
60 #define FTMRX_FCLKDIV_FDIVLCK_SHIFT 6
61 #define FTMRX_FCLKDIV_FDIVLD_MASK 0x80
62 #define FTMRX_FCLKDIV_FDIVLD_SHIFT 7
63 #define FTMRX_FSTAT_CCIF_MASK 0x80
64 #define FTMRX_FSTAT_MGSTAT0_MASK 0x01
65 #define FTMRX_FSTAT_MGSTAT1_MASK 0x02
66 
67 /* Commands */
68 #define FTMRX_CMD_ALLERASED 0x01
69 #define FTMRX_CMD_BLOCKERASED 0x02
70 #define FTMRX_CMD_SECTIONERASED 0x03
71 #define FTMRX_CMD_READONCE 0x04
72 #define FTMRX_CMD_PROGFLASH 0x06
73 #define FTMRX_CMD_PROGONCE 0x07
74 #define FTMRX_CMD_ERASEALL 0x08
75 #define FTMRX_CMD_ERASEBLOCK 0x09
76 #define FTMRX_CMD_ERASESECTOR 0x0A
77 #define FTMRX_CMD_UNSECURE 0x0B
78 #define FTMRX_CMD_VERIFYACCESS 0x0C
79 #define FTMRX_CMD_SETMARGINLVL 0x0D
80 #define FTMRX_CMD_SETFACTORYLVL 0x0E
81 #define FTMRX_CMD_CONFIGNVM 0x0F
82 
83 /* Error codes */
84 #define FTMRX_ERROR_ACCERR 0x20
85 #define FTMRX_ERROR_FPVIOL 0x10
86 
87 #define KINETIS_KE_SRSID_FAMID(x) ((x >> 28) & 0x0F)
88 #define KINETIS_KE_SRSID_SUBFAMID(x) ((x >> 24) & 0x0F)
89 #define KINETIS_KE_SRSID_PINCOUNT(x) ((x >> 16) & 0x0F)
90 
91 #define KINETIS_KE_SRSID_KEX2 0x02
92 #define KINETIS_KE_SRSID_KEX4 0x04
93 #define KINETIS_KE_SRSID_KEX6 0x06
94 
96  uint32_t sector_size;
97  uint32_t protection_size;
98 
99  uint32_t sim_srsid;
106 };
107 
108 #define MDM_REG_STAT 0x00
109 #define MDM_REG_CTRL 0x04
110 #define MDM_REG_ID 0xfc
111 
112 #define MDM_STAT_FMEACK (1<<0)
113 #define MDM_STAT_FREADY (1<<1)
114 #define MDM_STAT_SYSSEC (1<<2)
115 #define MDM_STAT_SYSRES (1<<3)
116 #define MDM_STAT_FMEEN (1<<5)
117 #define MDM_STAT_BACKDOOREN (1<<6)
118 #define MDM_STAT_LPEN (1<<7)
119 #define MDM_STAT_VLPEN (1<<8)
120 #define MDM_STAT_LLSMODEXIT (1<<9)
121 #define MDM_STAT_VLLSXMODEXIT (1<<10)
122 #define MDM_STAT_CORE_HALTED (1<<16)
123 #define MDM_STAT_CORE_SLEEPDEEP (1<<17)
124 #define MDM_STAT_CORESLEEPING (1<<18)
125 
126 #define MEM_CTRL_FMEIP (1<<0)
127 #define MEM_CTRL_DBG_DIS (1<<1)
128 #define MEM_CTRL_DBG_REQ (1<<2)
129 #define MEM_CTRL_SYS_RES_REQ (1<<3)
130 #define MEM_CTRL_CORE_HOLD_RES (1<<4)
131 #define MEM_CTRL_VLLSX_DBG_REQ (1<<5)
132 #define MEM_CTRL_VLLSX_DBG_ACK (1<<6)
133 #define MEM_CTRL_VLLSX_STAT_ACK (1<<7)
134 
135 #define MDM_ACCESS_TIMEOUT 3000 /* iterations */
136 
137 static int kinetis_ke_mdm_write_register(struct adiv5_dap *dap, unsigned int reg, uint32_t value)
138 {
139  LOG_DEBUG("MDM_REG[0x%02x] <- %08" PRIX32, reg, value);
140 
141  struct adiv5_ap *ap = dap_get_ap(dap, 1);
142  if (!ap) {
143  LOG_DEBUG("MDM: failed to get AP");
144  return ERROR_FAIL;
145  }
146 
147  int retval = dap_queue_ap_write(ap, reg, value);
148  if (retval != ERROR_OK) {
149  LOG_DEBUG("MDM: failed to queue a write request");
150  dap_put_ap(ap);
151  return retval;
152  }
153 
154  retval = dap_run(dap);
155  dap_put_ap(ap);
156  if (retval != ERROR_OK) {
157  LOG_DEBUG("MDM: dap_run failed");
158  return retval;
159  }
160 
161  return ERROR_OK;
162 }
163 
164 static int kinetis_ke_mdm_read_register(struct adiv5_dap *dap, unsigned int reg, uint32_t *result)
165 {
166  struct adiv5_ap *ap = dap_get_ap(dap, 1);
167  if (!ap) {
168  LOG_DEBUG("MDM: failed to get AP");
169  return ERROR_FAIL;
170  }
171 
172  int retval = dap_queue_ap_read(ap, reg, result);
173  if (retval != ERROR_OK) {
174  LOG_DEBUG("MDM: failed to queue a read request");
175  dap_put_ap(ap);
176  return retval;
177  }
178 
179  retval = dap_run(dap);
180  dap_put_ap(ap);
181  if (retval != ERROR_OK) {
182  LOG_DEBUG("MDM: dap_run failed");
183  return retval;
184  }
185 
186  LOG_DEBUG("MDM_REG[0x%02x]: %08" PRIX32, reg, *result);
187  return ERROR_OK;
188 }
189 
190 static int kinetis_ke_mdm_poll_register(struct adiv5_dap *dap, unsigned int reg, uint32_t mask, uint32_t value)
191 {
192  uint32_t val;
193  int retval;
195 
196  do {
197  retval = kinetis_ke_mdm_read_register(dap, reg, &val);
198  if (retval != ERROR_OK || (val & mask) == value)
199  return retval;
200 
201  alive_sleep(1);
202  } while (timeout--);
203 
204  LOG_DEBUG("MDM: polling timed out");
205  return ERROR_FAIL;
206 }
207 
209 {
210  struct target *target = bank->target;
211  struct kinetis_ke_flash_bank *kinfo = bank->driver_priv;
212  uint8_t c2, c3, c4, s = 0;
213  uint16_t trim_value = 0;
214  uint16_t timeout = 0;
215  uint32_t bus_clock = 0;
216  uint32_t bus_reg_val = 0;
217  uint32_t bus_reg_addr = 0;
218  uint32_t flash_clk_div;
219  uint8_t fclkdiv;
220  int result;
221 
222  /*
223  * The RM states that the flash clock has to be set to 1MHz for writing and
224  * erasing operations (otherwise it can damage the flash).
225  * This function configures the entire clock tree to make sure we
226  * run at the specified clock. We'll set FEI mode running from the ~32KHz
227  * internal clock. So we need to:
228  * - Trim internal clock.
229  * - Configure the divider for ICSOUTCLK (ICS module).
230  * - Configure the divider to get a bus clock (SIM module).
231  * - Configure the flash clock that depends on the bus clock.
232  *
233  * For MKE02_40 and MKE02_20 we set ICSOUTCLK = 20MHz and bus clock = 20MHz.
234  * For MKE04 and MKE06 we run at ICSOUTCLK = 48MHz and bus clock = 24MHz.
235  */
236 
237  /*
238  * Trim internal clock
239  */
240  switch (KINETIS_KE_SRSID_SUBFAMID(kinfo->sim_srsid)) {
242  /* Both KE02_20 and KE02_40 should get the same trim value */
243  trim_value = 0x4C;
244  break;
245 
247  trim_value = 0x54;
248  break;
249 
251  trim_value = 0x58;
252  break;
253  }
254 
255  result = target_read_u8(target, ICS_C4, &c4);
256  if (result != ERROR_OK)
257  return result;
258 
259  c3 = trim_value;
260  c4 = (c4 & ~(ICS_C4_SCFTRIM_MASK)) | ((trim_value >> 8) & 0x01);
261 
262  result = target_write_u8(target, ICS_C3, c3);
263  if (result != ERROR_OK)
264  return result;
265 
266  result = target_write_u8(target, ICS_C4, c4);
267  if (result != ERROR_OK)
268  return result;
269 
270  result = target_read_u8(target, ICS_S, &s);
271  if (result != ERROR_OK)
272  return result;
273 
274  /* Wait */
275  while (!(s & ICS_S_LOCK_MASK)) {
276 
277  if (timeout <= 1000) {
278  timeout++;
279  alive_sleep(1);
280  } else {
281  return ERROR_FAIL;
282  }
283 
284  result = target_read_u8(target, ICS_S, &s);
285  if (result != ERROR_OK)
286  return result;
287  }
288 
289  /* ... trim done ... */
290 
291  /*
292  * Configure SIM (bus clock)
293  */
294  switch (KINETIS_KE_SRSID_SUBFAMID(kinfo->sim_srsid)) {
295  /* KE02 sub-family operates on SIM_BUSDIV */
297  bus_reg_val = 0;
298  bus_reg_addr = SIM_BUSDIV;
299  bus_clock = 20000000;
300  break;
301 
302  /* KE04 and KE06 sub-family operates on SIM_CLKDIV
303  * Clocks are divided by:
304  * DIV1 = core clock = 48MHz
305  * DIV2 = bus clock = 24Mhz
306  * DIV3 = timer clocks
307  * So we need to configure SIM_CLKDIV, DIV1 and DIV2 value
308  */
310  /* KE04 devices have the SIM_CLKDIV register at a different offset
311  * depending on the pin count. */
312  switch (KINETIS_KE_SRSID_PINCOUNT(kinfo->sim_srsid)) {
313  /* 16, 20 and 24 pins */
314  case 1:
315  case 2:
316  case 3:
317  bus_reg_addr = SIM_CLKDIV_KE04_16_20_24;
318  break;
319 
320  /* 44, 64 and 80 pins */
321  case 5:
322  case 7:
323  case 8:
324  bus_reg_addr = SIM_CLKDIV_KE04_44_64_80;
325  break;
326 
327  default:
328  LOG_ERROR("KE04 - Unknown pin count");
329  return ERROR_FAIL;
330  }
331 
332  bus_reg_val = SIM_CLKDIV_OUTDIV2_MASK;
333  bus_clock = 24000000;
334  break;
335 
337  bus_reg_val = SIM_CLKDIV_OUTDIV2_MASK;
338  bus_reg_addr = SIM_CLKDIV_KE06;
339  bus_clock = 24000000;
340  break;
341  }
342 
343  result = target_write_u32(target, bus_reg_addr, bus_reg_val);
344  if (result != ERROR_OK)
345  return result;
346 
347  /*
348  * Configure ICS to FEI (internal source)
349  */
350  result = target_read_u8(target, ICS_C2, &c2);
351  if (result != ERROR_OK)
352  return result;
353 
354  c2 &= ~ICS_C2_BDIV_MASK;
355 
356  switch (KINETIS_KE_SRSID_SUBFAMID(kinfo->sim_srsid)) {
358  /* Note: since there are two KE02 types, the KE02_40 @ 40MHz and the
359  * KE02_20 @ 20MHz, we divide here the ~40MHz ICSFLLCLK down to 20MHz,
360  * for compatibility.
361  */
362  c2 |= ICS_C2_BDIV(1);
363  break;
364 
367  /* For KE04 and KE06, the ICSFLLCLK can be 48MHz. */
368  c2 |= ICS_C2_BDIV(0);
369  break;
370  }
371 
372  result = target_write_u8(target, ICS_C2, c2);
373  if (result != ERROR_OK)
374  return result;
375 
376  /* Internal clock as reference (IREFS = 1) */
377  result = target_write_u8(target, ICS_C1, 4);
378  if (result != ERROR_OK)
379  return result;
380 
381  /* Wait for FLL to lock */
382  result = target_read_u8(target, ICS_S, &s);
383  if (result != ERROR_OK)
384  return result;
385 
386  while (!(s & ICS_S_LOCK_MASK)) {
387 
388  if (timeout <= 1000) {
389  timeout++;
390  alive_sleep(1);
391  } else {
393  }
394 
395  result = target_read_u8(target, ICS_S, &s);
396  if (result != ERROR_OK)
397  return result;
398  }
399 
400  /*
401  * Configure flash clock to 1MHz.
402  */
403  flash_clk_div = bus_clock / 1000000L - 1;
404 
405  /* Check if the FCLKDIV register is locked */
406  result = target_read_u8(target, kinfo->ftmrx_fclkdiv_addr, &fclkdiv);
407  if (result != ERROR_OK)
408  return result;
409 
410  if (!(fclkdiv & FTMRX_FCLKDIV_FDIVLCK_MASK)) {
411  /* Unlocked. Check if the register was configured, and if so, if it has the right value */
412  if ((fclkdiv & FTMRX_FCLKDIV_FDIVLD_MASK) &&
413  ((fclkdiv & FTMRX_FCLKDIV_FDIV_MASK) != FTMRX_FCLKDIV_FDIV(flash_clk_div))) {
414  LOG_WARNING("Flash clock was already set and contains an invalid value.");
415  LOG_WARNING("Please reset the target.");
416  return ERROR_FAIL;
417  }
418 
419  /* Finally, configure the flash clock */
420  fclkdiv = (fclkdiv & ~(FTMRX_FCLKDIV_FDIV_MASK)) | FTMRX_FCLKDIV_FDIV(flash_clk_div);
421  result = target_write_u8(target, kinfo->ftmrx_fclkdiv_addr, fclkdiv);
422  if (result != ERROR_OK)
423  return result;
424  } else {
425  /* Locked. Check if the current value is correct. */
426  if ((fclkdiv & FTMRX_FCLKDIV_FDIV_MASK) != FTMRX_FCLKDIV_FDIV(flash_clk_div)) {
427  LOG_WARNING("Flash clock register is locked and contains an invalid value.");
428  LOG_WARNING("Please reset the target.");
429  return ERROR_FAIL;
430  }
431  }
432 
433  LOG_INFO("Flash clock ready");
434  return ERROR_OK;
435 }
436 
438 {
439  struct working_area *watchdog_algorithm;
440  struct armv7m_algorithm armv7m_info;
441  int retval;
442  uint8_t cs1;
443 
444  static const uint8_t watchdog_code[] = {
445 #include "../../../contrib/loaders/flash/kinetis_ke/kinetis_ke_watchdog.inc"
446  };
447 
448  if (target->state != TARGET_HALTED) {
449  LOG_ERROR("Target not halted");
451  }
452 
453  /* Check if the watchdog is enabled */
454  retval = target_read_u8(target, WDOG_CS1, &cs1);
455  if (retval != ERROR_OK)
456  return retval;
457 
458  if (!(cs1 & 0x80)) {
459  /* Already stopped */
460  return ERROR_OK;
461  }
462 
463  /* allocate working area with watchdog code */
464  if (target_alloc_working_area(target, sizeof(watchdog_code), &watchdog_algorithm) != ERROR_OK) {
465  LOG_WARNING("No working area available for watchdog algorithm");
467  }
468 
469  retval = target_write_buffer(target, watchdog_algorithm->address,
470  sizeof(watchdog_code), watchdog_code);
471  if (retval != ERROR_OK)
472  return retval;
473 
474  armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
475  armv7m_info.core_mode = ARM_MODE_THREAD;
476 
477  retval = target_run_algorithm(target, 0, NULL, 0, NULL,
478  watchdog_algorithm->address, 0, 100000, &armv7m_info);
479  if (retval != ERROR_OK) {
480  LOG_ERROR("Error executing Kinetis KE watchdog algorithm");
481  } else {
482  LOG_INFO("Watchdog stopped");
483  }
484 
485  target_free_working_area(target, watchdog_algorithm);
486 
487  return retval;
488 }
489 
490 COMMAND_HANDLER(kinetis_ke_disable_wdog_handler)
491 {
493 
494  if (CMD_ARGC > 0)
496 
498 }
499 
500 COMMAND_HANDLER(kinetis_ke_mdm_mass_erase)
501 {
503  struct cortex_m_common *cortex_m = target_to_cm(target);
504  struct adiv5_dap *dap = cortex_m->armv7m.arm.dap;
505 
506  if (!dap) {
507  LOG_ERROR("Cannot perform mass erase with a high-level adapter");
508  return ERROR_FAIL;
509  }
510 
511  int retval;
512 
513  /* According to chapter 18.3.7.2 of the KE02 reference manual */
514 
515  /* assert SRST */
518 
519  /*
520  * 1. Reset the device by asserting RESET pin or DAP_CTRL[3]
521  */
523  if (retval != ERROR_OK)
524  return retval;
525 
526  /*
527  * ... Read the MDM-AP status register until the Flash Ready bit sets...
528  */
532  if (retval != ERROR_OK) {
533  LOG_ERROR("MDM : flash ready timeout");
534  return retval;
535  }
536 
537  /*
538  * 2. Set DAP_CTRL[0] bit to invoke debug mass erase via SWD
539  * 3. Release reset by deasserting RESET pin or DAP_CTRL[3] bit via SWD.
540  */
542  if (retval != ERROR_OK)
543  return retval;
544 
545  /* As a sanity check make sure that device started mass erase procedure */
548  if (retval != ERROR_OK)
549  return retval;
550 
551  /*
552  * 4. Wait till DAP_CTRL[0] bit is cleared (after mass erase completes,
553  * DAP_CTRL[0] bit is cleared automatically).
554  */
557  0);
558  if (retval != ERROR_OK)
559  return retval;
560 
563 
564  return ERROR_OK;
565 }
566 
567 static const uint32_t kinetis_ke_known_mdm_ids[] = {
568  0x001C0020, /* Kinetis-L/M/V/E/KE Series */
569 };
570 
571 /*
572  * This function implements the procedure to connect to
573  * SWD/JTAG on Kinetis K and L series of devices as it is described in
574  * AN4835 "Production Flash Programming Best Practices for Kinetis K-
575  * and L-series MCUs" Section 4.1.1
576  */
577 COMMAND_HANDLER(kinetis_ke_check_flash_security_status)
578 {
580  struct cortex_m_common *cortex_m = target_to_cm(target);
581  struct adiv5_dap *dap = cortex_m->armv7m.arm.dap;
582 
583  if (!dap) {
584  LOG_WARNING("Cannot check flash security status with a high-level adapter");
585  return ERROR_OK;
586  }
587 
588  uint32_t val;
589  int retval;
590 
591  /*
592  * ... The MDM-AP ID register can be read to verify that the
593  * connection is working correctly...
594  */
595  retval = kinetis_ke_mdm_read_register(dap, MDM_REG_ID, &val);
596  if (retval != ERROR_OK) {
597  LOG_ERROR("MDM: failed to read ID register");
598  goto fail;
599  }
600 
601  bool found = false;
602  for (size_t i = 0; i < ARRAY_SIZE(kinetis_ke_known_mdm_ids); i++) {
603  if (val == kinetis_ke_known_mdm_ids[i]) {
604  found = true;
605  break;
606  }
607  }
608 
609  if (!found)
610  LOG_WARNING("MDM: unknown ID %08" PRIX32, val);
611 
612  /*
613  * ... Read the MDM-AP status register until the Flash Ready bit sets...
614  */
618  if (retval != ERROR_OK) {
619  LOG_ERROR("MDM: flash ready timeout");
620  goto fail;
621  }
622 
623  /*
624  * ... Read the System Security bit to determine if security is enabled.
625  * If System Security = 0, then proceed. If System Security = 1, then
626  * communication with the internals of the processor, including the
627  * flash, will not be possible without issuing a mass erase command or
628  * unsecuring the part through other means (backdoor key unlock)...
629  */
630  retval = kinetis_ke_mdm_read_register(dap, MDM_REG_STAT, &val);
631  if (retval != ERROR_OK) {
632  LOG_ERROR("MDM: failed to read MDM_REG_STAT");
633  goto fail;
634  }
635 
636  if (val & MDM_STAT_SYSSEC) {
637  jtag_poll_set_enabled(false);
638 
639  LOG_WARNING("*********** ATTENTION! ATTENTION! ATTENTION! ATTENTION! **********");
640  LOG_WARNING("**** ****");
641  LOG_WARNING("**** Your Kinetis MCU is in secured state, which means that, ****");
642  LOG_WARNING("**** with exception for very basic communication, JTAG/SWD ****");
643  LOG_WARNING("**** interface will NOT work. In order to restore its ****");
644  LOG_WARNING("**** functionality please issue 'kinetis_ke mdm mass_erase' ****");
645  LOG_WARNING("**** command, power cycle the MCU and restart OpenOCD. ****");
646  LOG_WARNING("**** ****");
647  LOG_WARNING("*********** ATTENTION! ATTENTION! ATTENTION! ATTENTION! **********");
648  } else {
649  LOG_INFO("MDM: Chip is unsecured. Continuing.");
650  jtag_poll_set_enabled(true);
651  }
652 
653  return ERROR_OK;
654 
655 fail:
656  LOG_ERROR("MDM: Failed to check security status of the MCU. Cannot proceed further");
657  jtag_poll_set_enabled(false);
658  return retval;
659 }
660 
661 FLASH_BANK_COMMAND_HANDLER(kinetis_ke_flash_bank_command)
662 {
663  struct kinetis_ke_flash_bank *bank_info;
664 
665  if (CMD_ARGC < 6)
667 
668  LOG_INFO("add flash_bank kinetis_ke %s", bank->name);
669 
670  bank_info = malloc(sizeof(struct kinetis_ke_flash_bank));
671 
672  memset(bank_info, 0, sizeof(struct kinetis_ke_flash_bank));
673 
674  bank->driver_priv = bank_info;
675 
676  return ERROR_OK;
677 }
678 
679 /* Kinetis Program-LongWord Microcodes */
680 static uint8_t kinetis_ke_flash_write_code[] = {
681 #include "../../../contrib/loaders/flash/kinetis_ke/kinetis_ke_flash.inc"
682 };
683 
684 static int kinetis_ke_write_words(struct flash_bank *bank, const uint8_t *buffer,
685  uint32_t offset, uint32_t words)
686 {
687  struct kinetis_ke_flash_bank *kinfo = bank->driver_priv;
688  struct target *target = bank->target;
689  uint32_t ram_buffer_size = 512 + 16;
690  struct working_area *write_algorithm;
691  struct working_area *source;
692  uint32_t address = bank->base + offset;
693  struct reg_param reg_params[4];
694  struct armv7m_algorithm armv7m_info;
695  int retval = ERROR_OK;
696  uint32_t flash_code_size;
697 
698  LOG_INFO("Kinetis KE: FLASH Write ...");
699 
700  /* allocate working area with flash programming code */
702  &write_algorithm) != ERROR_OK) {
703  LOG_WARNING("no working area available, can't do block memory writes");
705  }
706 
707  /* Patch the FTMRx registers addresses */
708  flash_code_size = sizeof(kinetis_ke_flash_write_code);
709  buf_set_u32(&kinetis_ke_flash_write_code[flash_code_size-16], 0, 32, kinfo->ftmrx_fstat_addr);
710  buf_set_u32(&kinetis_ke_flash_write_code[flash_code_size-12], 0, 32, kinfo->ftmrx_fccobix_addr);
711  buf_set_u32(&kinetis_ke_flash_write_code[flash_code_size-8], 0, 32, kinfo->ftmrx_fccobhi_addr);
712  buf_set_u32(&kinetis_ke_flash_write_code[flash_code_size-4], 0, 32, kinfo->ftmrx_fccoblo_addr);
713 
714  retval = target_write_buffer(target, write_algorithm->address,
716  if (retval != ERROR_OK)
717  return retval;
718 
719  /* memory buffer */
720  if (target_alloc_working_area(target, ram_buffer_size, &source) != ERROR_OK) {
721  /* free working area, write algorithm already allocated */
722  target_free_working_area(target, write_algorithm);
723 
724  LOG_WARNING("No large enough working area available, can't do block memory writes");
726  }
727 
728  armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
729  armv7m_info.core_mode = ARM_MODE_THREAD;
730 
731  init_reg_param(&reg_params[0], "r0", 32, PARAM_IN_OUT);
732  init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
733  init_reg_param(&reg_params[2], "r2", 32, PARAM_OUT);
734  init_reg_param(&reg_params[3], "r3", 32, PARAM_OUT);
735 
736  buf_set_u32(reg_params[0].value, 0, 32, address);
737  buf_set_u32(reg_params[1].value, 0, 32, words);
738  buf_set_u32(reg_params[2].value, 0, 32, source->address);
739  buf_set_u32(reg_params[3].value, 0, 32, source->address + source->size);
740 
741  retval = target_run_flash_async_algorithm(target, buffer, words, 4,
742  0, NULL,
743  4, reg_params,
744  source->address, source->size,
745  write_algorithm->address, 0,
746  &armv7m_info);
747 
748  if (retval == ERROR_FLASH_OPERATION_FAILED) {
749  if (buf_get_u32(reg_params[0].value, 0, 32) & FTMRX_ERROR_ACCERR)
750  LOG_ERROR("flash access error");
751 
752  if (buf_get_u32(reg_params[0].value, 0, 32) & FTMRX_ERROR_FPVIOL)
753  LOG_ERROR("flash protection violation");
754  }
755 
757  target_free_working_area(target, write_algorithm);
758 
759  destroy_reg_param(&reg_params[0]);
760  destroy_reg_param(&reg_params[1]);
761  destroy_reg_param(&reg_params[2]);
762  destroy_reg_param(&reg_params[3]);
763 
764  return retval;
765 }
766 
767 static int kinetis_ke_protect(struct flash_bank *bank, int set,
768  unsigned int first, unsigned int last)
769 {
770  LOG_WARNING("kinetis_ke_protect not supported yet");
771  /* FIXME: TODO */
772 
773  if (bank->target->state != TARGET_HALTED) {
774  LOG_ERROR("Target not halted");
776  }
777 
779 }
780 
782 {
783  struct kinetis_ke_flash_bank *kinfo = bank->driver_priv;
784 
785  if (bank->target->state != TARGET_HALTED) {
786  LOG_ERROR("Target not halted");
788  }
789 
790  int result;
791  uint8_t fprot;
792  uint8_t fpopen, fpldis, fphdis;
793  uint8_t fphs, fpls;
794  uint32_t lprot_size = 0, hprot_size = 0;
795  uint32_t lprot_to = 0, hprot_from = 0;
796 
797  /* read protection register */
798  result = target_read_u8(bank->target, kinfo->ftmrx_fprot_addr, &fprot);
799 
800  if (result != ERROR_OK)
801  return result;
802 
803  fpopen = fprot & 0x80;
804  fpldis = fprot & 0x04;
805  fphdis = fprot & 0x20;
806  fphs = (fprot >> 3) & 0x03;
807  fpls = fprot & 0x03;
808 
809  /* Fully unprotected? */
810  if (fpopen && fpldis && fphdis) {
811  LOG_WARNING("No flash protection found.");
812 
813  for (unsigned int i = 0; i < bank->num_sectors; i++)
814  bank->sectors[i].is_protected = 0;
815 
816  kinfo->protection_size = 0;
817  } else {
818  LOG_WARNING("Flash protected. FPOPEN=%i FPLDIS=%i FPHDIS=%i FPLS=%i FPHS=%i",
819  fpopen ? 1 : 0, fpldis ? 1 : 0, fphdis ? 1 : 0, fpls, fphs);
820 
821  /* Retrieve which region is protected and how much */
822  if (fpopen) {
823  if (fpldis == 0)
824  lprot_size = (kinfo->sector_size * 4) << fpls;
825 
826  if (fphdis == 0)
827  hprot_size = (kinfo->sector_size * 2) << fphs;
828  } else {
829  if (fpldis == 1)
830  lprot_size = (kinfo->sector_size * 4) << fpls;
831 
832  if (fphdis == 1)
833  hprot_size = (kinfo->sector_size * 2) << fphs;
834  }
835 
836  kinfo->protection_size = lprot_size + hprot_size;
837 
838  /* lprot_to indicates up to where the lower region is protected */
839  lprot_to = lprot_size / kinfo->sector_size;
840 
841  /* hprot_from indicates from where the upper region is protected */
842  hprot_from = (0x8000 - hprot_size) / kinfo->sector_size;
843 
844  for (unsigned int i = 0; i < bank->num_sectors; i++) {
845 
846  /* Check if the sector is in the lower region */
847  if (bank->sectors[i].offset < 0x4000) {
848  /* Compare the sector start address against lprot_to */
849  if (lprot_to && (i < lprot_to))
850  bank->sectors[i].is_protected = 1;
851  else
852  bank->sectors[i].is_protected = 0;
853 
854  /* Check if the sector is between the lower and upper region
855  * OR after the upper region */
856  } else if (bank->sectors[i].offset < 0x6000 || bank->sectors[i].offset >= 0x8000) {
857  /* If fpopen is 1 then these regions are protected */
858  if (fpopen)
859  bank->sectors[i].is_protected = 0;
860  else
861  bank->sectors[i].is_protected = 1;
862 
863  /* Check if the sector is in the upper region */
864  } else if (bank->sectors[i].offset < 0x8000) {
865  if (hprot_from && (i > hprot_from))
866  bank->sectors[i].is_protected = 1;
867  else
868  bank->sectors[i].is_protected = 0;
869  }
870  }
871  }
872 
873  return ERROR_OK;
874 }
875 
876 static int kinetis_ke_ftmrx_command(struct flash_bank *bank, uint8_t count,
877  uint8_t *FCCOBIX, uint8_t *FCCOBHI, uint8_t *FCCOBLO, uint8_t *fstat)
878 {
879  uint8_t i;
880  int result;
881  struct target *target = bank->target;
882  struct kinetis_ke_flash_bank *kinfo = bank->driver_priv;
883  uint32_t timeout = 0;
884 
885  /* Clear error flags */
886  result = target_write_u8(target, kinfo->ftmrx_fstat_addr, 0x30);
887  if (result != ERROR_OK)
888  return result;
889 
890  for (i = 0; i < count; i++) {
891  /* Write index */
892  result = target_write_u8(target, kinfo->ftmrx_fccobix_addr, FCCOBIX[i]);
893  if (result != ERROR_OK)
894  return result;
895 
896  /* Write high part */
897  result = target_write_u8(target, kinfo->ftmrx_fccobhi_addr, FCCOBHI[i]);
898  if (result != ERROR_OK)
899  return result;
900 
901  /* Write low part (that is not always required) */
902  if (FCCOBLO) {
903  result = target_write_u8(target, kinfo->ftmrx_fccoblo_addr, FCCOBLO[i]);
904  if (result != ERROR_OK)
905  return result;
906  }
907  }
908 
909  /* Launch the command */
910  result = target_write_u8(target, kinfo->ftmrx_fstat_addr, 0x80);
911  if (result != ERROR_OK)
912  return result;
913 
914  /* Wait for it to finish */
915  result = target_read_u8(target, kinfo->ftmrx_fstat_addr, fstat);
916  if (result != ERROR_OK)
917  return result;
918 
919  while (!(*fstat & FTMRX_FSTAT_CCIF_MASK)) {
920  if (timeout <= 1000) {
921  timeout++;
922  alive_sleep(1);
923  } else {
925  }
926 
927  result = target_read_u8(target, kinfo->ftmrx_fstat_addr, fstat);
928  if (result != ERROR_OK)
929  return result;
930  }
931 
932  return ERROR_OK;
933 }
934 
935 static int kinetis_ke_erase(struct flash_bank *bank, unsigned int first,
936  unsigned int last)
937 {
938  int result;
939  uint8_t FCCOBIX[2], FCCOBHI[2], FCCOBLO[2], fstat;
940  bool fcf_erased = false;
941 
942  if (bank->target->state != TARGET_HALTED) {
943  LOG_ERROR("Target not halted");
945  }
946 
947  if ((first > bank->num_sectors) || (last > bank->num_sectors))
949 
950  result = kinetis_ke_prepare_flash(bank);
951  if (result != ERROR_OK)
952  return result;
953 
954  for (unsigned int i = first; i <= last; i++) {
955  FCCOBIX[0] = 0;
956  FCCOBHI[0] = FTMRX_CMD_ERASESECTOR;
957  FCCOBLO[0] = (bank->base + bank->sectors[i].offset) >> 16;
958 
959  FCCOBIX[1] = 1;
960  FCCOBHI[1] = (bank->base + bank->sectors[i].offset) >> 8;
961  FCCOBLO[1] = (bank->base + bank->sectors[i].offset);
962 
963  result = kinetis_ke_ftmrx_command(bank, 2, FCCOBIX, FCCOBHI, FCCOBLO, &fstat);
964 
965  if (result != ERROR_OK) {
966  LOG_WARNING("erase sector %u failed", i);
968  }
969 
970  if (i == 2)
971  fcf_erased = true;
972  }
973 
974  if (fcf_erased) {
976  ("flash configuration field erased, please reset the device");
977  }
978 
979  return ERROR_OK;
980 }
981 
982 static int kinetis_ke_write(struct flash_bank *bank, const uint8_t *buffer,
983  uint32_t offset, uint32_t count)
984 {
985  int result;
986  uint8_t *new_buffer = NULL;
987  uint32_t words = count / 4;
988 
989  if (bank->target->state != TARGET_HALTED) {
990  LOG_ERROR("Target not halted");
992  }
993 
994  if (offset > bank->size)
996 
997  if (offset & 0x3) {
998  LOG_WARNING("offset 0x%" PRIx32 " breaks the required alignment", offset);
1000  }
1001 
1002  result = kinetis_ke_stop_watchdog(bank->target);
1003  if (result != ERROR_OK)
1004  return result;
1005 
1006  result = kinetis_ke_prepare_flash(bank);
1007  if (result != ERROR_OK)
1008  return result;
1009 
1010  if (count & 0x3) {
1011  uint32_t old_count = count;
1012  count = (old_count | 3) + 1;
1013  new_buffer = malloc(count);
1014  if (!new_buffer) {
1015  LOG_ERROR("odd number of bytes to write and no memory "
1016  "for padding buffer");
1017  return ERROR_FAIL;
1018  }
1019 
1020  LOG_INFO("odd number of bytes to write (%" PRIu32 "), extending to %" PRIu32 " "
1021  "and padding with 0xff", old_count, count);
1022 
1023  memset(new_buffer, 0xff, count);
1024  buffer = memcpy(new_buffer, buffer, old_count);
1025  words++;
1026  }
1027 
1028  result = kinetis_ke_write_words(bank, buffer, offset, words);
1029  free(new_buffer);
1030 
1031  return result;
1032 }
1033 
1034 static int kinetis_ke_probe(struct flash_bank *bank)
1035 {
1036  int result;
1037  uint32_t offset = 0;
1038  struct target *target = bank->target;
1039  struct kinetis_ke_flash_bank *kinfo = bank->driver_priv;
1040 
1041  result = target_read_u32(target, SIM_SRSID, &kinfo->sim_srsid);
1042  if (result != ERROR_OK)
1043  return result;
1044 
1045  if (KINETIS_KE_SRSID_FAMID(kinfo->sim_srsid) != 0x00) {
1046  LOG_ERROR("Unsupported KE family");
1048  }
1049 
1050  switch (KINETIS_KE_SRSID_SUBFAMID(kinfo->sim_srsid)) {
1051  case KINETIS_KE_SRSID_KEX2:
1052  LOG_INFO("KE02 sub-family");
1053  break;
1054 
1055  case KINETIS_KE_SRSID_KEX4:
1056  LOG_INFO("KE04 sub-family");
1057  break;
1058 
1059  case KINETIS_KE_SRSID_KEX6:
1060  LOG_INFO("KE06 sub-family");
1061  break;
1062 
1063  default:
1064  LOG_ERROR("Unsupported KE sub-family");
1066  }
1067 
1068  /* We can only retrieve the ke0x part, but there is no way to know
1069  * the flash size, so assume the maximum flash size for the entire
1070  * sub family.
1071  */
1072  bank->base = 0x00000000;
1073  kinfo->sector_size = 512;
1074 
1075  switch (KINETIS_KE_SRSID_SUBFAMID(kinfo->sim_srsid)) {
1076  case KINETIS_KE_SRSID_KEX2:
1077  /* Max. 64KB */
1078  bank->size = 0x00010000;
1079  bank->num_sectors = 128;
1080 
1081  /* KE02 uses the FTMRH flash controller,
1082  * and registers have a different offset from the
1083  * FTMRE flash controller. Sort this out here.
1084  */
1085  kinfo->ftmrx_fclkdiv_addr = 0x40020000;
1086  kinfo->ftmrx_fccobix_addr = 0x40020002;
1087  kinfo->ftmrx_fstat_addr = 0x40020006;
1088  kinfo->ftmrx_fprot_addr = 0x40020008;
1089  kinfo->ftmrx_fccobhi_addr = 0x4002000A;
1090  kinfo->ftmrx_fccoblo_addr = 0x4002000B;
1091  break;
1092 
1093  case KINETIS_KE_SRSID_KEX6:
1094  case KINETIS_KE_SRSID_KEX4:
1095  /* Max. 128KB */
1096  bank->size = 0x00020000;
1097  bank->num_sectors = 256;
1098 
1099  /* KE04 and KE06 use the FTMRE flash controller,
1100  * and registers have a different offset from the
1101  * FTMRH flash controller. Sort this out here.
1102  */
1103  kinfo->ftmrx_fclkdiv_addr = 0x40020003;
1104  kinfo->ftmrx_fccobix_addr = 0x40020001;
1105  kinfo->ftmrx_fstat_addr = 0x40020005;
1106  kinfo->ftmrx_fprot_addr = 0x4002000B;
1107  kinfo->ftmrx_fccobhi_addr = 0x40020009;
1108  kinfo->ftmrx_fccoblo_addr = 0x40020008;
1109  break;
1110  }
1111 
1112  free(bank->sectors);
1113 
1114  assert(bank->num_sectors > 0);
1115  bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
1116 
1117  for (unsigned int i = 0; i < bank->num_sectors; i++) {
1118  bank->sectors[i].offset = offset;
1119  bank->sectors[i].size = kinfo->sector_size;
1120  offset += kinfo->sector_size;
1121  bank->sectors[i].is_erased = -1;
1122  bank->sectors[i].is_protected = 1;
1123  }
1124 
1125  return ERROR_OK;
1126 }
1127 
1129 {
1130  struct kinetis_ke_flash_bank *kinfo = bank->driver_priv;
1131 
1132  if (kinfo->sim_srsid)
1133  return ERROR_OK;
1134 
1135  return kinetis_ke_probe(bank);
1136 }
1137 
1139 {
1140  command_print_sameline(cmd, "%s driver for flash bank %s at " TARGET_ADDR_FMT,
1141  bank->driver->name, bank->name, bank->base);
1142 
1143  return ERROR_OK;
1144 }
1145 
1147 {
1148  uint8_t FCCOBIX[3], FCCOBHI[3], FCCOBLO[3], fstat;
1149  uint16_t longwords = 0;
1150  int result;
1151 
1152  if (bank->target->state != TARGET_HALTED) {
1153  LOG_ERROR("Target not halted");
1154  return ERROR_TARGET_NOT_HALTED;
1155  }
1156 
1157  result = kinetis_ke_prepare_flash(bank);
1158  if (result != ERROR_OK)
1159  return result;
1160 
1161  /* check if whole bank is blank */
1162  FCCOBIX[0] = 0;
1163  FCCOBHI[0] = FTMRX_CMD_ALLERASED;
1164 
1165  result = kinetis_ke_ftmrx_command(bank, 1, FCCOBIX, FCCOBHI, NULL, &fstat);
1166 
1167  if (result != ERROR_OK)
1168  return result;
1169 
1171  /* the whole bank is not erased, check sector-by-sector */
1172  for (unsigned int i = 0; i < bank->num_sectors; i++) {
1173  FCCOBIX[0] = 0;
1174  FCCOBHI[0] = FTMRX_CMD_SECTIONERASED;
1175  FCCOBLO[0] = (bank->base + bank->sectors[i].offset) >> 16;
1176 
1177  FCCOBIX[1] = 1;
1178  FCCOBHI[1] = (bank->base + bank->sectors[i].offset) >> 8;
1179  FCCOBLO[1] = (bank->base + bank->sectors[i].offset);
1180 
1181  longwords = 128;
1182 
1183  FCCOBIX[2] = 2;
1184  FCCOBHI[2] = longwords >> 8;
1185  FCCOBLO[2] = longwords;
1186 
1187  result = kinetis_ke_ftmrx_command(bank, 3, FCCOBIX, FCCOBHI, FCCOBLO, &fstat);
1188 
1189  if (result == ERROR_OK) {
1190  bank->sectors[i].is_erased = !(fstat & (FTMRX_FSTAT_MGSTAT0_MASK | FTMRX_FSTAT_MGSTAT1_MASK));
1191  } else {
1192  LOG_DEBUG("Ignoring error on PFlash sector blank-check");
1193  bank->sectors[i].is_erased = -1;
1194  }
1195  }
1196  } else {
1197  /* the whole bank is erased, update all sectors */
1198  for (unsigned int i = 0; i < bank->num_sectors; i++)
1199  bank->sectors[i].is_erased = 1;
1200  }
1201 
1202  return ERROR_OK;
1203 }
1204 
1206  {
1207  .name = "check_security",
1208  .mode = COMMAND_EXEC,
1209  .help = "Check status of device security lock",
1210  .usage = "",
1211  .handler = kinetis_ke_check_flash_security_status,
1212  },
1213  {
1214  .name = "mass_erase",
1215  .mode = COMMAND_EXEC,
1216  .help = "Issue a complete flash erase via the MDM-AP",
1217  .usage = "",
1218  .handler = kinetis_ke_mdm_mass_erase,
1219  },
1221 };
1222 
1224  {
1225  .name = "mdm",
1226  .mode = COMMAND_ANY,
1227  .help = "MDM-AP command group",
1228  .usage = "",
1230  },
1231  {
1232  .name = "disable_wdog",
1233  .mode = COMMAND_EXEC,
1234  .help = "Disable the watchdog timer",
1235  .usage = "",
1236  .handler = kinetis_ke_disable_wdog_handler,
1237  },
1239 };
1240 
1241 static const struct command_registration kinetis_ke_command_handler[] = {
1242  {
1243  .name = "kinetis_ke",
1244  .mode = COMMAND_ANY,
1245  .help = "Kinetis KE flash controller commands",
1246  .usage = "",
1248  },
1250 };
1251 
1252 const struct flash_driver kinetis_ke_flash = {
1253  .name = "kinetis_ke",
1254  .commands = kinetis_ke_command_handler,
1255  .flash_bank_command = kinetis_ke_flash_bank_command,
1256  .erase = kinetis_ke_erase,
1257  .protect = kinetis_ke_protect,
1258  .write = kinetis_ke_write,
1259  .read = default_flash_read,
1260  .probe = kinetis_ke_probe,
1261  .auto_probe = kinetis_ke_auto_probe,
1262  .erase_check = kinetis_ke_blank_check,
1263  .protect_check = kinetis_ke_protect_check,
1264  .info = kinetis_ke_info,
1265  .free_driver_priv = default_flash_free_driver_priv,
1266 };
void init_reg_param(struct reg_param *param, const char *reg_name, uint32_t size, enum param_direction direction)
Definition: algorithm.c:29
void destroy_reg_param(struct reg_param *param)
Definition: algorithm.c:38
@ PARAM_OUT
Definition: algorithm.h:16
@ PARAM_IN_OUT
Definition: algorithm.h:17
@ ARM_MODE_THREAD
Definition: arm.h:94
struct adiv5_ap * dap_get_ap(struct adiv5_dap *dap, uint64_t ap_num)
Definition: arm_adi_v5.c:1197
int dap_put_ap(struct adiv5_ap *ap)
Definition: arm_adi_v5.c:1217
This defines formats and data structures used to talk to ADIv5 entities.
static int dap_queue_ap_read(struct adiv5_ap *ap, unsigned int reg, uint32_t *data)
Queue an AP register read.
Definition: arm_adi_v5.h:590
static int dap_queue_ap_write(struct adiv5_ap *ap, unsigned int reg, uint32_t data)
Queue an AP register write.
Definition: arm_adi_v5.h:610
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...
Definition: arm_adi_v5.h:648
#define ARMV7M_COMMON_MAGIC
Definition: armv7m.h:224
Support functions to access arbitrary bits in a byte array.
static uint32_t buf_get_u32(const uint8_t *_buffer, unsigned int first, unsigned int num)
Retrieves num bits from _buffer, starting at the first bit, returning the bits in a 32-bit word.
Definition: binarybuffer.h:104
static void buf_set_u32(uint8_t *_buffer, unsigned int first, unsigned int num, uint32_t value)
Sets num bits in _buffer, starting at the first bit, using the bits in value.
Definition: binarybuffer.h:34
void command_print_sameline(struct command_invocation *cmd, const char *format,...)
Definition: command.c:348
#define ERROR_COMMAND_SYNTAX_ERROR
Definition: command.h:400
#define CMD_ARGC
Use this macro to access the number of arguments for the command being handled, rather than accessing...
Definition: command.h:151
#define CMD_CTX
Use this macro to access the context of the command being handled, rather than accessing the variable...
Definition: command.h:146
#define COMMAND_REGISTRATION_DONE
Use this as the last entry in an array of command_registration records.
Definition: command.h:251
@ COMMAND_ANY
Definition: command.h:42
@ COMMAND_EXEC
Definition: command.h:40
static struct cortex_m_common * target_to_cm(struct target *target)
Definition: cortex_m.h:301
uint64_t buffer
Pointer to data buffer to send over SPI.
Definition: dw-spi-helper.h:0
uint32_t address
Starting address. Sector aligned.
Definition: dw-spi-helper.h:0
uint8_t bank
Definition: esirisc.c:135
#define ERROR_FLASH_OPER_UNSUPPORTED
Definition: flash/common.h:36
#define ERROR_FLASH_BANK_INVALID
Definition: flash/common.h:28
#define ERROR_FLASH_OPERATION_FAILED
Definition: flash/common.h:30
#define ERROR_FLASH_DST_BREAKS_ALIGNMENT
Definition: flash/common.h:32
int default_flash_read(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
Provides default read implementation for flash memory.
void default_flash_free_driver_priv(struct flash_bank *bank)
Deallocates bank->driver_priv.
void jtag_poll_set_enabled(bool value)
Assign flag reporting whether JTAG polling is disallowed.
Definition: jtag/core.c:171
int adapter_deassert_reset(void)
Definition: jtag/core.c:1912
enum reset_types jtag_get_reset_config(void)
Definition: jtag/core.c:1747
int adapter_assert_reset(void)
Definition: jtag/core.c:1892
@ RESET_HAS_SRST
Definition: jtag.h:218
#define ICS_C4
Definition: kinetis_ke.c:42
COMMAND_HANDLER(kinetis_ke_disable_wdog_handler)
Definition: kinetis_ke.c:490
#define WDOG_CS1
Definition: kinetis_ke.c:48
#define KINETIS_KE_SRSID_KEX6
Definition: kinetis_ke.c:93
static int kinetis_ke_ftmrx_command(struct flash_bank *bank, uint8_t count, uint8_t *FCCOBIX, uint8_t *FCCOBHI, uint8_t *FCCOBLO, uint8_t *fstat)
Definition: kinetis_ke.c:876
#define SIM_CLKDIV_KE06
Definition: kinetis_ke.c:45
static int kinetis_ke_mdm_read_register(struct adiv5_dap *dap, unsigned int reg, uint32_t *result)
Definition: kinetis_ke.c:164
#define MDM_STAT_SYSSEC
Definition: kinetis_ke.c:114
static int kinetis_ke_protect(struct flash_bank *bank, int set, unsigned int first, unsigned int last)
Definition: kinetis_ke.c:767
#define MDM_STAT_FMEACK
Definition: kinetis_ke.c:112
static int kinetis_ke_erase(struct flash_bank *bank, unsigned int first, unsigned int last)
Definition: kinetis_ke.c:935
#define FTMRX_FCLKDIV_FDIVLD_MASK
Definition: kinetis_ke.c:61
#define MDM_REG_ID
Definition: kinetis_ke.c:110
static int kinetis_ke_auto_probe(struct flash_bank *bank)
Definition: kinetis_ke.c:1128
static int kinetis_ke_blank_check(struct flash_bank *bank)
Definition: kinetis_ke.c:1146
#define KINETIS_KE_SRSID_FAMID(x)
Definition: kinetis_ke.c:87
#define MEM_CTRL_FMEIP
Definition: kinetis_ke.c:126
static const uint32_t kinetis_ke_known_mdm_ids[]
Definition: kinetis_ke.c:567
#define FTMRX_ERROR_FPVIOL
Definition: kinetis_ke.c:85
#define ICS_S
Definition: kinetis_ke.c:43
#define FTMRX_FCLKDIV_FDIV(x)
Definition: kinetis_ke.c:58
#define ICS_C2
Definition: kinetis_ke.c:40
#define FTMRX_FSTAT_CCIF_MASK
Definition: kinetis_ke.c:63
static const struct command_registration kinetis_ke_exec_command_handlers[]
Definition: kinetis_ke.c:1223
static int kinetis_ke_protect_check(struct flash_bank *bank)
Definition: kinetis_ke.c:781
FLASH_BANK_COMMAND_HANDLER(kinetis_ke_flash_bank_command)
Definition: kinetis_ke.c:661
#define FTMRX_FCLKDIV_FDIV_MASK
Definition: kinetis_ke.c:56
#define FTMRX_ERROR_ACCERR
Definition: kinetis_ke.c:84
#define ICS_C4_SCFTRIM_MASK
Definition: kinetis_ke.c:54
static int kinetis_ke_mdm_poll_register(struct adiv5_dap *dap, unsigned int reg, uint32_t mask, uint32_t value)
Definition: kinetis_ke.c:190
#define FTMRX_CMD_ALLERASED
Definition: kinetis_ke.c:68
#define ICS_S_LOCK_MASK
Definition: kinetis_ke.c:53
#define MEM_CTRL_SYS_RES_REQ
Definition: kinetis_ke.c:129
static const struct command_registration kinetis_ke_security_command_handlers[]
Definition: kinetis_ke.c:1205
static int kinetis_ke_stop_watchdog(struct target *target)
Definition: kinetis_ke.c:437
#define MDM_REG_STAT
Definition: kinetis_ke.c:108
#define FTMRX_FSTAT_MGSTAT1_MASK
Definition: kinetis_ke.c:65
#define ICS_C2_BDIV(x)
Definition: kinetis_ke.c:52
static int kinetis_ke_prepare_flash(struct flash_bank *bank)
Definition: kinetis_ke.c:208
const struct flash_driver kinetis_ke_flash
Definition: kinetis_ke.c:1252
#define FTMRX_CMD_ERASESECTOR
Definition: kinetis_ke.c:76
#define FTMRX_FSTAT_MGSTAT0_MASK
Definition: kinetis_ke.c:64
#define SIM_SRSID
Definition: kinetis_ke.c:38
static uint8_t kinetis_ke_flash_write_code[]
Definition: kinetis_ke.c:680
#define ICS_C1
Definition: kinetis_ke.c:39
#define SIM_CLKDIV_KE04_44_64_80
Definition: kinetis_ke.c:46
#define KINETIS_KE_SRSID_PINCOUNT(x)
Definition: kinetis_ke.c:89
static const struct command_registration kinetis_ke_command_handler[]
Definition: kinetis_ke.c:1241
#define KINETIS_KE_SRSID_SUBFAMID(x)
Definition: kinetis_ke.c:88
#define MDM_ACCESS_TIMEOUT
Definition: kinetis_ke.c:135
#define MDM_STAT_FREADY
Definition: kinetis_ke.c:113
#define KINETIS_KE_SRSID_KEX2
Definition: kinetis_ke.c:91
#define MDM_REG_CTRL
Definition: kinetis_ke.c:109
static int kinetis_ke_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
Definition: kinetis_ke.c:982
#define MDM_STAT_SYSRES
Definition: kinetis_ke.c:115
#define ICS_C2_BDIV_MASK
Definition: kinetis_ke.c:50
#define FTMRX_FCLKDIV_FDIVLCK_MASK
Definition: kinetis_ke.c:59
#define KINETIS_KE_SRSID_KEX4
Definition: kinetis_ke.c:92
static int kinetis_ke_mdm_write_register(struct adiv5_dap *dap, unsigned int reg, uint32_t value)
Definition: kinetis_ke.c:137
#define ICS_C3
Definition: kinetis_ke.c:41
#define SIM_CLKDIV_KE04_16_20_24
Definition: kinetis_ke.c:47
static int kinetis_ke_write_words(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t words)
Definition: kinetis_ke.c:684
static int kinetis_ke_probe(struct flash_bank *bank)
Definition: kinetis_ke.c:1034
#define FTMRX_CMD_SECTIONERASED
Definition: kinetis_ke.c:70
#define SIM_CLKDIV_OUTDIV2_MASK
Definition: kinetis_ke.c:55
#define SIM_BUSDIV
Definition: kinetis_ke.c:44
static int kinetis_ke_info(struct flash_bank *bank, struct command_invocation *cmd)
Definition: kinetis_ke.c:1138
void alive_sleep(uint64_t ms)
Definition: log.c:468
#define LOG_WARNING(expr ...)
Definition: log.h:130
#define ERROR_FAIL
Definition: log.h:174
#define LOG_ERROR(expr ...)
Definition: log.h:133
#define LOG_INFO(expr ...)
Definition: log.h:127
#define LOG_DEBUG(expr ...)
Definition: log.h:110
#define ERROR_OK
Definition: log.h:168
uint8_t mask
Definition: parport.c:67
struct rtt_source source
Definition: rtt/rtt.c:23
This represents an ARM Debug Interface (v5) Access Port (AP).
Definition: arm_adi_v5.h:250
struct adiv5_dap * dap
DAP this AP belongs to.
Definition: arm_adi_v5.h:254
This represents an ARM Debug Interface (v5) Debug Access Port (DAP).
Definition: arm_adi_v5.h:348
struct adiv5_dap * dap
For targets conforming to ARM Debug Interface v5, this handle references the Debug Access Port (DAP) ...
Definition: arm.h:257
unsigned int common_magic
Definition: armv7m.h:299
enum arm_mode core_mode
Definition: armv7m.h:301
struct arm arm
Definition: armv7m.h:229
When run_command is called, a new instance will be created on the stack, filled with the proper value...
Definition: command.h:76
const char * name
Definition: command.h:234
struct armv7m_common armv7m
Definition: cortex_m.h:229
Provides details of a flash bank, available either on-chip or through a major interface.
Definition: nor/core.h:75
Provides the implementation-independent structure that defines all of the callbacks required by OpenO...
Definition: nor/driver.h:39
const char * name
Gives a human-readable name of this flash driver, This field is used to select and initialize the dri...
Definition: nor/driver.h:44
Describes the geometry and status of a single flash sector within a flash bank.
Definition: nor/core.h:28
uint32_t protection_size
Definition: kinetis_ke.c:97
uint32_t ftmrx_fccobhi_addr
Definition: kinetis_ke.c:104
uint32_t ftmrx_fprot_addr
Definition: kinetis_ke.c:103
uint32_t ftmrx_fstat_addr
Definition: kinetis_ke.c:102
uint32_t ftmrx_fclkdiv_addr
Definition: kinetis_ke.c:100
uint32_t ftmrx_fccobix_addr
Definition: kinetis_ke.c:101
uint32_t ftmrx_fccoblo_addr
Definition: kinetis_ke.c:105
Definition: register.h:111
Definition: target.h:119
enum target_state state
Definition: target.h:160
Definition: psoc6.c:83
target_addr_t address
Definition: target.h:89
int target_write_buffer(struct target *target, target_addr_t address, uint32_t size, const uint8_t *buffer)
Definition: target.c:2351
int target_write_u8(struct target *target, target_addr_t address, uint8_t value)
Definition: target.c:2692
int target_read_u8(struct target *target, target_addr_t address, uint8_t *value)
Definition: target.c:2607
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, unsigned int timeout_ms, void *arch_info)
Downloads a target-specific native code algorithm to the target, and executes it.
Definition: target.c:783
int target_alloc_working_area(struct target *target, uint32_t size, struct working_area **area)
Definition: target.c:2070
int target_write_u32(struct target *target, target_addr_t address, uint32_t value)
Definition: target.c:2650
int target_free_working_area(struct target *target, struct working_area *area)
Free a working area.
Definition: target.c:2128
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...
Definition: target.c:940
int target_read_u32(struct target *target, target_addr_t address, uint32_t *value)
Definition: target.c:2559
struct target * get_current_target(struct command_context *cmd_ctx)
Definition: target.c:467
#define ERROR_TARGET_NOT_HALTED
Definition: target.h:786
@ TARGET_HALTED
Definition: target.h:58
#define ERROR_TARGET_RESOURCE_NOT_AVAILABLE
Definition: target.h:790
#define TARGET_ADDR_FMT
Definition: types.h:286
#define ARRAY_SIZE(x)
Compute the number of elements of a variable length array.
Definition: types.h:57
#define NULL
Definition: usb.h:16
uint8_t cmd
Definition: vdebug.c:1
uint8_t offset[4]
Definition: vdebug.c:9
uint8_t count[4]
Definition: vdebug.c:22