X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fflash%2Fnor%2Fstellaris.c;h=b4c959f05c089033d55f578fcf0fe386f7f17f49;hp=4c819c6195d294946d521e132a8c614bc9b2846e;hb=64c2e03b23d9;hpb=b631e78b25433712b4ffd03e1bc4b34a03da4f10

diff --git a/src/flash/nor/stellaris.c b/src/flash/nor/stellaris.c
index 4c819c6195..b4c959f05c 100644
--- a/src/flash/nor/stellaris.c
+++ b/src/flash/nor/stellaris.c
@@ -16,9 +16,7 @@
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 /***************************************************************************
@@ -107,14 +105,9 @@ struct stellaris_flash_bank {
 	uint8_t target_class;
 
 	uint32_t sramsiz;
-	uint32_t flshsz;
 	/* flash geometry */
 	uint32_t num_pages;
 	uint32_t pagesize;
-	uint32_t pages_in_lockregion;
-
-	/* nv memory bits */
-	uint16_t num_lockbits;
 
 	/* main clock status */
 	uint32_t rcc;
@@ -486,62 +479,45 @@ FLASH_BANK_COMMAND_HANDLER(stellaris_flash_bank_command)
 	return ERROR_OK;
 }
 
-static int get_stellaris_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_stellaris_info(struct flash_bank *bank, struct command_invocation *cmd)
 {
-	int printed;
 	struct stellaris_flash_bank *stellaris_info = bank->driver_priv;
 
 	if (stellaris_info->did1 == 0)
 		return ERROR_FLASH_BANK_NOT_PROBED;
 
-	/* Read main and master clock freqency register */
+	/* Read main and master clock frequency register */
 	stellaris_read_clock_info(bank);
 
-	printed = snprintf(buf,
-			   buf_size,
-			   "\nTI/LMI Stellaris information: Chip is "
-			   "class %i (%s) %s rev %c%i\n",
-			   stellaris_info->target_class,
-			   StellarisClassname[stellaris_info->target_class],
-			   stellaris_info->target_name,
-			   (int)('A' + ((stellaris_info->did0 >> 8) & 0xFF)),
-			   (int)((stellaris_info->did0) & 0xFF));
-	buf += printed;
-	buf_size -= printed;
-
-	printed = snprintf(buf,
-			   buf_size,
-			   "did1: 0x%8.8" PRIx32 ", arch: 0x%4.4" PRIx32
-			   ", eproc: %s, ramsize: %ik, flashsize: %ik\n",
-			   stellaris_info->did1,
-			   stellaris_info->did1,
-			   "ARMv7M",
-			   stellaris_info->sramsiz,
-			   stellaris_info->num_pages * stellaris_info->pagesize / 1024);
-	buf += printed;
-	buf_size -= printed;
-
-	printed = snprintf(buf,
-			   buf_size,
-			   "master clock: %ikHz%s, "
-			   "rcc is 0x%" PRIx32 ", rcc2 is 0x%" PRIx32 "\n",
-			   (int)(stellaris_info->mck_freq / 1000),
-			   stellaris_info->mck_desc,
-			   stellaris_info->rcc,
-			   stellaris_info->rcc2);
-	buf += printed;
-	buf_size -= printed;
-
-	if (stellaris_info->num_lockbits > 0) {
-		snprintf(buf,
-				buf_size,
-				"pagesize: %" PRIi32 ", pages: %d, "
-				"lockbits: %i, pages per lockbit: %i\n",
-				stellaris_info->pagesize,
-				(unsigned) stellaris_info->num_pages,
-				stellaris_info->num_lockbits,
-				(unsigned) stellaris_info->pages_in_lockregion);
-	}
+	command_print_sameline(cmd,
+			"\nTI/LMI Stellaris information: Chip is "
+			"class %i (%s) %s rev %c%i\n",
+			stellaris_info->target_class,
+			StellarisClassname[stellaris_info->target_class],
+			stellaris_info->target_name,
+			(int)('A' + ((stellaris_info->did0 >> 8) & 0xFF)),
+			(int)((stellaris_info->did0) & 0xFF));
+
+	command_print_sameline(cmd,
+			"did1: 0x%8.8" PRIx32 ", arch: 0x%4.4" PRIx32
+			", eproc: %s, ramsize: %" PRIu32 "k, flashsize: %" PRIu32 "k\n",
+			stellaris_info->did1,
+			stellaris_info->did1,
+			"ARMv7M",
+			stellaris_info->sramsiz,
+			(uint32_t)(stellaris_info->num_pages * stellaris_info->pagesize / 1024));
+
+	command_print_sameline(cmd,
+			"master clock: %ikHz%s, "
+			"rcc is 0x%" PRIx32 ", rcc2 is 0x%" PRIx32 ", "
+			"pagesize: %" PRIu32 ", pages: %" PRIu32,
+			(int)(stellaris_info->mck_freq / 1000),
+			stellaris_info->mck_desc,
+			stellaris_info->rcc,
+			stellaris_info->rcc2,
+			stellaris_info->pagesize,
+			stellaris_info->num_pages);
+
 	return ERROR_OK;
 }
 
@@ -549,7 +525,7 @@ static int get_stellaris_info(struct flash_bank *bank, char *buf, int buf_size)
 *	chip identification and status                                         *
 ***************************************************************************/
 
-/* Set the flash timimg register to match current clocking */
+/* Set the flash timing register to match current clocking */
 static void stellaris_set_flash_timing(struct flash_bank *bank)
 {
 	struct stellaris_flash_bank *stellaris_info = bank->driver_priv;
@@ -616,7 +592,7 @@ static void stellaris_read_clock_info(struct flash_bank *bank)
 	LOG_DEBUG("Stellaris PLLCFG %" PRIx32 "", pllcfg);
 
 	stellaris_info->rcc = rcc;
-	stellaris_info->rcc = rcc2;
+	stellaris_info->rcc2 = rcc2;
 
 	sysdiv = (rcc >> 23) & 0xF;
 	usesysdiv = (rcc >> 22) & 0x1;
@@ -782,11 +758,9 @@ static int stellaris_read_part_info(struct flash_bank *bank)
 		target_read_u32(target, FLASH_FSIZE, &stellaris_info->fsize);
 		target_read_u32(target, FLASH_SSIZE, &stellaris_info->ssize);
 
-		stellaris_info->num_lockbits = 1 + (stellaris_info->fsize & 0xFFFF);
 		stellaris_info->num_pages = 2 * (1 + (stellaris_info->fsize & 0xFFFF));
 		stellaris_info->sramsiz = (1 + (stellaris_info->ssize & 0xFFFF)) / 4;
 		stellaris_info->pagesize = 1024;
-		stellaris_info->pages_in_lockregion = 2;
 	} else if (stellaris_info->target_class == 0xa) { /* Snowflake */
 		target_read_u32(target, FLASH_FSIZE, &stellaris_info->fsize);
 		target_read_u32(target, FLASH_SSIZE, &stellaris_info->ssize);
@@ -794,17 +768,11 @@ static int stellaris_read_part_info(struct flash_bank *bank)
 		stellaris_info->pagesize = (1 << ((stellaris_info->fsize >> 16) & 7)) * 1024;
 		stellaris_info->num_pages = 2048 * (1 + (stellaris_info->fsize & 0xFFFF)) /
 			stellaris_info->pagesize;
-		stellaris_info->pages_in_lockregion = 1;
-
-		stellaris_info->num_lockbits = stellaris_info->pagesize * stellaris_info->num_pages /
-			2048;
 		stellaris_info->sramsiz = (1 + (stellaris_info->ssize & 0xFFFF)) / 4;
 	} else {
-		stellaris_info->num_lockbits = 1 + (stellaris_info->dc0 & 0xFFFF);
 		stellaris_info->num_pages = 2 * (1 + (stellaris_info->dc0 & 0xFFFF));
 		stellaris_info->sramsiz = (1 + ((stellaris_info->dc0 >> 16) & 0xFFFF)) / 4;
 		stellaris_info->pagesize = 1024;
-		stellaris_info->pages_in_lockregion = 2;
 	}
 
 	/* REVISIT for at least Tempest parts, read NVMSTAT.FWB too.
@@ -822,57 +790,54 @@ static int stellaris_read_part_info(struct flash_bank *bank)
 static int stellaris_protect_check(struct flash_bank *bank)
 {
 	struct stellaris_flash_bank *stellaris = bank->driver_priv;
+	struct target *target = bank->target;
+	uint32_t flash_sizek = stellaris->pagesize / 1024 *
+		stellaris->num_pages;
+	uint32_t fmppe_addr;
 	int status = ERROR_OK;
-	unsigned i;
-	unsigned page;
 
 	if (stellaris->did1 == 0)
 		return ERROR_FLASH_BANK_NOT_PROBED;
 
-	if (stellaris->target_class == 0xa) {
-		LOG_WARNING("Assuming flash to be unprotected on Snowflake");
-		return ERROR_OK;
-	}
-
-	for (i = 0; i < (unsigned) bank->num_sectors; i++)
+	for (unsigned int i = 0; i < bank->num_sectors; i++)
 		bank->sectors[i].is_protected = -1;
 
 	/* Read each Flash Memory Protection Program Enable (FMPPE) register
 	 * to report any pages that we can't write.  Ignore the Read Enable
 	 * register (FMPRE).
 	 */
-	for (i = 0, page = 0;
-			i < DIV_ROUND_UP(stellaris->num_lockbits, 32u);
-			i++) {
-		uint32_t lockbits;
-
-		status = target_read_u32(bank->target,
-				SCB_BASE + (i ? (FMPPE0 + 4 * i) : FMPPE),
-				&lockbits);
-		LOG_DEBUG("FMPPE%d = %#8.8x (status %d)", i,
-				(unsigned) lockbits, status);
-		if (status != ERROR_OK)
-			goto done;
-
-		for (unsigned j = 0; j < 32; j++) {
-			unsigned k;
 
-			for (k = 0; k < stellaris->pages_in_lockregion; k++) {
-				if (page >= (unsigned) bank->num_sectors)
-					goto done;
-				bank->sectors[page++].is_protected =
-						!(lockbits & (1 << j));
+	if (stellaris->target_class >= 0x0a || flash_sizek > 64)
+		fmppe_addr = SCB_BASE | FMPPE0;
+	else
+		fmppe_addr = SCB_BASE | FMPPE;
+
+	unsigned int page = 0, lockbitnum, lockbitcnt = flash_sizek / 2;
+	unsigned int bits_per_page = stellaris->pagesize / 2048;
+	/* Every lock bit always corresponds to a 2k region */
+	for (lockbitnum = 0; lockbitnum < lockbitcnt; lockbitnum += 32) {
+		uint32_t fmppe;
+
+		target_read_u32(target, fmppe_addr, &fmppe);
+		for (unsigned int i = 0; i < 32 && lockbitnum + i < lockbitcnt; i++) {
+			bool protect = !(fmppe & (1 << i));
+			if (bits_per_page) {
+				bank->sectors[page++].is_protected = protect;
+				i += bits_per_page - 1;
+			} else { /* 1024k pages, every lockbit covers 2 pages */
+				bank->sectors[page++].is_protected = protect;
+				bank->sectors[page++].is_protected = protect;
 			}
 		}
+		fmppe_addr += 4;
 	}
 
-done:
 	return status;
 }
 
-static int stellaris_erase(struct flash_bank *bank, int first, int last)
+static int stellaris_erase(struct flash_bank *bank, unsigned int first,
+		unsigned int last)
 {
-	int banknr;
 	uint32_t flash_fmc, flash_cris;
 	struct stellaris_flash_bank *stellaris_info = bank->driver_priv;
 	struct target *target = bank->target;
@@ -885,10 +850,10 @@ static int stellaris_erase(struct flash_bank *bank, int first, int last)
 	if (stellaris_info->did1 == 0)
 		return ERROR_FLASH_BANK_NOT_PROBED;
 
-	if ((first < 0) || (last < first) || (last >= (int)stellaris_info->num_pages))
+	if ((last < first) || (last >= stellaris_info->num_pages))
 		return ERROR_FLASH_SECTOR_INVALID;
 
-	if ((first == 0) && (last == ((int)stellaris_info->num_pages-1)))
+	if ((first == 0) && (last == (stellaris_info->num_pages - 1)))
 		return stellaris_mass_erase(bank);
 
 	/* Refresh flash controller timing */
@@ -903,7 +868,7 @@ static int stellaris_erase(struct flash_bank *bank, int first, int last)
 	 * it might want to process those IRQs.
 	 */
 
-	for (banknr = first; banknr <= last; banknr++) {
+	for (unsigned int banknr = first; banknr <= last; banknr++) {
 		/* Address is first word in page */
 		target_write_u32(target, FLASH_FMA, banknr * stellaris_info->pagesize);
 		/* Write erase command */
@@ -913,7 +878,7 @@ static int stellaris_erase(struct flash_bank *bank, int first, int last)
 			target_read_u32(target, FLASH_FMC, &flash_fmc);
 		} while (flash_fmc & FMC_ERASE);
 
-		/* Check acess violations */
+		/* Check access violations */
 		target_read_u32(target, FLASH_CRIS, &flash_cris);
 		if (flash_cris & (AMASK)) {
 			LOG_WARNING("Error erasing flash page %i,  flash_cris 0x%" PRIx32 "",
@@ -928,15 +893,15 @@ static int stellaris_erase(struct flash_bank *bank, int first, int last)
 	return ERROR_OK;
 }
 
-static int stellaris_protect(struct flash_bank *bank, int set, int first, int last)
+static int stellaris_protect(struct flash_bank *bank, int set,
+		unsigned int first, unsigned int last)
 {
-	uint32_t fmppe, flash_fmc, flash_cris;
-	int lockregion;
-
-	struct stellaris_flash_bank *stellaris_info = bank->driver_priv;
+	struct stellaris_flash_bank *stellaris = bank->driver_priv;
 	struct target *target = bank->target;
+	uint32_t flash_fmc, flash_cris;
+	unsigned int bits_per_page = stellaris->pagesize / 2048;
 
-	if (bank->target->state != TARGET_HALTED) {
+	if (target->state != TARGET_HALTED) {
 		LOG_ERROR("Target not halted");
 		return ERROR_TARGET_NOT_HALTED;
 	}
@@ -947,26 +912,18 @@ static int stellaris_protect(struct flash_bank *bank, int set, int first, int la
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	if (stellaris_info->did1 == 0)
+	if (stellaris->did1 == 0)
 		return ERROR_FLASH_BANK_NOT_PROBED;
 
-	if (stellaris_info->target_class == 0x03 &&
-	    !((stellaris_info->did0 >> 8) & 0xFF) &&
-	    !((stellaris_info->did0) & 0xFF)) {
+	if (stellaris->target_class == 0x03 &&
+	    !((stellaris->did0 >> 8) & 0xFF) &&
+	    !((stellaris->did0) & 0xFF)) {
 		LOG_ERROR("DustDevil A0 parts can't be unprotected, see errata; refusing to proceed");
 		return ERROR_FLASH_OPERATION_FAILED;
 	}
 
-	if (stellaris_info->target_class == 0xa) {
-		LOG_ERROR("Protection on Snowflake is not supported yet");
-		return ERROR_FLASH_OPERATION_FAILED;
-	}
-
-	/* lockregions are 2 pages ... must protect [even..odd] */
-	if ((first < 0) || (first & 1)
-			|| (last < first) || !(last & 1)
-			|| (last >= 2 * stellaris_info->num_lockbits)) {
-		LOG_ERROR("Can't protect unaligned or out-of-range pages.");
+	if (!bits_per_page && (first % 2 || !(last % 2))) {
+		LOG_ERROR("Can't protect unaligned pages");
 		return ERROR_FLASH_SECTOR_INVALID;
 	}
 
@@ -974,56 +931,66 @@ static int stellaris_protect(struct flash_bank *bank, int set, int first, int la
 	stellaris_read_clock_info(bank);
 	stellaris_set_flash_timing(bank);
 
-	/* convert from pages to lockregions */
-	first /= 2;
-	last /= 2;
-
-	/* FIXME this assumes single FMPPE, for a max of 64K of flash!!
-	 * Current parts can be much bigger.
-	 */
-	if (last >= 32) {
-		LOG_ERROR("No support yet for protection > 64K");
-		return ERROR_FLASH_OPERATION_FAILED;
-	}
-
-	target_read_u32(target, SCB_BASE | FMPPE, &fmppe);
-
-	for (lockregion = first; lockregion <= last; lockregion++)
-		fmppe &= ~(1 << lockregion);
-
 	/* Clear and disable flash programming interrupts */
 	target_write_u32(target, FLASH_CIM, 0);
 	target_write_u32(target, FLASH_MISC, PMISC | AMISC);
 
-	/* REVISIT this clobbers state set by any halted firmware ...
-	 * it might want to process those IRQs.
-	 */
+	uint32_t flash_sizek = stellaris->pagesize / 1024 *
+		stellaris->num_pages;
+	uint32_t fmppe_addr;
 
-	LOG_DEBUG("fmppe 0x%" PRIx32 "", fmppe);
-	target_write_u32(target, SCB_BASE | FMPPE, fmppe);
+	if (stellaris->target_class >= 0x0a || flash_sizek > 64)
+		fmppe_addr = SCB_BASE | FMPPE0;
+	else
+		fmppe_addr = SCB_BASE | FMPPE;
+
+	unsigned int page = 0;
+	unsigned int lockbitnum, lockbitcnt = flash_sizek / 2;
+	/* Every lock bit always corresponds to a 2k region */
+	for (lockbitnum = 0; lockbitnum < lockbitcnt; lockbitnum += 32) {
+		uint32_t fmppe;
+
+		target_read_u32(target, fmppe_addr, &fmppe);
+		for (unsigned int i = 0;
+		     i < 32 && lockbitnum + i < lockbitcnt;
+		     i++) {
+			if (page >= first && page <= last)
+				fmppe &= ~(1 << i);
+
+			if (bits_per_page) {
+				if (!((i + 1) % bits_per_page))
+					page++;
+			} else { /* 1024k pages, every lockbit covers 2 pages */
+				page += 2;
+			}
+		}
+		target_write_u32(target, fmppe_addr, fmppe);
 
-	/* Commit FMPPE */
-	target_write_u32(target, FLASH_FMA, 1);
-	/* Write commit command */
-	target_write_u32(target, FLASH_FMC, FMC_WRKEY | FMC_COMT);
+		/* Commit FMPPE* */
+		target_write_u32(target, FLASH_FMA, 1 + lockbitnum / 16);
+		/* Write commit command */
+		target_write_u32(target, FLASH_FMC, FMC_WRKEY | FMC_COMT);
 
-	/* Wait until erase complete */
-	do {
-		target_read_u32(target, FLASH_FMC, &flash_fmc);
-	} while (flash_fmc & FMC_COMT);
+		/* Wait until commit complete */
+		do {
+			target_read_u32(target, FLASH_FMC, &flash_fmc);
+		} while (flash_fmc & FMC_COMT);
 
-	/* Check acess violations */
-	target_read_u32(target, FLASH_CRIS, &flash_cris);
-	if (flash_cris & (AMASK)) {
-		LOG_WARNING("Error setting flash page protection,  flash_cris 0x%" PRIx32 "", flash_cris);
-		target_write_u32(target, FLASH_CRIS, 0);
-		return ERROR_FLASH_OPERATION_FAILED;
+		/* Check access violations */
+		target_read_u32(target, FLASH_CRIS, &flash_cris);
+		if (flash_cris & (AMASK)) {
+			LOG_WARNING("Error setting flash page protection,  flash_cris 0x%" PRIx32 "", flash_cris);
+			target_write_u32(target, FLASH_CRIS, 0);
+			return ERROR_FLASH_OPERATION_FAILED;
+		}
+
+		fmppe_addr += 4;
 	}
 
 	return ERROR_OK;
 }
 
-/* see contib/loaders/flash/stellaris.s for src */
+/* see contrib/loaders/flash/stellaris.s for src */
 
 static const uint8_t stellaris_write_code[] = {
 								/* write: */
@@ -1088,7 +1055,7 @@ static int stellaris_write_block(struct flash_bank *bank,
 			&write_algorithm) != ERROR_OK) {
 		LOG_DEBUG("no working area for block memory writes");
 		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
-	};
+	}
 
 	/* plus a buffer big enough for this data */
 	if (wcount * 4 < buffer_size)
@@ -1103,7 +1070,7 @@ static int stellaris_write_block(struct flash_bank *bank,
 		}
 		LOG_DEBUG("retry target_alloc_working_area(%s, size=%u)",
 				target_name(target), (unsigned) buffer_size);
-	};
+	}
 
 	target_write_buffer(target, write_algorithm->address,
 			sizeof(stellaris_write_code),
@@ -1195,7 +1162,7 @@ static int stellaris_write(struct flash_bank *bank, const uint8_t *buffer,
 			if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE) {
 				LOG_DEBUG("writing flash word-at-a-time");
 			} else if (retval == ERROR_FLASH_OPERATION_FAILED) {
-				/* if an error occured, we examine the reason, and quit */
+				/* if an error occurred, we examine the reason, and quit */
 				target_read_u32(target, FLASH_CRIS, &flash_cris);
 
 				LOG_ERROR("flash writing failed with CRIS: 0x%" PRIx32 "", flash_cris);
@@ -1275,16 +1242,13 @@ static int stellaris_probe(struct flash_bank *bank)
 	if (retval != ERROR_OK)
 		return retval;
 
-	if (bank->sectors) {
-		free(bank->sectors);
-		bank->sectors = NULL;
-	}
+	free(bank->sectors);
 
 	/* provide this for the benefit of the NOR flash framework */
 	bank->size = stellaris_info->num_pages * stellaris_info->pagesize;
 	bank->num_sectors = stellaris_info->num_pages;
 	bank->sectors = calloc(bank->num_sectors, sizeof(struct flash_sector));
-	for (int i = 0; i < bank->num_sectors; i++) {
+	for (unsigned int i = 0; i < bank->num_sectors; i++) {
 		bank->sectors[i].offset = i * stellaris_info->pagesize;
 		bank->sectors[i].size = stellaris_info->pagesize;
 		bank->sectors[i].is_erased = -1;
@@ -1346,8 +1310,6 @@ static int stellaris_mass_erase(struct flash_bank *bank)
 
 COMMAND_HANDLER(stellaris_handle_mass_erase_command)
 {
-	int i;
-
 	if (CMD_ARGC < 1)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
@@ -1358,12 +1320,12 @@ COMMAND_HANDLER(stellaris_handle_mass_erase_command)
 
 	if (stellaris_mass_erase(bank) == ERROR_OK) {
 		/* set all sectors as erased */
-		for (i = 0; i < bank->num_sectors; i++)
+		for (unsigned int i = 0; i < bank->num_sectors; i++)
 			bank->sectors[i].is_erased = 1;
 
-		command_print(CMD_CTX, "stellaris mass erase complete");
+		command_print(CMD, "stellaris mass erase complete");
 	} else
-		command_print(CMD_CTX, "stellaris mass erase failed");
+		command_print(CMD, "stellaris mass erase failed");
 
 	return ERROR_OK;
 }
@@ -1380,11 +1342,15 @@ COMMAND_HANDLER(stellaris_handle_mass_erase_command)
 COMMAND_HANDLER(stellaris_handle_recover_command)
 {
 	struct flash_bank *bank;
+	struct arm *arm;
 	int retval;
 
-	retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
-	if (retval != ERROR_OK)
-		return retval;
+	if (CMD_ARGC != 0)
+		return ERROR_COMMAND_SYNTAX_ERROR;
+
+	bank = get_flash_bank_by_num_noprobe(0);
+	if (!bank)
+		return ERROR_FAIL;
 
 	/* REVISIT ... it may be worth sanity checking that the AP is
 	 * inactive before we start.  ARM documents that switching a DP's
@@ -1405,12 +1371,13 @@ COMMAND_HANDLER(stellaris_handle_recover_command)
 	}
 	adapter_assert_reset();
 
+	arm = target_to_arm(bank->target);
 	for (int i = 0; i < 5; i++) {
-		retval = dap_to_swd(bank->target);
+		retval = dap_to_swd(arm->dap);
 		if (retval != ERROR_OK)
 			goto done;
 
-		retval = dap_to_jtag(bank->target);
+		retval = dap_to_jtag(arm->dap);
 		if (retval != ERROR_OK)
 			goto done;
 	}
@@ -1445,7 +1412,7 @@ static const struct command_registration stellaris_exec_command_handlers[] = {
 		.name = "recover",
 		.handler = stellaris_handle_recover_command,
 		.mode = COMMAND_EXEC,
-		.usage = "bank_id",
+		.usage = "",
 		.help = "recover (and erase) locked device",
 	},
 	COMMAND_REGISTRATION_DONE
@@ -1461,7 +1428,7 @@ static const struct command_registration stellaris_command_handlers[] = {
 	COMMAND_REGISTRATION_DONE
 };
 
-struct flash_driver stellaris_flash = {
+const struct flash_driver stellaris_flash = {
 	.name = "stellaris",
 	.commands = stellaris_command_handlers,
 	.flash_bank_command = stellaris_flash_bank_command,
@@ -1474,4 +1441,5 @@ struct flash_driver stellaris_flash = {
 	.erase_check = default_flash_blank_check,
 	.protect_check = stellaris_protect_check,
 	.info = get_stellaris_info,
+	.free_driver_priv = default_flash_free_driver_priv,
 };