diff --git a/src/target/kinetis.c b/src/target/kinetis.c index cf8527b..3c075bd 100644 --- a/src/target/kinetis.c +++ b/src/target/kinetis.c @@ -39,36 +39,56 @@ #include "target_internal.h" #include "adiv5.h" +#define KINETIS_MDM_IDR_K22F 0x1c0000 +#define KINETIS_MDM_IDR_KZ03 0x1c0020 + +#define MDM_STATUS ADIV5_AP_REG(0x00) +#define MDM_CONTROL ADIV5_AP_REG(0x04) + +#define MDM_STATUS_MASS_ERASE_ACK (1 << 0) +#define MDM_STATUS_FLASH_READY (1 << 1) +#define MDM_STATUS_MASS_ERASE_ENABLED (1 << 5) +#define MDM_STATUS_BACK_KEY_ENABLED (1 << 6) + +#define MDM_CONTROL_MASS_ERASE (1 << 0) +#define MDM_CONTROL_SYS_RESET (1 << 3) + #define SIM_SDID 0x40048024 #define SIM_FCFG1 0x4004804C -#define FTFA_BASE 0x40020000 -#define FTFA_FSTAT (FTFA_BASE + 0x00) -#define FTFA_FCNFG (FTFA_BASE + 0x01) -#define FTFA_FSEC (FTFA_BASE + 0x02) -#define FTFA_FOPT (FTFA_BASE + 0x03) -#define FTFA_FCCOB_0 (FTFA_BASE + 0x04) -#define FTFA_FCCOB_1 (FTFA_BASE + 0x08) -#define FTFA_FCCOB_2 (FTFA_BASE + 0x0C) +#define FLASH_SECURITY_BYTE_ADDRESS 0x40C +#define FLASH_SECURITY_BYTE_UNSECURED 0xFE -#define FTFA_FSTAT_CCIF (1 << 7) -#define FTFA_FSTAT_RDCOLERR (1 << 6) -#define FTFA_FSTAT_ACCERR (1 << 5) -#define FTFA_FSTAT_FPVIOL (1 << 4) -#define FTFA_FSTAT_MGSTAT0 (1 << 0) +#define FTFx_BASE 0x40020000 +#define FTFx_FSTAT (FTFx_BASE + 0x00) +#define FTFx_FCNFG (FTFx_BASE + 0x01) +#define FTFx_FSEC (FTFx_BASE + 0x02) +#define FTFx_FOPT (FTFx_BASE + 0x03) +#define FTFx_FCCOB0 (FTFx_BASE + 0x04) +#define FTFx_FCCOB4 (FTFx_BASE + 0x08) +#define FTFx_FCCOB8 (FTFx_BASE + 0x0C) -#define FTFA_CMD_CHECK_ERASE 0x01 -#define FTFA_CMD_PROGRAM_CHECK 0x02 -#define FTFA_CMD_READ_RESOURCE 0x03 -#define FTFA_CMD_PROGRAM_LONGWORD 0x06 +#define FTFx_FSTAT_CCIF (1 << 7) +#define FTFx_FSTAT_RDCOLERR (1 << 6) +#define FTFx_FSTAT_ACCERR (1 << 5) +#define FTFx_FSTAT_FPVIOL (1 << 4) +#define FTFx_FSTAT_MGSTAT0 (1 << 0) + +#define FTFx_FSEC_KEYEN_MSK (0b11 << 6) +#define FTFx_FSEC_KEYEN (0b10 << 6) + +#define FTFx_CMD_CHECK_ERASE 0x01 +#define FTFx_CMD_PROGRAM_CHECK 0x02 +#define FTFx_CMD_READ_RESOURCE 0x03 +#define FTFx_CMD_PROGRAM_LONGWORD 0x06 /* Part of the FTFE module for K64 */ -#define FTFE_CMD_PROGRAM_PHRASE 0x07 -#define FTFA_CMD_ERASE_SECTOR 0x09 -#define FTFA_CMD_CHECK_ERASE_ALL 0x40 -#define FTFA_CMD_READ_ONCE 0x41 -#define FTFA_CMD_PROGRAM_ONCE 0x43 -#define FTFA_CMD_ERASE_ALL 0x44 -#define FTFA_CMD_BACKDOOR_ACCESS 0x45 +#define FTFx_CMD_PROGRAM_PHRASE 0x07 +#define FTFx_CMD_ERASE_SECTOR 0x09 +#define FTFx_CMD_CHECK_ERASE_ALL 0x40 +#define FTFx_CMD_READ_ONCE 0x41 +#define FTFx_CMD_PROGRAM_ONCE 0x43 +#define FTFx_CMD_ERASE_ALL 0x44 +#define FTFx_CMD_BACKDOOR_ACCESS 0x45 #define KL_WRITE_LEN 4 /* 8 byte phrases need to be written to the k64 flash */ @@ -78,7 +98,8 @@ static bool kinetis_cmd_unsafe(target *t, int argc, char **argv); const struct command_s kinetis_cmd_list[] = { {"unsafe", (cmd_handler)kinetis_cmd_unsafe, "Allow programming security byte (enable|disable)"}, - {NULL, NULL, NULL}}; + {NULL, NULL, NULL}, +}; static bool kinetis_cmd_unsafe(target *t, int argc, char **argv) { @@ -90,16 +111,16 @@ static bool kinetis_cmd_unsafe(target *t, int argc, char **argv) return true; } -static int kl_gen_flash_erase(struct target_flash *f, target_addr addr, size_t len); -static int kl_gen_flash_write(struct target_flash *f, target_addr dest, const void *src, size_t len); -static int kl_gen_flash_done(struct target_flash *f); +static int kinetis_flash_cmd_erase(struct target_flash *f, target_addr addr, size_t len); +static int kinetis_flash_cmd_write(struct target_flash *f, target_addr dest, const void *src, size_t len); +static int kinetis_flash_done(struct target_flash *f); struct kinetis_flash { struct target_flash f; uint8_t write_len; }; -static void kl_gen_add_flash( +static void kinetis_add_flash( target *const t, const uint32_t addr, const size_t length, const size_t erasesize, const size_t write_len) { struct kinetis_flash *kf = calloc(1, sizeof(*kf)); @@ -114,9 +135,9 @@ static void kl_gen_add_flash( f->start = addr; f->length = length; f->blocksize = erasesize; - f->erase = kl_gen_flash_erase; - f->write = kl_gen_flash_write; - f->done = kl_gen_flash_done; + f->erase = kinetis_flash_cmd_erase; + f->write = kinetis_flash_cmd_write; + f->done = kinetis_flash_done; f->erased = 0xff; kf->write_len = write_len; target_add_flash(t, f); @@ -129,8 +150,8 @@ static void kl_s32k14_setup( target_add_ram(t, sram_l, 0x20000000 - sram_l); target_add_ram(t, 0x20000000, sram_h); - kl_gen_add_flash(t, 0x00000000, flash_size, 0x1000, K64_WRITE_LEN); /* P-Flash, 4 KB Sectors */ - kl_gen_add_flash(t, 0x10000000, flexmem_size, 0x1000, K64_WRITE_LEN); /* FlexNVM, 4 KB Sectors */ + kinetis_add_flash(t, 0x00000000, flash_size, 0x1000, K64_WRITE_LEN); /* P-Flash, 4 KB Sectors */ + kinetis_add_flash(t, 0x10000000, flexmem_size, 0x1000, K64_WRITE_LEN); /* FlexNVM, 4 KB Sectors */ } bool kinetis_probe(target *const t) @@ -167,22 +188,22 @@ bool kinetis_probe(target *const t) switch ((fcfg1 >> 24) & 0x0f) { case 0x03: /* 32 KB */ t->driver = "KL16Z32Vxxx"; - kl_gen_add_flash(t, 0x00000000, 0x08000, 0x400, KL_WRITE_LEN); + kinetis_add_flash(t, 0x00000000, 0x08000, 0x400, KL_WRITE_LEN); break; case 0x05: /* 64 KB */ t->driver = "KL16Z64Vxxx"; - kl_gen_add_flash(t, 0x00000000, 0x10000, 0x400, KL_WRITE_LEN); + kinetis_add_flash(t, 0x00000000, 0x10000, 0x400, KL_WRITE_LEN); break; case 0x07: /* 128 KB */ t->driver = "KL16Z128Vxxx"; - kl_gen_add_flash(t, 0x00000000, 0x20000, 0x400, KL_WRITE_LEN); + kinetis_add_flash(t, 0x00000000, 0x20000, 0x400, KL_WRITE_LEN); break; case 0x09: /* 256 KB */ t->driver = "KL16Z256Vxxx"; - kl_gen_add_flash(t, 0x00000000, 0x40000, 0x400, KL_WRITE_LEN); + kinetis_add_flash(t, 0x00000000, 0x40000, 0x400, KL_WRITE_LEN); break; default: return false; @@ -195,13 +216,13 @@ bool kinetis_probe(target *const t) t->driver = "KL25"; target_add_ram(t, 0x1ffff000, 0x1000); target_add_ram(t, 0x20000000, 0x3000); - kl_gen_add_flash(t, 0x00000000, 0x20000, 0x400, KL_WRITE_LEN); + kinetis_add_flash(t, 0x00000000, 0x20000, 0x400, KL_WRITE_LEN); break; case 0x231: t->driver = "KL27x128"; // MKL27 >=128kb target_add_ram(t, 0x1fffe000, 0x2000); target_add_ram(t, 0x20000000, 0x6000); - kl_gen_add_flash(t, 0x00000000, 0x40000, 0x400, KL_WRITE_LEN); + kinetis_add_flash(t, 0x00000000, 0x40000, 0x400, KL_WRITE_LEN); break; case 0x271: switch ((sdid >> 16) & 0x0f) { @@ -209,13 +230,13 @@ bool kinetis_probe(target *const t) t->driver = "KL27x32"; target_add_ram(t, 0x1ffff800, 0x0800); target_add_ram(t, 0x20000000, 0x1800); - kl_gen_add_flash(t, 0x00000000, 0x8000, 0x400, KL_WRITE_LEN); + kinetis_add_flash(t, 0x00000000, 0x8000, 0x400, KL_WRITE_LEN); break; case 5: t->driver = "KL27x64"; target_add_ram(t, 0x1ffff000, 0x1000); target_add_ram(t, 0x20000000, 0x3000); - kl_gen_add_flash(t, 0x00000000, 0x10000, 0x400, KL_WRITE_LEN); + kinetis_add_flash(t, 0x00000000, 0x10000, 0x400, KL_WRITE_LEN); break; default: return false; @@ -227,19 +248,19 @@ bool kinetis_probe(target *const t) t->driver = "KL02x32"; target_add_ram(t, 0x1FFFFC00, 0x400); target_add_ram(t, 0x20000000, 0xc00); - kl_gen_add_flash(t, 0x00000000, 0x7FFF, 0x400, KL_WRITE_LEN); + kinetis_add_flash(t, 0x00000000, 0x7FFF, 0x400, KL_WRITE_LEN); break; case 2: t->driver = "KL02x16"; target_add_ram(t, 0x1FFFFE00, 0x200); target_add_ram(t, 0x20000000, 0x600); - kl_gen_add_flash(t, 0x00000000, 0x3FFF, 0x400, KL_WRITE_LEN); + kinetis_add_flash(t, 0x00000000, 0x3FFF, 0x400, KL_WRITE_LEN); break; case 1: t->driver = "KL02x8"; target_add_ram(t, 0x1FFFFF00, 0x100); target_add_ram(t, 0x20000000, 0x300); - kl_gen_add_flash(t, 0x00000000, 0x1FFF, 0x400, KL_WRITE_LEN); + kinetis_add_flash(t, 0x00000000, 0x1FFF, 0x400, KL_WRITE_LEN); break; default: return false; @@ -249,14 +270,14 @@ bool kinetis_probe(target *const t) t->driver = "KL03"; target_add_ram(t, 0x1ffffe00, 0x200); target_add_ram(t, 0x20000000, 0x600); - kl_gen_add_flash(t, 0, 0x8000, 0x400, KL_WRITE_LEN); + kinetis_add_flash(t, 0, 0x8000, 0x400, KL_WRITE_LEN); break; case 0x220: /* K22F family */ t->driver = "K22F"; target_add_ram(t, 0x1c000000, 0x4000000); target_add_ram(t, 0x20000000, 0x100000); - kl_gen_add_flash(t, 0, 0x40000, 0x800, KL_WRITE_LEN); - kl_gen_add_flash(t, 0x40000, 0x40000, 0x800, KL_WRITE_LEN); + kinetis_add_flash(t, 0, 0x40000, 0x800, KL_WRITE_LEN); + kinetis_add_flash(t, 0x40000, 0x40000, 0x800, KL_WRITE_LEN); break; case 0x620: /* K64F family. */ /* This should be 0x640, but according to the errata sheet @@ -266,8 +287,8 @@ bool kinetis_probe(target *const t) t->driver = "K64"; target_add_ram(t, 0x1FFF0000, 0x10000); target_add_ram(t, 0x20000000, 0x30000); - kl_gen_add_flash(t, 0, 0x80000, 0x1000, K64_WRITE_LEN); - kl_gen_add_flash(t, 0x80000, 0x80000, 0x1000, K64_WRITE_LEN); + kinetis_add_flash(t, 0, 0x80000, 0x1000, K64_WRITE_LEN); + kinetis_add_flash(t, 0x80000, 0x80000, 0x1000, K64_WRITE_LEN); break; case 0x000: /* Older K-series */ switch (sdid & 0xff0) { @@ -282,24 +303,24 @@ bool kinetis_probe(target *const t) /* K12 Sub-Family Reference Manual, K12P80M50SF4RM, Rev. 4, February 2013 */ case 0x7: t->driver = "MK12DX128Vxx5"; - target_add_ram(t, 0x1fffc000, 0x00004000); /* SRAM_L, 16 KB */ - target_add_ram(t, 0x20000000, 0x00004000); /* SRAM_H, 16 KB */ - kl_gen_add_flash(t, 0x00000000, 0x00020000, 0x800, KL_WRITE_LEN); /* P-Flash, 128 KB, 2 KB Sectors */ - kl_gen_add_flash(t, 0x10000000, 0x00010000, 0x800, KL_WRITE_LEN); /* FlexNVM, 64 KB, 2 KB Sectors */ + target_add_ram(t, 0x1fffc000, 0x00004000); /* SRAM_L, 16 KB */ + target_add_ram(t, 0x20000000, 0x00004000); /* SRAM_H, 16 KB */ + kinetis_add_flash(t, 0x00000000, 0x00020000, 0x800, KL_WRITE_LEN); /* P-Flash, 128 KB, 2 KB Sectors */ + kinetis_add_flash(t, 0x10000000, 0x00010000, 0x800, KL_WRITE_LEN); /* FlexNVM, 64 KB, 2 KB Sectors */ break; case 0x9: t->driver = "MK12DX256Vxx5"; - target_add_ram(t, 0x1fffc000, 0x00004000); /* SRAM_L, 16 KB */ - target_add_ram(t, 0x20000000, 0x00004000); /* SRAM_H, 16 KB */ - kl_gen_add_flash(t, 0x00000000, 0x00040000, 0x800, KL_WRITE_LEN); /* P-Flash, 256 KB, 2 KB Sectors */ - kl_gen_add_flash(t, 0x10000000, 0x00010000, 0x800, KL_WRITE_LEN); /* FlexNVM, 64 KB, 2 KB Sectors */ + target_add_ram(t, 0x1fffc000, 0x00004000); /* SRAM_L, 16 KB */ + target_add_ram(t, 0x20000000, 0x00004000); /* SRAM_H, 16 KB */ + kinetis_add_flash(t, 0x00000000, 0x00040000, 0x800, KL_WRITE_LEN); /* P-Flash, 256 KB, 2 KB Sectors */ + kinetis_add_flash(t, 0x10000000, 0x00010000, 0x800, KL_WRITE_LEN); /* FlexNVM, 64 KB, 2 KB Sectors */ break; case 0xb: t->driver = "MK12DN512Vxx5"; - target_add_ram(t, 0x1fff8000, 0x00008000); /* SRAM_L, 32 KB */ - target_add_ram(t, 0x20000000, 0x00008000); /* SRAM_H, 32 KB */ - kl_gen_add_flash(t, 0x00000000, 0x00040000, 0x800, KL_WRITE_LEN); /* P-Flash, 256 KB, 2 KB Sectors */ - kl_gen_add_flash(t, 0x00040000, 0x00040000, 0x800, KL_WRITE_LEN); /* FlexNVM, 256 KB, 2 KB Sectors */ + target_add_ram(t, 0x1fff8000, 0x00008000); /* SRAM_L, 32 KB */ + target_add_ram(t, 0x20000000, 0x00008000); /* SRAM_H, 32 KB */ + kinetis_add_flash(t, 0x00000000, 0x00040000, 0x800, KL_WRITE_LEN); /* P-Flash, 256 KB, 2 KB Sectors */ + kinetis_add_flash(t, 0x00040000, 0x00040000, 0x800, KL_WRITE_LEN); /* FlexNVM, 256 KB, 2 KB Sectors */ break; default: return false; @@ -329,10 +350,10 @@ bool kinetis_probe(target *const t) break; case 0x118: /* S32K118 */ t->driver = "S32K118"; - target_add_ram(t, 0x1ffffc00, 0x00000400); /* SRAM_L, 1 KB */ - target_add_ram(t, 0x20000000, 0x00005800); /* SRAM_H, 22 KB */ - kl_gen_add_flash(t, 0x00000000, 0x00040000, 0x800, K64_WRITE_LEN); /* P-Flash, 256 KB, 2 KB Sectors */ - kl_gen_add_flash(t, 0x10000000, 0x00008000, 0x800, K64_WRITE_LEN); /* FlexNVM, 32 KB, 2 KB Sectors */ + target_add_ram(t, 0x1ffffc00, 0x00000400); /* SRAM_L, 1 KB */ + target_add_ram(t, 0x20000000, 0x00005800); /* SRAM_H, 22 KB */ + kinetis_add_flash(t, 0x00000000, 0x00040000, 0x800, K64_WRITE_LEN); /* P-Flash, 256 KB, 2 KB Sectors */ + kinetis_add_flash(t, 0x10000000, 0x00008000, 0x800, K64_WRITE_LEN); /* FlexNVM, 32 KB, 2 KB Sectors */ break; /* gen1 s32k14x */ case 0x142: /* S32K142 */ @@ -373,46 +394,46 @@ bool kinetis_probe(target *const t) return true; } -static bool kl_gen_command(target *t, uint8_t cmd, uint32_t addr, const uint32_t *data, int n_items) +static bool kinetis_fccob_cmd(target *t, uint8_t cmd, uint32_t addr, const uint32_t *data, int n_items) { uint8_t fstat; /* clear errors unconditionally, so we can start a new operation */ - target_mem_write8(t, FTFA_FSTAT, (FTFA_FSTAT_ACCERR | FTFA_FSTAT_FPVIOL)); + target_mem_write8(t, FTFx_FSTAT, (FTFx_FSTAT_ACCERR | FTFx_FSTAT_FPVIOL)); /* Wait for CCIF to be high */ do { - fstat = target_mem_read8(t, FTFA_FSTAT); - } while (!(fstat & FTFA_FSTAT_CCIF)); + fstat = target_mem_read8(t, FTFx_FSTAT); + } while (!(fstat & FTFx_FSTAT_CCIF)); /* Write command to FCCOB */ addr &= 0xffffff; addr |= (uint32_t)cmd << 24; - target_mem_write32(t, FTFA_FCCOB_0, addr); + target_mem_write32(t, FTFx_FCCOB0, addr); if (data) { - target_mem_write32(t, FTFA_FCCOB_1, data[0]); + target_mem_write32(t, FTFx_FCCOB4, data[0]); if (n_items > 1) - target_mem_write32(t, FTFA_FCCOB_2, data[1]); + target_mem_write32(t, FTFx_FCCOB8, data[1]); } /* Enable execution by clearing CCIF */ - target_mem_write8(t, FTFA_FSTAT, FTFA_FSTAT_CCIF); + target_mem_write8(t, FTFx_FSTAT, FTFx_FSTAT_CCIF); /* Wait for execution to complete */ do { - fstat = target_mem_read8(t, FTFA_FSTAT); + fstat = target_mem_read8(t, FTFx_FSTAT); /* Check ACCERR and FPVIOL are zero in FSTAT */ - if (fstat & (FTFA_FSTAT_ACCERR | FTFA_FSTAT_FPVIOL)) + if (fstat & (FTFx_FSTAT_ACCERR | FTFx_FSTAT_FPVIOL)) return false; - } while (!(fstat & FTFA_FSTAT_CCIF)); + } while (!(fstat & FTFx_FSTAT_CCIF)); return true; } -static int kl_gen_flash_erase(struct target_flash *const f, target_addr addr, size_t len) +static int kinetis_flash_cmd_erase(struct target_flash *const f, target_addr addr, size_t len) { while (len) { - if (kl_gen_command(f->t, FTFA_CMD_ERASE_SECTOR, addr, NULL, 0)) { + if (kinetis_fccob_cmd(f->t, FTFx_CMD_ERASE_SECTOR, addr, NULL, 0)) { /* Different targets have different flash erase sizes */ if (len > f->blocksize) len -= f->blocksize; @@ -426,10 +447,7 @@ static int kl_gen_flash_erase(struct target_flash *const f, target_addr addr, si return 0; } -#define FLASH_SECURITY_BYTE_ADDRESS 0x40C -#define FLASH_SECURITY_BYTE_UNSECURED 0xFE - -static int kl_gen_flash_write(struct target_flash *f, target_addr dest, const void *src, size_t len) +static int kinetis_flash_cmd_write(struct target_flash *f, target_addr dest, const void *src, size_t len) { struct kinetis_flash *const kf = (struct kinetis_flash *)f; @@ -441,12 +459,12 @@ static int kl_gen_flash_write(struct target_flash *f, target_addr dest, const vo /* Determine write command based on the alignment. */ uint8_t write_cmd; if (kf->write_len == K64_WRITE_LEN) - write_cmd = FTFE_CMD_PROGRAM_PHRASE; + write_cmd = FTFx_CMD_PROGRAM_PHRASE; else - write_cmd = FTFA_CMD_PROGRAM_LONGWORD; + write_cmd = FTFx_CMD_PROGRAM_LONGWORD; while (len) { - if (kl_gen_command(f->t, write_cmd, dest, src, 1)) { + if (kinetis_fccob_cmd(f->t, write_cmd, dest, src, 1)) { if (len > kf->write_len) len -= kf->write_len; else @@ -459,7 +477,7 @@ static int kl_gen_flash_write(struct target_flash *f, target_addr dest, const vo return 0; } -static int kl_gen_flash_done(struct target_flash *const f) +static int kinetis_flash_done(struct target_flash *const f) { struct kinetis_flash *const kf = (struct kinetis_flash *)f; @@ -477,12 +495,12 @@ static int kl_gen_flash_done(struct target_flash *const f) vals[0] = target_mem_read32(f->t, FLASH_SECURITY_BYTE_ADDRESS - 4); vals[1] = target_mem_read32(f->t, FLASH_SECURITY_BYTE_ADDRESS); vals[1] = (vals[1] & 0xffffff00) | FLASH_SECURITY_BYTE_UNSECURED; - kl_gen_command(f->t, FTFE_CMD_PROGRAM_PHRASE, FLASH_SECURITY_BYTE_ADDRESS - 4, vals, 2); + kinetis_fccob_cmd(f->t, FTFx_CMD_PROGRAM_PHRASE, FLASH_SECURITY_BYTE_ADDRESS - 4, vals, 2); } else { uint32_t vals[1]; vals[0] = target_mem_read32(f->t, FLASH_SECURITY_BYTE_ADDRESS); vals[0] = (vals[0] & 0xffffff00) | FLASH_SECURITY_BYTE_UNSECURED; - kl_gen_command(f->t, FTFA_CMD_PROGRAM_LONGWORD, FLASH_SECURITY_BYTE_ADDRESS, vals, 1); + kinetis_fccob_cmd(f->t, FTFx_CMD_PROGRAM_LONGWORD, FLASH_SECURITY_BYTE_ADDRESS, vals, 1); } return 0; @@ -496,15 +514,14 @@ static int kl_gen_flash_done(struct target_flash *const f) * device. This provides a fake target to allow a monitor command interface */ -#define KINETIS_MDM_IDR_K22F 0x1c0000 -#define KINETIS_MDM_IDR_KZ03 0x1c0020 - static bool kinetis_mdm_cmd_erase_mass(target *t, int argc, const char **argv); static bool kinetis_mdm_cmd_ke04_mode(target *t, int argc, const char **argv); const struct command_s kinetis_mdm_cmd_list[] = { {"erase_mass", (cmd_handler)kinetis_mdm_cmd_erase_mass, "Erase entire flash memory"}, - {"ke04_mode", (cmd_handler)kinetis_mdm_cmd_ke04_mode, "Allow erase for KE04"}, {NULL, NULL, NULL}}; + {"ke04_mode", (cmd_handler)kinetis_mdm_cmd_ke04_mode, "Allow erase for KE04"}, + {NULL, NULL, NULL}, +}; enum target_halt_reason mdm_halt_poll(target *t, const target_addr *const watch) { @@ -537,16 +554,6 @@ void kinetis_mdm_probe(ADIv5_AP_t *ap) target_add_commands(t, kinetis_mdm_cmd_list, t->driver); } -#define MDM_STATUS ADIV5_AP_REG(0x00) -#define MDM_CONTROL ADIV5_AP_REG(0x04) - -#define MDM_STATUS_MASS_ERASE_ACK (1 << 0) -#define MDM_STATUS_FLASH_READY (1 << 1) -#define MDM_STATUS_MASS_ERASE_ENABLED (1 << 5) - -#define MDM_CONTROL_MASS_ERASE (1 << 0) -#define MDM_CONTROL_SYS_RESET (1 << 3) - /* This is needed as a separate command, as there's no way to * * tell a KE04 from other kinetis in kinetis_mdm_probe() */ static bool kinetis_mdm_cmd_ke04_mode(target *t, int argc, const char **argv)