kinetis: add kl flash support

Not tested, adapted from http://tech.groups.yahoo.com/group/versaloon/message/391
depends on http://openocd.zylin.com/1602

Change-Id: Ib846be48500a28d515c6dbd3ca2a5c1719cd74d4
Signed-off-by: Spencer Oliver <spen@spen-soft.co.uk>
Reviewed-on: http://openocd.zylin.com/1508
Tested-by: jenkins
Reviewed-by: Chris Fryer <chrisf1874@gmail.com>
Reviewed-by: Nemui Trinomius <nemuisan_kawausogasuki@live.jp>

1 files changed, 315 insertions, 61 deletions

diff --git a/src/flash/nor/kinetis.c b/src/flash/nor/kinetis.c
index 31483cc..51e7676 100644
--- a/src/flash/nor/kinetis.c
+++ b/src/flash/nor/kinetis.c
@@ -8,6 +8,9 @@
  *   Copyright (C) 2012 by Christopher D. Kilgour                          *
  *   techie at whiterocker.com                                             *
  *                                                                         *
+ *   Copyright (C) 2013 Nemui Trinomius                                    *
+ *   nemuisan_kawausogasuki@live.jp                                        *
+ *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
@@ -29,7 +32,9 @@
 #endif
 
 #include "imp.h"
-#include "helper/binarybuffer.h"
+#include <helper/binarybuffer.h>
+#include <target/algorithm.h>
+#include <target/armv7m.h>
 
 /*
  * Implementation Notes
@@ -84,6 +89,7 @@
  * settings 0..3, so sector sizes and block counts are applicable
  * according to the following table.
  */
+
 const struct {
 	unsigned pflash_sector_size_bytes;
 	unsigned nvm_sector_size_bytes;
@@ -106,18 +112,20 @@ const struct {
 #define SIM_FCFG2	0x40048050
 
 /* Commands */
-#define FTFx_CMD_BLOCKSTAT 0x00
-#define FTFx_CMD_SECTSTAT 0x01
-#define FTFx_CMD_LWORDPROG 0x06
-#define FTFx_CMD_SECTERASE 0x09
-#define FTFx_CMD_SECTWRITE 0x0b
+#define FTFx_CMD_BLOCKSTAT  0x00
+#define FTFx_CMD_SECTSTAT   0x01
+#define FTFx_CMD_LWORDPROG  0x06
+#define FTFx_CMD_SECTERASE  0x09
+#define FTFx_CMD_SECTWRITE  0x0b
 #define FTFx_CMD_SETFLEXRAM 0x81
+#define FTFx_CMD_MASSERASE  0x44
 
 struct kinetis_flash_bank {
 	unsigned granularity;
 	unsigned bank_ordinal;
 	uint32_t sector_size;
 	uint32_t protection_size;
+	uint32_t klxx;
 
 	uint32_t sim_sdid;
 	uint32_t sim_fcfg1;
@@ -149,8 +157,178 @@ FLASH_BANK_COMMAND_HANDLER(kinetis_flash_bank_command)
 	return ERROR_OK;
 }
 
-static int kinetis_protect(struct flash_bank *bank, int set, int first,
-			   int last)
+/* Kinetis Program-LongWord Microcodes */
+static const uint8_t kinetis_flash_write_code[] = {
+	/* Params:
+	 * r0 - workarea buffer
+	* r1 - target address
+	* r2 - wordcount
+	* Clobbered:
+	* r4 - tmp
+	* r5 - tmp
+	* r6 - tmp
+	* r7 - tmp
+	*/
+
+							/* .L1: */
+						/* for(register uint32_t i=0;i<wcount;i++){ */
+	0x04, 0x1C,					/* mov    r4, r0          */
+	0x00, 0x23,					/* mov    r3, #0          */
+							/* .L2: */
+	0x0E, 0x1A,					/* sub    r6, r1, r0      */
+	0xA6, 0x19,					/* add    r6, r4, r6      */
+	0x93, 0x42,					/* cmp    r3, r2          */
+	0x16, 0xD0,					/* beq    .L9             */
+							/* .L5: */
+						/* while((FTFx_FSTAT&FTFA_FSTAT_CCIF_MASK) != FTFA_FSTAT_CCIF_MASK){}; */
+	0x0B, 0x4D,					/* ldr    r5, .L10        */
+	0x2F, 0x78,					/* ldrb   r7, [r5]        */
+	0x7F, 0xB2,					/* sxtb   r7, r7          */
+	0x00, 0x2F,					/* cmp    r7, #0          */
+	0xFA, 0xDA,					/* bge    .L5             */
+						/* FTFx_FSTAT = FTFA_FSTAT_ACCERR_MASK|FTFA_FSTAT_FPVIOL_MASK|FTFA_FSTAT_RDCO */
+	0x70, 0x27,					/* mov    r7, #112        */
+	0x2F, 0x70,					/* strb   r7, [r5]        */
+						/* FTFx_FCCOB3 = faddr; */
+	0x09, 0x4F,					/* ldr    r7, .L10+4      */
+	0x3E, 0x60,					/* str    r6, [r7]        */
+	0x06, 0x27,					/* mov    r7, #6          */
+						/* FTFx_FCCOB0 = 0x06;  */
+	0x08, 0x4E,					/* ldr    r6, .L10+8      */
+	0x37, 0x70,					/* strb   r7, [r6]        */
+						/* FTFx_FCCOB7 = *pLW;  */
+	0x80, 0xCC,					/* ldmia  r4!, {r7}       */
+	0x08, 0x4E,					/* ldr    r6, .L10+12     */
+	0x37, 0x60,					/* str    r7, [r6]        */
+						/* FTFx_FSTAT = FTFA_FSTAT_CCIF_MASK; */
+	0x80, 0x27,					/* mov    r7, #128        */
+	0x2F, 0x70,					/* strb   r7, [r5]        */
+							/* .L4: */
+						/* while((FTFx_FSTAT&FTFA_FSTAT_CCIF_MASK) != FTFA_FSTAT_CCIF_MASK){}; */
+	0x2E, 0x78,					/* ldrb    r6, [r5]       */
+	0x77, 0xB2,					/* sxtb    r7, r6         */
+	0x00, 0x2F,					/* cmp     r7, #0         */
+	0xFB, 0xDA,					/* bge     .L4            */
+	0x01, 0x33,					/* add     r3, r3, #1     */
+	0xE4, 0xE7,					/* b       .L2            */
+							/* .L9: */
+	0x00, 0xBE,					/* bkpt #0                */
+							/* .L10: */
+	0x00, 0x00, 0x02, 0x40,		/* .word    1073872896    */
+	0x04, 0x00, 0x02, 0x40,		/* .word    1073872900    */
+	0x07, 0x00, 0x02, 0x40,		/* .word    1073872903    */
+	0x08, 0x00, 0x02, 0x40,		/* .word    1073872904    */
+};
+
+/* Program LongWord Block Write */
+static int kinetis_write_block(struct flash_bank *bank, uint8_t *buffer,
+		uint32_t offset, uint32_t wcount)
+{
+	struct target *target = bank->target;
+	uint32_t buffer_size = 2048;		/* Default minimum value */
+	struct working_area *write_algorithm;
+	struct working_area *source;
+	uint32_t address = bank->base + offset;
+	struct reg_param reg_params[3];
+	struct armv7m_algorithm armv7m_info;
+	int retval = ERROR_OK;
+
+	/* Params:
+	 * r0 - workarea buffer
+	 * r1 - target address
+	 * r2 - wordcount
+	 * Clobbered:
+	 * r4 - tmp
+	 * r5 - tmp
+	 * r6 - tmp
+	 * r7 - tmp
+	 */
+
+	/* Increase buffer_size if needed */
+	if (buffer_size < (target->working_area_size/2))
+		buffer_size = (target->working_area_size/2);
+
+	LOG_INFO("Kinetis: FLASH Write ...");
+
+	/* check code alignment */
+	if (offset & 0x1) {
+		LOG_WARNING("offset 0x%" PRIx32 " breaks required 2-byte alignment", offset);
+		return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
+	}
+
+	/* allocate working area with flash programming code */
+	if (target_alloc_working_area(target, sizeof(kinetis_flash_write_code),
+			&write_algorithm) != ERROR_OK) {
+		LOG_WARNING("no working area available, can't do block memory writes");
+		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
+	}
+
+	retval = target_write_buffer(target, write_algorithm->address,
+		sizeof(kinetis_flash_write_code), kinetis_flash_write_code);
+	if (retval != ERROR_OK)
+		return retval;
+
+	/* memory buffer */
+	while (target_alloc_working_area(target, buffer_size, &source) != ERROR_OK) {
+		buffer_size /= 4;
+		if (buffer_size <= 256) {
+			/* free working area, write algorithm already allocated */
+			target_free_working_area(target, write_algorithm);
+
+			LOG_WARNING("No large enough working area available, can't do block memory writes");
+			return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
+		}
+	}
+
+	armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
+	armv7m_info.core_mode = ARM_MODE_THREAD;
+
+	init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT); /* *pLW (*buffer) */
+	init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT); /* faddr */
+	init_reg_param(&reg_params[2], "r2", 32, PARAM_OUT); /* number of words to program */
+
+	/* write code buffer and use Flash programming code within kinetis       */
+	/* Set breakpoint to 0 with time-out of 1000 ms                          */
+	while (wcount > 0) {
+		uint32_t thisrun_count = (wcount > (buffer_size / 4)) ? (buffer_size / 4) : wcount;
+
+		retval = target_write_buffer(target, write_algorithm->address, 8,
+				kinetis_flash_write_code);
+		if (retval != ERROR_OK)
+			break;
+
+		retval = target_write_buffer(target, source->address, thisrun_count * 4, buffer);
+		if (retval != ERROR_OK)
+			break;
+
+		buf_set_u32(reg_params[0].value, 0, 32, source->address);
+		buf_set_u32(reg_params[1].value, 0, 32, address);
+		buf_set_u32(reg_params[2].value, 0, 32, thisrun_count);
+
+		retval = target_run_algorithm(target, 0, NULL, 3, reg_params,
+				write_algorithm->address, 0, 100000, &armv7m_info);
+		if (retval != ERROR_OK) {
+			LOG_ERROR("Error executing kinetis Flash programming algorithm");
+			retval = ERROR_FLASH_OPERATION_FAILED;
+			break;
+		}
+
+		buffer += thisrun_count * 4;
+		address += thisrun_count * 4;
+		wcount -= thisrun_count;
+	}
+
+	target_free_working_area(target, source);
+	target_free_working_area(target, write_algorithm);
+
+	destroy_reg_param(&reg_params[0]);
+	destroy_reg_param(&reg_params[1]);
+	destroy_reg_param(&reg_params[2]);
+
+	return retval;
+}
+
+static int kinetis_protect(struct flash_bank *bank, int set, int first, int last)
 {
 	LOG_WARNING("kinetis_protect not supported yet");
 	/* FIXME: TODO */
@@ -219,8 +397,8 @@ static int kinetis_ftfx_command(struct flash_bank *bank, uint8_t fcmd, uint32_t
 				uint8_t *ftfx_fstat)
 {
 	uint8_t command[12] = {faddr & 0xff, (faddr >> 8) & 0xff, (faddr >> 16) & 0xff, fcmd,
-			       fccob7, fccob6, fccob5, fccob4,
-			       fccobb, fccoba, fccob9, fccob8};
+			fccob7, fccob6, fccob5, fccob4,
+			fccobb, fccoba, fccob9, fccob8};
 	int result, i;
 	uint8_t buffer;
 
@@ -259,7 +437,7 @@ static int kinetis_ftfx_command(struct flash_bank *bank, uint8_t fcmd, uint32_t
 		return result;
 
 	/* wait for done */
-	for (i = 0; i < 50; i++) {
+	for (i = 0; i < 240; i++) { /* Need Entire Erase Nemui Changed */
 		result =
 			target_read_memory(bank->target, FTFx_FSTAT, 1, 1, ftfx_fstat);
 
@@ -274,17 +452,50 @@ static int kinetis_ftfx_command(struct flash_bank *bank, uint8_t fcmd, uint32_t
 		LOG_ERROR
 			("ftfx command failed FSTAT: %02X FCCOB: %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X",
 			 *ftfx_fstat, command[3], command[2], command[1], command[0],
-				      command[7], command[6], command[5], command[4],
-				      command[11], command[10], command[9], command[8]);
+			 command[7], command[6], command[5], command[4],
+			 command[11], command[10], command[9], command[8]);
 		return ERROR_FLASH_OPERATION_FAILED;
 	}
 
 	return ERROR_OK;
 }
 
+static int kinetis_mass_erase(struct flash_bank *bank)
+{
+	int result;
+	uint8_t ftfx_fstat;
+
+	if (bank->target->state != TARGET_HALTED) {
+		LOG_ERROR("Target not halted");
+		return ERROR_TARGET_NOT_HALTED;
+	}
+
+	/* check if whole bank is blank */
+	LOG_INFO("Kinetis L Series Erase All Blocks");
+	/* set command and sector address */
+	result = kinetis_ftfx_command(bank, FTFx_CMD_MASSERASE, 0,
+			0, 0, 0, 0,  0, 0, 0, 0,  &ftfx_fstat);
+	/* Anyway Result, write unsecure byte */
+	/*	if (result != ERROR_OK)
+		return result;*/
+
+	/* Write to MCU security status unsecure in Flash security byte(Work around) */
+	LOG_INFO("Write to MCU security status unsecure Anyway!");
+	uint8_t padding[4] = {0xFE, 0xFF, 0xFF, 0xFF}; /* Write 0xFFFFFFFE */
+
+	result = kinetis_ftfx_command(bank, FTFx_CMD_LWORDPROG, (bank->base + 0x0000040C),
+				padding[3], padding[2], padding[1], padding[0],
+				0, 0, 0, 0,  &ftfx_fstat);
+	if (result != ERROR_OK)
+		return ERROR_FLASH_OPERATION_FAILED;
+
+	return ERROR_OK;
+}
+
 static int kinetis_erase(struct flash_bank *bank, int first, int last)
 {
 	int result, i;
+	struct kinetis_flash_bank *kinfo = bank->driver_priv;
 
 	if (bank->target->state != TARGET_HALTED) {
 		LOG_ERROR("Target not halted");
@@ -294,6 +505,9 @@ static int kinetis_erase(struct flash_bank *bank, int first, int last)
 	if ((first > bank->num_sectors) || (last > bank->num_sectors))
 		return ERROR_FLASH_OPERATION_FAILED;
 
+	if ((first == 0) && (last == (bank->num_sectors - 1)) && (kinfo->klxx))
+		return kinetis_mass_erase(bank);
+
 	/*
 	 * FIXME: TODO: use the 'Erase Flash Block' command if the
 	 * requested erase is PFlash or NVM and encompasses the entire
@@ -303,7 +517,7 @@ static int kinetis_erase(struct flash_bank *bank, int first, int last)
 		uint8_t ftfx_fstat;
 		/* set command and sector address */
 		result = kinetis_ftfx_command(bank, FTFx_CMD_SECTERASE, bank->base + bank->sectors[i].offset,
-					      0, 0, 0, 0,  0, 0, 0, 0,  &ftfx_fstat);
+				0, 0, 0, 0,  0, 0, 0, 0,  &ftfx_fstat);
 
 		if (result != ERROR_OK) {
 			LOG_WARNING("erase sector %d failed", i);
@@ -328,13 +542,20 @@ static int kinetis_write(struct flash_bank *bank, uint8_t *buffer,
 	uint8_t buf[8];
 	uint32_t wc;
 	struct kinetis_flash_bank *kinfo = bank->driver_priv;
+	uint8_t *new_buffer = NULL;
 
 	if (bank->target->state != TARGET_HALTED) {
 		LOG_ERROR("Target not halted");
 		return ERROR_TARGET_NOT_HALTED;
 	}
 
-	if (kinfo->flash_class == FC_FLEX_NVM) {
+	if (kinfo->klxx) {
+		/* fallback to longword write */
+		fallback = 1;
+		LOG_WARNING("Kinetis L Series supports Program Longword execution only.");
+		LOG_DEBUG("flash write into PFLASH @08%X", offset);
+
+	} else if (kinfo->flash_class == FC_FLEX_NVM) {
 		uint8_t ftfx_fstat;
 
 		LOG_DEBUG("flash write into FlexNVM @%08X", offset);
@@ -355,8 +576,7 @@ static int kinetis_write(struct flash_bank *bank, uint8_t *buffer,
 			/* fallback to longword write */
 			fallback = 1;
 
-			LOG_WARNING("ram not ready, fallback to slow longword write (FCNFG: %02X)",
-				    buf[0]);
+			LOG_WARNING("ram not ready, fallback to slow longword write (FCNFG: %02X)", buf[0]);
 		}
 	} else {
 		LOG_DEBUG("flash write into PFLASH @08%X", offset);
@@ -374,7 +594,7 @@ static int kinetis_write(struct flash_bank *bank, uint8_t *buffer,
 		unsigned prog_section_chunk_bytes = kinfo->sector_size >> 8;
 		/* assume the NVM sector size is half the FlexRAM size */
 		unsigned prog_size_bytes = MIN(kinfo->sector_size,
-					       kinetis_flash_params[kinfo->granularity].nvm_sector_size_bytes);
+				kinetis_flash_params[kinfo->granularity].nvm_sector_size_bytes);
 		for (i = 0; i < count; i += prog_size_bytes) {
 			uint8_t residual_buffer[16];
 			uint8_t ftfx_fstat;
@@ -417,7 +637,7 @@ static int kinetis_write(struct flash_bank *bank, uint8_t *buffer,
 
 			/* write data to flexram as whole-words */
 			result = target_write_memory(bank->target, FLEXRAM, 4, wc,
-						     buffer + i);
+					buffer + i);
 
 			if (result != ERROR_OK) {
 				LOG_ERROR("target_write_memory failed");
@@ -427,9 +647,9 @@ static int kinetis_write(struct flash_bank *bank, uint8_t *buffer,
 			/* write the residual words to the flexram */
 			if (residual_wc) {
 				result = target_write_memory(bank->target,
-							     FLEXRAM+4*wc,
-							     4, residual_wc,
-							     residual_buffer);
+						FLEXRAM+4*wc,
+						4, residual_wc,
+						residual_buffer);
 
 				if (result != ERROR_OK) {
 					LOG_ERROR("target_write_memory failed");
@@ -439,29 +659,59 @@ static int kinetis_write(struct flash_bank *bank, uint8_t *buffer,
 
 			/* execute section-write command */
 			result = kinetis_ftfx_command(bank, FTFx_CMD_SECTWRITE, bank->base + offset + i,
-						      section_count>>8, section_count, 0, 0,
-						      0, 0, 0, 0,  &ftfx_fstat);
+					section_count>>8, section_count, 0, 0,
+					0, 0, 0, 0,  &ftfx_fstat);
 
 			if (result != ERROR_OK)
 				return ERROR_FLASH_OPERATION_FAILED;
 		}
 	}
 	/* program longword command, not supported in "SF3" devices */
-	else if (kinfo->granularity != 3) {
-		for (i = 0; i < count; i += 4) {
-			uint8_t ftfx_fstat;
+	else if ((kinfo->granularity != 3) || (kinfo->klxx)) {
+
+		if (count & 0x3) {
+			uint32_t old_count = count;
+			count = (old_count | 3) + 1;
+			new_buffer = malloc(count);
+			if (new_buffer == NULL) {
+				LOG_ERROR("odd number of bytes to write and no memory "
+					"for padding buffer");
+				return ERROR_FAIL;
+			}
+			LOG_INFO("odd number of bytes to write (%d), extending to %d "
+				"and padding with 0xff", old_count, count);
+			memset(buffer, 0xff, count);
+			buffer = memcpy(new_buffer, buffer, old_count);
+		}
 
-			LOG_DEBUG("write longword @ %08X", offset + i);
+		uint32_t words_remaining = count / 4;
 
-			uint8_t padding[4] = {0xff, 0xff, 0xff, 0xff};
-			memcpy(padding, buffer + i, MIN(4, count-i));
-			result = kinetis_ftfx_command(bank, FTFx_CMD_LWORDPROG, bank->base + offset + i,
-						      padding[3], padding[2], padding[1], padding[0],
-						      0, 0, 0, 0,  &ftfx_fstat);
+		/* try using a block write */
+		int retval = kinetis_write_block(bank, buffer, offset, words_remaining);
 
-			if (result != ERROR_OK)
-				return ERROR_FLASH_OPERATION_FAILED;
+		if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE) {
+			/* if block write failed (no sufficient working area),
+			 * we use normal (slow) single word accesses */
+			LOG_WARNING("couldn't use block writes, falling back to single "
+				"memory accesses");
+
+			for (i = 0; i < count; i += 4) {
+				uint8_t ftfx_fstat;
+
+				LOG_DEBUG("write longword @ %08X", offset + i);
+
+				uint8_t padding[4] = {0xff, 0xff, 0xff, 0xff};
+				memcpy(padding, buffer + i, MIN(4, count-i));
+
+				result = kinetis_ftfx_command(bank, FTFx_CMD_LWORDPROG, bank->base + offset + i,
+						padding[3], padding[2], padding[1], padding[0],
+						0, 0, 0, 0,  &ftfx_fstat);
+
+				if (result != ERROR_OK)
+					return ERROR_FLASH_OPERATION_FAILED;
+			}
 		}
+
 	} else {
 		LOG_ERROR("Flash write strategy not implemented");
 		return ERROR_FLASH_OPERATION_FAILED;
@@ -473,33 +723,38 @@ static int kinetis_write(struct flash_bank *bank, uint8_t *buffer,
 static int kinetis_read_part_info(struct flash_bank *bank)
 {
 	int result, i;
-	uint8_t buf[4];
 	uint32_t offset = 0;
 	uint8_t fcfg1_nvmsize, fcfg1_pfsize, fcfg1_eesize, fcfg2_pflsh;
 	uint32_t nvm_size = 0, pf_size = 0, ee_size = 0;
 	unsigned granularity, num_blocks = 0, num_pflash_blocks = 0, num_nvm_blocks = 0,
 		first_nvm_bank = 0, reassign = 0;
+	struct target *target = bank->target;
 	struct kinetis_flash_bank *kinfo = bank->driver_priv;
 
-	result = target_read_memory(bank->target, SIM_SDID, 1, 4, buf);
+	result = target_read_u32(target, SIM_SDID, &kinfo->sim_sdid);
 	if (result != ERROR_OK)
 		return result;
-	kinfo->sim_sdid = target_buffer_get_u32(bank->target, buf);
-	granularity = (kinfo->sim_sdid >> 7) & 0x03;
 
-	result = target_read_memory(bank->target, SIM_FCFG1, 1, 4, buf);
+	/* Kinetis L Series SubFamily Check */
+	kinfo->klxx = 0;
+	i = (kinfo->sim_sdid >> 20) & 0x0F;
+	if (i == 1) {
+		kinfo->klxx = 1;
+		granularity = 0;
+	} else
+		granularity = (kinfo->sim_sdid >> 7) & 0x03;
+
+	result = target_read_u32(target, SIM_FCFG1, &kinfo->sim_fcfg1);
 	if (result != ERROR_OK)
 		return result;
-	kinfo->sim_fcfg1 = target_buffer_get_u32(bank->target, buf);
 
-	result = target_read_memory(bank->target, SIM_FCFG2, 1, 4, buf);
+	result = target_read_u32(target, SIM_FCFG2, &kinfo->sim_fcfg2);
 	if (result != ERROR_OK)
 		return result;
-	kinfo->sim_fcfg2 = target_buffer_get_u32(bank->target, buf);
 	fcfg2_pflsh = (kinfo->sim_fcfg2 >> 23) & 0x01;
 
-	LOG_DEBUG("SDID: %08X FCFG1: %08X FCFG2: %08X", kinfo->sim_sdid,
-		  kinfo->sim_fcfg1, kinfo->sim_fcfg2);
+	LOG_DEBUG("SDID: 0x%08X FCFG1: 0x%08X FCFG2: 0x%08X", kinfo->sim_sdid,
+			kinfo->sim_fcfg1, kinfo->sim_fcfg2);
 
 	fcfg1_nvmsize = (uint8_t)((kinfo->sim_fcfg1 >> 28) & 0x0f);
 	fcfg1_pfsize = (uint8_t)((kinfo->sim_fcfg1 >> 24) & 0x0f);
@@ -568,14 +823,17 @@ static int kinetis_read_part_info(struct flash_bank *bank)
 
 	LOG_DEBUG("FlexNVM: %d PFlash: %d FlexRAM: %d PFLSH: %d",
 		  nvm_size, pf_size, ee_size, fcfg2_pflsh);
+	if (kinfo->klxx)
+		num_blocks = 1;
+	else
+		num_blocks = kinetis_flash_params[granularity].num_blocks;
 
-	num_blocks = kinetis_flash_params[granularity].num_blocks;
 	num_pflash_blocks = num_blocks / (2 - fcfg2_pflsh);
 	first_nvm_bank = num_pflash_blocks;
 	num_nvm_blocks = num_blocks - num_pflash_blocks;
 
 	LOG_DEBUG("%d blocks total: %d PFlash, %d FlexNVM",
-		  num_blocks, num_pflash_blocks, num_nvm_blocks);
+			num_blocks, num_pflash_blocks, num_nvm_blocks);
 
 	/*
 	 * If the flash class is already assigned, verify the
@@ -592,8 +850,7 @@ static int kinetis_read_part_info(struct flash_bank *bank)
 			switch (kinfo->flash_class) {
 			case FC_PFLASH:
 				if (kinfo->bank_ordinal >= first_nvm_bank) {
-					LOG_WARNING("Class mismatch, bank %d is not PFlash",
-						    bank->bank_number);
+					LOG_WARNING("Class mismatch, bank %d is not PFlash", bank->bank_number);
 					reassign = 1;
 				} else if (bank->size != (pf_size / num_pflash_blocks)) {
 					LOG_WARNING("PFlash size mismatch");
@@ -603,7 +860,7 @@ static int kinetis_read_part_info(struct flash_bank *bank)
 					LOG_WARNING("PFlash address range mismatch");
 					reassign = 1;
 				} else if (kinfo->sector_size !=
-					 kinetis_flash_params[granularity].pflash_sector_size_bytes) {
+						kinetis_flash_params[granularity].pflash_sector_size_bytes) {
 					LOG_WARNING("PFlash sector size mismatch");
 					reassign = 1;
 				} else {
@@ -613,19 +870,18 @@ static int kinetis_read_part_info(struct flash_bank *bank)
 				break;
 			case FC_FLEX_NVM:
 				if ((kinfo->bank_ordinal >= num_blocks) ||
-				    (kinfo->bank_ordinal < first_nvm_bank)) {
-					LOG_WARNING("Class mismatch, bank %d is not FlexNVM",
-						    bank->bank_number);
+						(kinfo->bank_ordinal < first_nvm_bank)) {
+					LOG_WARNING("Class mismatch, bank %d is not FlexNVM", bank->bank_number);
 					reassign = 1;
 				} else if (bank->size != (nvm_size / num_nvm_blocks)) {
 					LOG_WARNING("FlexNVM size mismatch");
 					reassign = 1;
 				} else if (bank->base !=
-					 (0x10000000 + bank->size * kinfo->bank_ordinal)) {
+						(0x10000000 + bank->size * kinfo->bank_ordinal)) {
 					LOG_WARNING("FlexNVM address range mismatch");
 					reassign = 1;
 				} else if (kinfo->sector_size !=
-					 kinetis_flash_params[granularity].nvm_sector_size_bytes) {
+						kinetis_flash_params[granularity].nvm_sector_size_bytes) {
 					LOG_WARNING("FlexNVM sector size mismatch");
 					reassign = 1;
 				} else {
@@ -635,8 +891,7 @@ static int kinetis_read_part_info(struct flash_bank *bank)
 				break;
 			case FC_FLEX_RAM:
 				if (kinfo->bank_ordinal != num_blocks) {
-					LOG_WARNING("Class mismatch, bank %d is not FlexRAM",
-						    bank->bank_number);
+					LOG_WARNING("Class mismatch, bank %d is not FlexRAM", bank->bank_number);
 					reassign = 1;
 				} else if (bank->size != ee_size) {
 					LOG_WARNING("FlexRAM size mismatch");
@@ -649,8 +904,7 @@ static int kinetis_read_part_info(struct flash_bank *bank)
 					LOG_WARNING("FlexRAM sector size mismatch");
 					reassign = 1;
 				} else {
-					LOG_DEBUG("FlexRAM bank %d already configured okay",
-						  kinfo->bank_ordinal);
+					LOG_DEBUG("FlexRAM bank %d already configured okay", kinfo->bank_ordinal);
 				}
 				break;
 
@@ -689,7 +943,7 @@ static int kinetis_read_part_info(struct flash_bank *bank)
 		return ERROR_FLASH_OPER_UNSUPPORTED;
 	} else {
 		LOG_ERROR("Cannot determine parameters for bank %d, only %d banks on device",
-			  bank->bank_number, num_blocks);
+				bank->bank_number, num_blocks);
 		return ERROR_FLASH_BANK_INVALID;
 	}
 
@@ -798,7 +1052,7 @@ static int kinetis_blank_check(struct flash_bank *bank)
 }
 
 static int kinetis_flash_read(struct flash_bank *bank,
-			      uint8_t *buffer, uint32_t offset, uint32_t count)
+		uint8_t *buffer, uint32_t offset, uint32_t count)
 {
 	LOG_WARNING("kinetis_flash_read not supported yet");