1 /***************************************************************************
2 * Copyright (C) 2011 by Mathias Kuester *
5 * Copyright (C) 2011 sleep(5) ltd *
6 * tomas@sleepfive.com *
8 * Copyright (C) 2012 by Christopher D. Kilgour *
9 * techie at whiterocker.com *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
25 ***************************************************************************/
32 #include "helper/binarybuffer.h"
35 * Implementation Notes
37 * The persistent memories in the Kinetis chip families K10 through
38 * K70 are all manipulated with the Flash Memory Module. Some
39 * variants call this module the FTFE, others call it the FTFL. To
40 * indicate that both are considered here, we use FTFX.
42 * Within the module, according to the chip variant, the persistent
43 * memory is divided into what Freescale terms Program Flash, FlexNVM,
44 * and FlexRAM. All chip variants have Program Flash. Some chip
45 * variants also have FlexNVM and FlexRAM, which always appear
48 * A given Kinetis chip may have 2 or 4 blocks of flash. Here we map
49 * each block to a separate bank. Each block size varies by chip and
50 * may be determined by the read-only SIM_FCFG1 register. The sector
51 * size within each bank/block varies by the chip granularity as
54 * Kinetis offers four different of flash granularities applicable
55 * across the chip families. The granularity is apparently reflected
56 * by at least the reference manual suffix. For example, for chip
57 * MK60FN1M0VLQ12, reference manual K60P144M150SF3RM ends in "SF3RM",
58 * where the "3" indicates there are four flash blocks with 4kiB
59 * sectors. All possible granularities are indicated below.
61 * The first half of the flash (1 or 2 blocks, depending on the
62 * granularity) is always Program Flash and always starts at address
63 * 0x00000000. The "PFLSH" flag, bit 23 of the read-only SIM_FCFG2
64 * register, determines whether the second half of the flash is also
65 * Program Flash or FlexNVM+FlexRAM. When PFLSH is set, the second
66 * half of flash is Program Flash and is contiguous in the memory map
67 * from the first half. When PFLSH is clear, the second half of flash
68 * is FlexNVM and always starts at address 0x10000000. FlexRAM, which
69 * is also present when PFLSH is clear, always starts at address
72 * The Flash Memory Module provides a register set where flash
73 * commands are loaded to perform flash operations like erase and
74 * program. Different commands are available depending on whether
75 * Program Flash or FlexNVM/FlexRAM is being manipulated. Although
76 * the commands used are quite consistent between flash blocks, the
77 * parameters they accept differ according to the flash granularity.
78 * Some Kinetis chips have different granularity between Program Flash
79 * and FlexNVM/FlexRAM, so flash command arguments may differ between
80 * blocks in the same chip.
82 * Although not documented as such by Freescale, it appears that bits
83 * 8:7 of the read-only SIM_SDID register reflect the granularity
84 * settings 0..3, so sector sizes and block counts are applicable
85 * according to the following table.
88 unsigned pflash_sector_size_bytes
;
89 unsigned nvm_sector_size_bytes
;
91 } kinetis_flash_params
[4] = {
99 #define FLEXRAM 0x14000000
100 #define FTFx_FSTAT 0x40020000
101 #define FTFx_FCNFG 0x40020001
102 #define FTFx_FCCOB3 0x40020004
103 #define FTFx_FPROT3 0x40020010
104 #define SIM_SDID 0x40048024
105 #define SIM_FCFG1 0x4004804c
106 #define SIM_FCFG2 0x40048050
109 #define FTFx_CMD_BLOCKSTAT 0x00
110 #define FTFx_CMD_SECTSTAT 0x01
111 #define FTFx_CMD_LWORDPROG 0x06
112 #define FTFx_CMD_SECTERASE 0x09
113 #define FTFx_CMD_SECTWRITE 0x0b
114 #define FTFx_CMD_SETFLEXRAM 0x81
116 struct kinetis_flash_bank
{
117 unsigned granularity
;
118 unsigned bank_ordinal
;
119 uint32_t sector_size
;
120 uint32_t protection_size
;
134 FLASH_BANK_COMMAND_HANDLER(kinetis_flash_bank_command
)
136 struct kinetis_flash_bank
*bank_info
;
139 return ERROR_COMMAND_SYNTAX_ERROR
;
141 LOG_INFO("add flash_bank kinetis %s", bank
->name
);
143 bank_info
= malloc(sizeof(struct kinetis_flash_bank
));
145 memset(bank_info
, 0, sizeof(struct kinetis_flash_bank
));
147 bank
->driver_priv
= bank_info
;
152 static int kinetis_protect(struct flash_bank
*bank
, int set
, int first
,
155 LOG_WARNING("kinetis_protect not supported yet");
158 if (bank
->target
->state
!= TARGET_HALTED
) {
159 LOG_ERROR("Target not halted");
160 return ERROR_TARGET_NOT_HALTED
;
163 return ERROR_FLASH_BANK_INVALID
;
166 static int kinetis_protect_check(struct flash_bank
*bank
)
168 struct kinetis_flash_bank
*kinfo
= bank
->driver_priv
;
170 if (bank
->target
->state
!= TARGET_HALTED
) {
171 LOG_ERROR("Target not halted");
172 return ERROR_TARGET_NOT_HALTED
;
175 if (kinfo
->flash_class
== FC_PFLASH
) {
178 uint32_t fprot
, psec
;
181 /* read protection register */
182 result
= target_read_memory(bank
->target
, FTFx_FPROT3
, 1, 4, buffer
);
184 if (result
!= ERROR_OK
)
187 fprot
= target_buffer_get_u32(bank
->target
, buffer
);
190 * Every bit protects 1/32 of the full flash (not necessarily
191 * just this bank), but we enforce the bank ordinals for
192 * PFlash to start at zero.
194 b
= kinfo
->bank_ordinal
* (bank
->size
/ kinfo
->protection_size
);
195 for (psec
= 0, i
= 0; i
< bank
->num_sectors
; i
++) {
196 if ((fprot
>> b
) & 1)
197 bank
->sectors
[i
].is_protected
= 0;
199 bank
->sectors
[i
].is_protected
= 1;
201 psec
+= bank
->sectors
[i
].size
;
203 if (psec
>= kinfo
->protection_size
) {
209 LOG_ERROR("Protection checks for FlexNVM not yet supported");
210 return ERROR_FLASH_BANK_INVALID
;
216 static int kinetis_ftfx_command(struct flash_bank
*bank
, uint8_t fcmd
, uint32_t faddr
,
217 uint8_t fccob4
, uint8_t fccob5
, uint8_t fccob6
, uint8_t fccob7
,
218 uint8_t fccob8
, uint8_t fccob9
, uint8_t fccoba
, uint8_t fccobb
,
221 uint8_t command
[12] = {faddr
& 0xff, (faddr
>> 8) & 0xff, (faddr
>> 16) & 0xff, fcmd
,
222 fccob7
, fccob6
, fccob5
, fccob4
,
223 fccobb
, fccoba
, fccob9
, fccob8
};
228 for (i
= 0; i
< 50; i
++) {
230 target_read_memory(bank
->target
, FTFx_FSTAT
, 1, 1, &buffer
);
232 if (result
!= ERROR_OK
)
241 if (buffer
!= 0x80) {
242 /* reset error flags */
245 target_write_memory(bank
->target
, FTFx_FSTAT
, 1, 1, &buffer
);
246 if (result
!= ERROR_OK
)
250 result
= target_write_memory(bank
->target
, FTFx_FCCOB3
, 4, 3, command
);
252 if (result
!= ERROR_OK
)
257 result
= target_write_memory(bank
->target
, FTFx_FSTAT
, 1, 1, &buffer
);
258 if (result
!= ERROR_OK
)
262 for (i
= 0; i
< 50; i
++) {
264 target_read_memory(bank
->target
, FTFx_FSTAT
, 1, 1, ftfx_fstat
);
266 if (result
!= ERROR_OK
)
269 if (*ftfx_fstat
& 0x80)
273 if ((*ftfx_fstat
& 0xf0) != 0x80) {
275 ("ftfx command failed FSTAT: %02X FCCOB: %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X",
276 *ftfx_fstat
, command
[3], command
[2], command
[1], command
[0],
277 command
[7], command
[6], command
[5], command
[4],
278 command
[11], command
[10], command
[9], command
[8]);
279 return ERROR_FLASH_OPERATION_FAILED
;
285 static int kinetis_erase(struct flash_bank
*bank
, int first
, int last
)
289 if (bank
->target
->state
!= TARGET_HALTED
) {
290 LOG_ERROR("Target not halted");
291 return ERROR_TARGET_NOT_HALTED
;
294 if ((first
> bank
->num_sectors
) || (last
> bank
->num_sectors
))
295 return ERROR_FLASH_OPERATION_FAILED
;
298 * FIXME: TODO: use the 'Erase Flash Block' command if the
299 * requested erase is PFlash or NVM and encompasses the entire
300 * block. Should be quicker.
302 for (i
= first
; i
<= last
; i
++) {
304 /* set command and sector address */
305 result
= kinetis_ftfx_command(bank
, FTFx_CMD_SECTERASE
, bank
->base
+ bank
->sectors
[i
].offset
,
306 0, 0, 0, 0, 0, 0, 0, 0, &ftfx_fstat
);
308 if (result
!= ERROR_OK
) {
309 LOG_WARNING("erase sector %d failed", i
);
310 return ERROR_FLASH_OPERATION_FAILED
;
313 bank
->sectors
[i
].is_erased
= 1;
318 ("flash configuration field erased, please reset the device");
324 static int kinetis_write(struct flash_bank
*bank
, uint8_t *buffer
,
325 uint32_t offset
, uint32_t count
)
327 unsigned int i
, result
, fallback
= 0;
330 struct kinetis_flash_bank
*kinfo
= bank
->driver_priv
;
332 if (bank
->target
->state
!= TARGET_HALTED
) {
333 LOG_ERROR("Target not halted");
334 return ERROR_TARGET_NOT_HALTED
;
337 if (kinfo
->flash_class
== FC_FLEX_NVM
) {
340 LOG_DEBUG("flash write into FlexNVM @%08X", offset
);
342 /* make flex ram available */
343 result
= kinetis_ftfx_command(bank
, FTFx_CMD_SETFLEXRAM
, 0x00ff0000, 0, 0, 0, 0, 0, 0, 0, 0, &ftfx_fstat
);
345 if (result
!= ERROR_OK
)
346 return ERROR_FLASH_OPERATION_FAILED
;
348 /* check if ram ready */
349 result
= target_read_memory(bank
->target
, FTFx_FCNFG
, 1, 1, buf
);
351 if (result
!= ERROR_OK
)
354 if (!(buf
[0] & (1 << 1))) {
355 /* fallback to longword write */
358 LOG_WARNING("ram not ready, fallback to slow longword write (FCNFG: %02X)",
362 LOG_DEBUG("flash write into PFLASH @08%X", offset
);
366 /* program section command */
369 * Kinetis uses different terms for the granularity of
370 * sector writes, e.g. "phrase" or "128 bits". We use
371 * the generic term "chunk". The largest possible
372 * Kinetis "chunk" is 16 bytes (128 bits).
374 unsigned prog_section_chunk_bytes
= kinfo
->sector_size
>> 8;
375 /* assume the NVM sector size is half the FlexRAM size */
376 unsigned prog_size_bytes
= MIN(kinfo
->sector_size
,
377 kinetis_flash_params
[kinfo
->granularity
].nvm_sector_size_bytes
);
378 for (i
= 0; i
< count
; i
+= prog_size_bytes
) {
379 uint8_t residual_buffer
[16];
381 uint32_t section_count
= prog_size_bytes
/ prog_section_chunk_bytes
;
382 uint32_t residual_wc
= 0;
385 * Assume the word count covers an entire
388 wc
= prog_size_bytes
/ 4;
391 * If bytes to be programmed are less than the
392 * full sector, then determine the number of
393 * full-words to program, and put together the
394 * residual buffer so that a full "section"
395 * may always be programmed.
397 if ((count
- i
) < prog_size_bytes
) {
398 /* number of bytes to program beyond full section */
399 unsigned residual_bc
= (count
-i
) % prog_section_chunk_bytes
;
401 /* number of complete words to copy directly from buffer */
402 wc
= (count
- i
) / 4;
404 /* number of total sections to write, including residual */
405 section_count
= DIV_ROUND_UP((count
-i
), prog_section_chunk_bytes
);
407 /* any residual bytes delivers a whole residual section */
408 residual_wc
= (residual_bc
? prog_section_chunk_bytes
: 0)/4;
410 /* clear residual buffer then populate residual bytes */
411 (void) memset(residual_buffer
, 0xff, prog_section_chunk_bytes
);
412 (void) memcpy(residual_buffer
, &buffer
[i
+4*wc
], residual_bc
);
415 LOG_DEBUG("write section @ %08X with length %d bytes",
418 /* write data to flexram as whole-words */
419 result
= target_write_memory(bank
->target
, FLEXRAM
, 4, wc
,
422 if (result
!= ERROR_OK
) {
423 LOG_ERROR("target_write_memory failed");
427 /* write the residual words to the flexram */
429 result
= target_write_memory(bank
->target
,
434 if (result
!= ERROR_OK
) {
435 LOG_ERROR("target_write_memory failed");
440 /* execute section-write command */
441 result
= kinetis_ftfx_command(bank
, FTFx_CMD_SECTWRITE
, bank
->base
+ offset
+ i
,
442 section_count
>>8, section_count
, 0, 0,
443 0, 0, 0, 0, &ftfx_fstat
);
445 if (result
!= ERROR_OK
)
446 return ERROR_FLASH_OPERATION_FAILED
;
449 /* program longword command, not supported in "SF3" devices */
450 else if (kinfo
->granularity
!= 3) {
451 for (i
= 0; i
< count
; i
+= 4) {
454 LOG_DEBUG("write longword @ %08X", offset
+ i
);
456 uint8_t padding
[4] = {0xff, 0xff, 0xff, 0xff};
457 memcpy(padding
, buffer
+ i
, MIN(4, count
-i
));
458 result
= kinetis_ftfx_command(bank
, FTFx_CMD_LWORDPROG
, bank
->base
+ offset
+ i
,
459 padding
[3], padding
[2], padding
[1], padding
[0],
460 0, 0, 0, 0, &ftfx_fstat
);
462 if (result
!= ERROR_OK
)
463 return ERROR_FLASH_OPERATION_FAILED
;
466 LOG_ERROR("Flash write strategy not implemented");
467 return ERROR_FLASH_OPERATION_FAILED
;
473 static int kinetis_read_part_info(struct flash_bank
*bank
)
478 uint8_t fcfg1_nvmsize
, fcfg1_pfsize
, fcfg1_eesize
, fcfg2_pflsh
;
479 uint32_t nvm_size
= 0, pf_size
= 0, ee_size
= 0;
480 unsigned granularity
, num_blocks
= 0, num_pflash_blocks
= 0, num_nvm_blocks
= 0,
481 first_nvm_bank
= 0, reassign
= 0;
482 struct kinetis_flash_bank
*kinfo
= bank
->driver_priv
;
484 result
= target_read_memory(bank
->target
, SIM_SDID
, 1, 4, buf
);
485 if (result
!= ERROR_OK
)
487 kinfo
->sim_sdid
= target_buffer_get_u32(bank
->target
, buf
);
488 granularity
= (kinfo
->sim_sdid
>> 7) & 0x03;
490 result
= target_read_memory(bank
->target
, SIM_FCFG1
, 1, 4, buf
);
491 if (result
!= ERROR_OK
)
493 kinfo
->sim_fcfg1
= target_buffer_get_u32(bank
->target
, buf
);
495 result
= target_read_memory(bank
->target
, SIM_FCFG2
, 1, 4, buf
);
496 if (result
!= ERROR_OK
)
498 kinfo
->sim_fcfg2
= target_buffer_get_u32(bank
->target
, buf
);
499 fcfg2_pflsh
= (kinfo
->sim_fcfg2
>> 23) & 0x01;
501 LOG_DEBUG("SDID: %08X FCFG1: %08X FCFG2: %08X", kinfo
->sim_sdid
,
502 kinfo
->sim_fcfg1
, kinfo
->sim_fcfg2
);
504 fcfg1_nvmsize
= (uint8_t)((kinfo
->sim_fcfg1
>> 28) & 0x0f);
505 fcfg1_pfsize
= (uint8_t)((kinfo
->sim_fcfg1
>> 24) & 0x0f);
506 fcfg1_eesize
= (uint8_t)((kinfo
->sim_fcfg1
>> 16) & 0x0f);
508 /* when the PFLSH bit is set, there is no FlexNVM/FlexRAM */
510 switch (fcfg1_nvmsize
) {
515 nvm_size
= 1 << (14 + (fcfg1_nvmsize
>> 1));
518 if (granularity
== 3)
528 switch (fcfg1_eesize
) {
539 ee_size
= (16 << (10 - fcfg1_eesize
));
547 switch (fcfg1_pfsize
) {
554 pf_size
= 1 << (14 + (fcfg1_pfsize
>> 1));
557 if (granularity
== 3)
559 else if (fcfg2_pflsh
)
569 LOG_DEBUG("FlexNVM: %d PFlash: %d FlexRAM: %d PFLSH: %d",
570 nvm_size
, pf_size
, ee_size
, fcfg2_pflsh
);
572 num_blocks
= kinetis_flash_params
[granularity
].num_blocks
;
573 num_pflash_blocks
= num_blocks
/ (2 - fcfg2_pflsh
);
574 first_nvm_bank
= num_pflash_blocks
;
575 num_nvm_blocks
= num_blocks
- num_pflash_blocks
;
577 LOG_DEBUG("%d blocks total: %d PFlash, %d FlexNVM",
578 num_blocks
, num_pflash_blocks
, num_nvm_blocks
);
581 * If the flash class is already assigned, verify the
584 if (kinfo
->flash_class
!= FC_AUTO
) {
585 if (kinfo
->bank_ordinal
!= (unsigned) bank
->bank_number
) {
586 LOG_WARNING("Flash ordinal/bank number mismatch");
588 } else if (kinfo
->granularity
!= granularity
) {
589 LOG_WARNING("Flash granularity mismatch");
592 switch (kinfo
->flash_class
) {
594 if (kinfo
->bank_ordinal
>= first_nvm_bank
) {
595 LOG_WARNING("Class mismatch, bank %d is not PFlash",
598 } else if (bank
->size
!= (pf_size
/ num_pflash_blocks
)) {
599 LOG_WARNING("PFlash size mismatch");
601 } else if (bank
->base
!=
602 (0x00000000 + bank
->size
* kinfo
->bank_ordinal
)) {
603 LOG_WARNING("PFlash address range mismatch");
605 } else if (kinfo
->sector_size
!=
606 kinetis_flash_params
[granularity
].pflash_sector_size_bytes
) {
607 LOG_WARNING("PFlash sector size mismatch");
610 LOG_DEBUG("PFlash bank %d already configured okay",
611 kinfo
->bank_ordinal
);
615 if ((kinfo
->bank_ordinal
>= num_blocks
) ||
616 (kinfo
->bank_ordinal
< first_nvm_bank
)) {
617 LOG_WARNING("Class mismatch, bank %d is not FlexNVM",
620 } else if (bank
->size
!= (nvm_size
/ num_nvm_blocks
)) {
621 LOG_WARNING("FlexNVM size mismatch");
623 } else if (bank
->base
!=
624 (0x10000000 + bank
->size
* kinfo
->bank_ordinal
)) {
625 LOG_WARNING("FlexNVM address range mismatch");
627 } else if (kinfo
->sector_size
!=
628 kinetis_flash_params
[granularity
].nvm_sector_size_bytes
) {
629 LOG_WARNING("FlexNVM sector size mismatch");
632 LOG_DEBUG("FlexNVM bank %d already configured okay",
633 kinfo
->bank_ordinal
);
637 if (kinfo
->bank_ordinal
!= num_blocks
) {
638 LOG_WARNING("Class mismatch, bank %d is not FlexRAM",
641 } else if (bank
->size
!= ee_size
) {
642 LOG_WARNING("FlexRAM size mismatch");
644 } else if (bank
->base
!= FLEXRAM
) {
645 LOG_WARNING("FlexRAM address mismatch");
647 } else if (kinfo
->sector_size
!=
648 kinetis_flash_params
[granularity
].nvm_sector_size_bytes
) {
649 LOG_WARNING("FlexRAM sector size mismatch");
652 LOG_DEBUG("FlexRAM bank %d already configured okay",
653 kinfo
->bank_ordinal
);
658 LOG_WARNING("Unknown or inconsistent flash class");
664 LOG_INFO("Probing flash info for bank %d", bank
->bank_number
);
671 kinfo
->granularity
= granularity
;
673 if ((unsigned)bank
->bank_number
< num_pflash_blocks
) {
674 /* pflash, banks start at address zero */
675 kinfo
->flash_class
= FC_PFLASH
;
676 bank
->size
= (pf_size
/ num_pflash_blocks
);
677 bank
->base
= 0x00000000 + bank
->size
* bank
->bank_number
;
678 kinfo
->sector_size
= kinetis_flash_params
[granularity
].pflash_sector_size_bytes
;
679 kinfo
->protection_size
= pf_size
/ 32;
680 } else if ((unsigned)bank
->bank_number
< num_blocks
) {
681 /* nvm, banks start at address 0x10000000 */
682 kinfo
->flash_class
= FC_FLEX_NVM
;
683 bank
->size
= (nvm_size
/ num_nvm_blocks
);
684 bank
->base
= 0x10000000 + bank
->size
* (bank
->bank_number
- first_nvm_bank
);
685 kinfo
->sector_size
= kinetis_flash_params
[granularity
].nvm_sector_size_bytes
;
686 kinfo
->protection_size
= 0; /* FIXME: TODO: depends on DEPART bits, chip */
687 } else if ((unsigned)bank
->bank_number
== num_blocks
) {
688 LOG_ERROR("FlexRAM support not yet implemented");
689 return ERROR_FLASH_OPER_UNSUPPORTED
;
691 LOG_ERROR("Cannot determine parameters for bank %d, only %d banks on device",
692 bank
->bank_number
, num_blocks
);
693 return ERROR_FLASH_BANK_INVALID
;
698 bank
->sectors
= NULL
;
701 bank
->num_sectors
= bank
->size
/ kinfo
->sector_size
;
702 assert(bank
->num_sectors
> 0);
703 bank
->sectors
= malloc(sizeof(struct flash_sector
) * bank
->num_sectors
);
705 for (i
= 0; i
< bank
->num_sectors
; i
++) {
706 bank
->sectors
[i
].offset
= offset
;
707 bank
->sectors
[i
].size
= kinfo
->sector_size
;
708 offset
+= kinfo
->sector_size
;
709 bank
->sectors
[i
].is_erased
= -1;
710 bank
->sectors
[i
].is_protected
= 1;
716 static int kinetis_probe(struct flash_bank
*bank
)
718 if (bank
->target
->state
!= TARGET_HALTED
) {
719 LOG_WARNING("Cannot communicate... target not halted.");
720 return ERROR_TARGET_NOT_HALTED
;
723 return kinetis_read_part_info(bank
);
726 static int kinetis_auto_probe(struct flash_bank
*bank
)
728 struct kinetis_flash_bank
*kinfo
= bank
->driver_priv
;
733 return kinetis_probe(bank
);
736 static int kinetis_info(struct flash_bank
*bank
, char *buf
, int buf_size
)
738 const char *bank_class_names
[] = {
739 "(ANY)", "PFlash", "FlexNVM", "FlexRAM"
742 struct kinetis_flash_bank
*kinfo
= bank
->driver_priv
;
744 (void) snprintf(buf
, buf_size
,
745 "%s driver for %s flash bank %s at 0x%8.8" PRIx32
"",
746 bank
->driver
->name
, bank_class_names
[kinfo
->flash_class
],
747 bank
->name
, bank
->base
);
752 static int kinetis_blank_check(struct flash_bank
*bank
)
754 struct kinetis_flash_bank
*kinfo
= bank
->driver_priv
;
756 if (bank
->target
->state
!= TARGET_HALTED
) {
757 LOG_ERROR("Target not halted");
758 return ERROR_TARGET_NOT_HALTED
;
761 if (kinfo
->flash_class
== FC_PFLASH
) {
765 /* check if whole bank is blank */
766 result
= kinetis_ftfx_command(bank
, FTFx_CMD_BLOCKSTAT
, bank
->base
, 0, 0, 0, 0, 0, 0, 0, 0, &ftfx_fstat
);
768 if (result
!= ERROR_OK
)
771 if (ftfx_fstat
& 0x01) {
772 /* the whole bank is not erased, check sector-by-sector */
774 for (i
= 0; i
< bank
->num_sectors
; i
++) {
776 result
= kinetis_ftfx_command(bank
, FTFx_CMD_SECTSTAT
, bank
->base
+ bank
->sectors
[i
].offset
,
777 1, 0, 0, 0, 0, 0, 0, 0, &ftfx_fstat
);
779 if (result
== ERROR_OK
) {
780 bank
->sectors
[i
].is_erased
= !(ftfx_fstat
& 0x01);
782 LOG_DEBUG("Ignoring errored PFlash sector blank-check");
783 bank
->sectors
[i
].is_erased
= -1;
787 /* the whole bank is erased, update all sectors */
789 for (i
= 0; i
< bank
->num_sectors
; i
++)
790 bank
->sectors
[i
].is_erased
= 1;
793 LOG_WARNING("kinetis_blank_check not supported yet for FlexNVM");
794 return ERROR_FLASH_OPERATION_FAILED
;
800 static int kinetis_flash_read(struct flash_bank
*bank
,
801 uint8_t *buffer
, uint32_t offset
, uint32_t count
)
803 LOG_WARNING("kinetis_flash_read not supported yet");
805 if (bank
->target
->state
!= TARGET_HALTED
) {
806 LOG_ERROR("Target not halted");
807 return ERROR_TARGET_NOT_HALTED
;
810 return ERROR_FLASH_OPERATION_FAILED
;
813 struct flash_driver kinetis_flash
= {
815 .flash_bank_command
= kinetis_flash_bank_command
,
816 .erase
= kinetis_erase
,
817 .protect
= kinetis_protect
,
818 .write
= kinetis_write
,
819 .read
= kinetis_flash_read
,
820 .probe
= kinetis_probe
,
821 .auto_probe
= kinetis_auto_probe
,
822 .erase_check
= kinetis_blank_check
,
823 .protect_check
= kinetis_protect_check
,
824 .info
= kinetis_info
,
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)