[Openocd-svn] r2379 - in trunk/src: flash flash/ocl/at91sam7x target target/xscale

[<zw...@ma...>]

Author: zwelch
Date: 2009-06-24 00:49:23 +0200 (Wed, 24 Jun 2009)
New Revision: 2379

Modified:
   trunk/src/flash/aduc702x.c
   trunk/src/flash/at91sam7.c
   trunk/src/flash/cfi.c
   trunk/src/flash/flash.c
   trunk/src/flash/flash.h
   trunk/src/flash/mflash.c
   trunk/src/flash/nand.c
   trunk/src/flash/ocl/at91sam7x/samflash.c
   trunk/src/flash/pic32mx.c
   trunk/src/flash/stellaris.c
   trunk/src/flash/str7x.c
   trunk/src/flash/tms470.c
   trunk/src/target/algorithm.h
   trunk/src/target/arm11.c
   trunk/src/target/arm926ejs.h
   trunk/src/target/arm9tdmi.h
   trunk/src/target/arm_adi_v5.h
   trunk/src/target/arm_disassembler.c
   trunk/src/target/arm_disassembler.h
   trunk/src/target/arm_jtag.c
   trunk/src/target/arm_simulator.c
   trunk/src/target/armv4_5.c
   trunk/src/target/armv7m.c
   trunk/src/target/armv7m.h
   trunk/src/target/breakpoints.c
   trunk/src/target/cortex_m3.h
   trunk/src/target/feroceon.c
   trunk/src/target/mips32.c
   trunk/src/target/mips32.h
   trunk/src/target/mips32_dmaacc.c
   trunk/src/target/mips32_pracc.c
   trunk/src/target/mips_ejtag.c
   trunk/src/target/mips_m4k.c
   trunk/src/target/target.c
   trunk/src/target/trace.c
   trunk/src/target/xscale.h
   trunk/src/target/xscale/protocol.h
Log:
Remove whitespace at end of lines, step 1.
- Replace '\s*$' with ''.


Modified: trunk/src/flash/aduc702x.c
===================================================================
--- trunk/src/flash/aduc702x.c	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/flash/aduc702x.c	2009-06-23 22:49:23 UTC (rev 2379)
@@ -109,10 +109,10 @@
 static int aduc702x_build_sector_list(struct flash_bank_s *bank)
 {
 	//aduc7026_flash_bank_t *aduc7026_info = bank->driver_priv;
-	
+
         int i = 0;
         uint32_t offset = 0;
-		
+
         // sector size is 512
         bank->num_sectors = bank->size / 512;
         bank->sectors = malloc(sizeof(flash_sector_t) * bank->num_sectors);
@@ -203,7 +203,7 @@
 	reg_param_t reg_params[6];
 	armv4_5_algorithm_t armv4_5_info;
 	int retval = ERROR_OK;
-	
+
         /* parameters:
 
         r0 - address of source data (absolute)
@@ -240,7 +240,7 @@
         //<done>:
                 0xeafffffe 	// b	1003c <done>
 	};
-	
+
 	/* flash write code */
 	if (target_alloc_working_area(target, sizeof(aduc702x_flash_write_code),
                 &aduc702x_info->write_algorithm) != ERROR_OK)
@@ -248,8 +248,8 @@
 		LOG_WARNING("no working area available, can't do block memory writes");
 		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 	};
-	
-	target_write_buffer(target, aduc702x_info->write_algorithm->address, 
+
+	target_write_buffer(target, aduc702x_info->write_algorithm->address,
                 sizeof(aduc702x_flash_write_code), (uint8_t*)aduc702x_flash_write_code);
 
 	/* memory buffer */
@@ -261,26 +261,26 @@
 			/* if we already allocated the writing code, but failed to get a buffer, free the algorithm */
 			if (aduc702x_info->write_algorithm)
 				target_free_working_area(target, aduc702x_info->write_algorithm);
-			
+
 			LOG_WARNING("no large enough working area available, can't do block memory writes");
 			return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 		}
 	}
-	
+
 	armv4_5_info.common_magic = ARMV4_5_COMMON_MAGIC;
 	armv4_5_info.core_mode = ARMV4_5_MODE_SVC;
 	armv4_5_info.core_state = ARMV4_5_STATE_ARM;
-	
+
 	init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
 	init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
 	init_reg_param(&reg_params[2], "r2", 32, PARAM_OUT);
 	init_reg_param(&reg_params[3], "r3", 32, PARAM_IN);
 	init_reg_param(&reg_params[4], "r4", 32, PARAM_OUT);
-	
+
 	while (count > 0)
 	{
 		uint32_t thisrun_count = (count > (buffer_size / 2)) ? (buffer_size / 2) : count;
-		
+
 		target_write_buffer(target, source->address, thisrun_count * 2, buffer);
 
 		buf_set_u32(reg_params[0].value, 0, 32, source->address);
@@ -288,16 +288,16 @@
 		buf_set_u32(reg_params[2].value, 0, 32, address);
 		buf_set_u32(reg_params[4].value, 0, 32, 0xFFFFF800);
 
-		if ((retval = target_run_algorithm(target, 0, NULL, 5, 
-                        reg_params, aduc702x_info->write_algorithm->address, 
-                        aduc702x_info->write_algorithm->address + sizeof(aduc702x_flash_write_code) - 4, 
+		if ((retval = target_run_algorithm(target, 0, NULL, 5,
+                        reg_params, aduc702x_info->write_algorithm->address,
+                        aduc702x_info->write_algorithm->address + sizeof(aduc702x_flash_write_code) - 4,
                         10000, &armv4_5_info)) != ERROR_OK)
 		{
 			LOG_ERROR("error executing aduc702x flash write algorithm");
 			retval = ERROR_FLASH_OPERATION_FAILED;
 			break;
 		}
-	
+
 		if ((buf_get_u32(reg_params[3].value, 0, 32) & 1) != 1) {
 			retval = ERROR_FLASH_OPERATION_FAILED;
 			break;
@@ -310,24 +310,24 @@
 
 	target_free_working_area(target, source);
 	target_free_working_area(target, aduc702x_info->write_algorithm);
-	
+
 	destroy_reg_param(&reg_params[0]);
 	destroy_reg_param(&reg_params[1]);
 	destroy_reg_param(&reg_params[2]);
 	destroy_reg_param(&reg_params[3]);
 	destroy_reg_param(&reg_params[4]);
-	
+
 	return retval;
 }
 
-/* All-JTAG, single-access method.  Very slow.  Used only if there is no 
+/* All-JTAG, single-access method.  Very slow.  Used only if there is no
  * working area available. */
 static int aduc702x_write_single(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
 {
 	uint32_t x;
         uint8_t b;
 	target_t *target = bank->target;
-	
+
         aduc702x_set_write_enable(target, 1);
 
 	for (x = 0; x < count; x += 2) {
@@ -373,13 +373,13 @@
                 if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
                 {
                         /* if block write failed (no sufficient working area),
-                         * use normal (slow) JTAG method */ 
+                         * use normal (slow) JTAG method */
                         LOG_WARNING("couldn't use block writes, falling back to single memory accesses");
 
                         if ((retval = aduc702x_write_single(bank, buffer, offset, count)) != ERROR_OK)
                         {
                                 LOG_ERROR("slow write failed");
-                                return ERROR_FLASH_OPERATION_FAILED; 
+                                return ERROR_FLASH_OPERATION_FAILED;
                         }
                 }
                 else if (retval == ERROR_FLASH_OPERATION_FAILED)

Modified: trunk/src/flash/at91sam7.c
===================================================================
--- trunk/src/flash/at91sam7.c	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/flash/at91sam7.c	2009-06-23 22:49:23 UTC (rev 2379)
@@ -57,7 +57,7 @@
 static uint32_t at91sam7_get_flash_status(target_t *target, int bank_number);
 static void at91sam7_set_flash_mode(flash_bank_t *bank, int mode);
 static uint32_t at91sam7_wait_status_busy(flash_bank_t *bank, uint32_t waitbits, int timeout);
-static int at91sam7_flash_command(struct flash_bank_s *bank, uint8_t cmd, uint16_t pagen); 
+static int at91sam7_flash_command(struct flash_bank_s *bank, uint8_t cmd, uint16_t pagen);
 static int at91sam7_handle_gpnvm_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 
 flash_driver_t at91sam7_flash =
@@ -85,8 +85,8 @@
 static long SRAMSIZ[16] = {
 	-1,
 	0x0400,		/*  1K */
-	0x0800,		/*  2K */ 
-	-1, 
+	0x0800,		/*  2K */
+	-1,
 	0x1c000,	/* 112K */
 	0x1000,		/*   4K */
 	0x14000,	/*  80K */
@@ -135,10 +135,10 @@
 	target_read_u32(target, PMC_MCKR, &mckr);
 	/* Read Clock Generator PLL Register  */
 	target_read_u32(target, CKGR_PLLR, &pllr);
-	
+
 	at91sam7_info->mck_valid = 0;
 	at91sam7_info->mck_freq = 0;
-	switch (mckr & PMC_MCKR_CSS) 
+	switch (mckr & PMC_MCKR_CSS)
 	{
 		case 0:			/* Slow Clock */
 			at91sam7_info->mck_valid = 1;
@@ -146,7 +146,7 @@
 			break;
 
 		case 1:			/* Main Clock */
-			if ((mcfr & CKGR_MCFR_MAINRDY) && 
+			if ((mcfr & CKGR_MCFR_MAINRDY) &&
 				(at91sam7_info->ext_freq == 0))
 			{
 				at91sam7_info->mck_valid = 1;
@@ -163,8 +163,8 @@
 			break;
 
 		case 3:			/* PLL Clock */
-			if ((mcfr & CKGR_MCFR_MAINRDY) && 
-				(at91sam7_info->ext_freq == 0)) 
+			if ((mcfr & CKGR_MCFR_MAINRDY) &&
+				(at91sam7_info->ext_freq == 0))
 			{
 				target_read_u32(target, CKGR_PLLR, &pllr);
 				if (!(pllr & CKGR_PLLR_DIV))
@@ -280,7 +280,7 @@
 	at91sam7_flash_bank_t *at91sam7_info = bank->driver_priv;
 	target_t *target = bank->target;
 
-	fcr = (0x5A << 24) | ((pagen&0x3FF) << 8) | cmd; 
+	fcr = (0x5A << 24) | ((pagen&0x3FF) << 8) | cmd;
 	target_write_u32(target, MC_FCR[bank->bank_number], fcr);
 	LOG_DEBUG("Flash command: 0x%" PRIx32 ", flash bank: %i, page number: %u", fcr, bank->bank_number + 1, pagen);
 
@@ -294,7 +294,7 @@
 		return ERROR_OK;
 	}
 
-	if (at91sam7_wait_status_busy(bank, MC_FSR_FRDY, 10)&0x0C) 
+	if (at91sam7_wait_status_busy(bank, MC_FSR_FRDY, 10)&0x0C)
 	{
 		return ERROR_FLASH_OPERATION_FAILED;
 	}
@@ -635,7 +635,7 @@
 	}
 
 	/* Configure the flash controller timing */
-	at91sam7_read_clock_info(bank); 
+	at91sam7_read_clock_info(bank);
 	at91sam7_set_flash_mode(bank, FMR_TIMING_FLASH);
 
 	fast_check = 1;
@@ -892,7 +892,7 @@
 
 	if (erase_all)
 	{
-		if (at91sam7_flash_command(bank, EA, 0) != ERROR_OK) 
+		if (at91sam7_flash_command(bank, EA, 0) != ERROR_OK)
 		{
 			return ERROR_FLASH_OPERATION_FAILED;
 		}
@@ -1079,13 +1079,13 @@
 	buf += printed;
 	buf_size -= printed;
 
-	printed = snprintf(buf, 
+	printed = snprintf(buf,
 			   buf_size,
 			   " Cidr: 0x%8.8" PRIx32 " | Arch: 0x%4.4x | Eproc: %s | Version: 0x%3.3x | Flashsize: 0x%8.8" PRIx32 "\n",
-			   at91sam7_info->cidr, 
-			   at91sam7_info->cidr_arch, 
+			   at91sam7_info->cidr,
+			   at91sam7_info->cidr_arch,
 			   EPROC[at91sam7_info->cidr_eproc],
-			   at91sam7_info->cidr_version, 
+			   at91sam7_info->cidr_version,
 			   bank->size);
 
 	buf += printed;
@@ -1117,10 +1117,10 @@
 	return ERROR_OK;
 }
 
-/* 
-* On AT91SAM7S: When the gpnvm bits are set with 
+/*
+* On AT91SAM7S: When the gpnvm bits are set with
 * > at91sam7 gpnvm bitnr set
-* the changes are not visible in the flash controller status register MC_FSR 
+* the changes are not visible in the flash controller status register MC_FSR
 * until the processor has been reset.
 * On the Olimex board this requires a power cycle.
 * Note that the AT91SAM7S has the following errata (doc6175.pdf sec 14.1.3):
@@ -1191,7 +1191,7 @@
 	/* Configure the flash controller timing */
 	at91sam7_read_clock_info(bank);
 	at91sam7_set_flash_mode(bank, FMR_TIMING_NVBITS);
-	
+
 	if (at91sam7_flash_command(bank, flashcmd, bit) != ERROR_OK)
 	{
 		return ERROR_FLASH_OPERATION_FAILED;
@@ -1203,6 +1203,6 @@
 
 	/* check protect state */
 	at91sam7_protect_check(bank);
-	
+
 	return ERROR_OK;
 }

Modified: trunk/src/flash/cfi.c
===================================================================
--- trunk/src/flash/cfi.c	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/flash/cfi.c	2009-06-23 22:49:23 UTC (rev 2379)
@@ -378,9 +378,9 @@
 	pri_ext->suspend_cmd_support = cfi_query_u8(bank, 0, cfi_info->pri_addr + 9);
 	pri_ext->blk_status_reg_mask = cfi_query_u16(bank, 0, cfi_info->pri_addr + 0xa);
 
-	LOG_DEBUG("feature_support: 0x%" PRIx32 ", suspend_cmd_support: 0x%x, blk_status_reg_mask: 0x%x", 
-		  pri_ext->feature_support, 
-		  pri_ext->suspend_cmd_support, 
+	LOG_DEBUG("feature_support: 0x%" PRIx32 ", suspend_cmd_support: 0x%x, blk_status_reg_mask: 0x%x",
+		  pri_ext->feature_support,
+		  pri_ext->suspend_cmd_support,
 		  pri_ext->blk_status_reg_mask);
 
 	pri_ext->vcc_optimal = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0xc);
@@ -1597,7 +1597,7 @@
 	/* Check for valid range */
 	if (address & buffermask)
 	{
-		LOG_ERROR("Write address at base 0x%" PRIx32 ", address %" PRIx32 " not aligned to 2^%d boundary", 
+		LOG_ERROR("Write address at base 0x%" PRIx32 ", address %" PRIx32 " not aligned to 2^%d boundary",
 			  bank->base, address, cfi_info->max_buf_write_size);
 		return ERROR_FLASH_OPERATION_FAILED;
 	}
@@ -2279,9 +2279,9 @@
 			for (i = 0; i < cfi_info->num_erase_regions; i++)
 			{
 				cfi_info->erase_region_info[i] = cfi_query_u32(bank, 0, 0x2d + (4 * i));
-				LOG_DEBUG("erase region[%i]: %" PRIu32 " blocks of size 0x%" PRIx32 "", 
-					  i, 
-					  (cfi_info->erase_region_info[i] & 0xffff) + 1, 
+				LOG_DEBUG("erase region[%i]: %" PRIu32 " blocks of size 0x%" PRIx32 "",
+					  i,
+					  (cfi_info->erase_region_info[i] & 0xffff) + 1,
 					  (cfi_info->erase_region_info[i] >> 16) * 256);
 			}
 		}

Modified: trunk/src/flash/flash.c
===================================================================
--- trunk/src/flash/flash.c	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/flash/flash.c	2009-06-23 22:49:23 UTC (rev 2379)
@@ -92,7 +92,7 @@
 	retval = bank->driver->write(bank, buffer, offset, count);
 	if (retval != ERROR_OK)
 	{
-		LOG_ERROR("error writing to flash at address 0x%08" PRIx32 " at offset 0x%8.8" PRIx32 " (%d)", 
+		LOG_ERROR("error writing to flash at address 0x%08" PRIx32 " at offset 0x%8.8" PRIx32 " (%d)",
 			  bank->base, offset, retval);
 	}
 
@@ -350,13 +350,13 @@
 			if ((retval = p->driver->auto_probe(p)) != ERROR_OK)
 				return retval;
 
-			command_print(cmd_ctx, 
+			command_print(cmd_ctx,
 				      "#%" PRIi32 " : %s at 0x%8.8" PRIx32 ", size 0x%8.8" PRIx32 ", buswidth %i, chipwidth %i",
 				      i,
-				      p->driver->name, 
-				      p->base, 
-				      p->size, 
-				      p->bus_width, 
+				      p->driver->name,
+				      p->base,
+				      p->size,
+				      p->bus_width,
 				      p->chip_width);
 			for (j = 0; j < p->num_sectors; j++)
 			{
@@ -369,11 +369,11 @@
 				else
 					protect_state = "protection state unknown";
 
-				command_print(cmd_ctx, 
+				command_print(cmd_ctx,
 					      "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
 					      j,
-					      p->sectors[j].offset, 
-					      p->sectors[j].size, 
+					      p->sectors[j].offset,
+					      p->sectors[j].size,
 					      p->sectors[j].size >> 10,
 					      protect_state);
 			}
@@ -462,9 +462,9 @@
 
 			command_print(cmd_ctx,
 				      "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
-				      j, 
-				      p->sectors[j].offset, 
-				      p->sectors[j].size, 
+				      j,
+				      p->sectors[j].offset,
+				      p->sectors[j].size,
 				      p->sectors[j].size >> 10,
 				      erase_state);
 		}
@@ -708,10 +708,10 @@
 	}
 	if (retval == ERROR_OK)
 	{
-		command_print(cmd_ctx, 
+		command_print(cmd_ctx,
 					  "wrote %" PRIu32 " byte from file %s in %s (%f kb/s)",
 					  written,
-					  args[0], 
+					  args[0],
 					  duration_text,
 					  (float)written / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
 	}
@@ -813,7 +813,7 @@
 		{
 			if (readback[i]!=chunk[i])
 			{
-				LOG_ERROR("Verfication error address 0x%08" PRIx32 ", read back 0x%02x, expected 0x%02x", 
+				LOG_ERROR("Verfication error address 0x%08" PRIx32 ", read back 0x%02x, expected 0x%02x",
 						  address + wrote + i, readback[i], chunk[i]);
 				return ERROR_FAIL;
 			}
@@ -831,10 +831,10 @@
 		float speed;
 		speed = wrote / 1024.0;
 		speed/=((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0));
-		command_print(cmd_ctx, 
+		command_print(cmd_ctx,
 					  "wrote %" PRId32 " bytes to 0x%8.8" PRIx32 " in %s (%f kb/s)",
-					  count*wordsize, 
-					  address, 
+					  count*wordsize,
+					  address,
 					  duration_text,
 					  speed);
 	}
@@ -896,12 +896,12 @@
 	}
 	if (retval == ERROR_OK)
 	{
-	command_print(cmd_ctx, 
+	command_print(cmd_ctx,
 				  "wrote  %lld byte from file %s to flash bank %li at offset 0x%8.8" PRIx32 " in %s (%f kb/s)",
-				  fileio.size, 
-				  args[1], 
-				  strtoul(args[0], NULL, 0), 
-				  offset, 
+				  fileio.size,
+				  args[1],
+				  strtoul(args[0], NULL, 0),
+				  offset,
 				  duration_text,
 				  (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
 	}

Modified: trunk/src/flash/flash.h
===================================================================
--- trunk/src/flash/flash.h	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/flash/flash.h	2009-06-23 22:49:23 UTC (rev 2379)
@@ -81,13 +81,13 @@
  */
 typedef struct flash_driver_s
 {
-	/** 
+	/**
 	 * Gives a human-readable name of this flash driver,
 	 * This field is used to select and initialize the driver.
 	 */
 	char *name;
 
-	/** 
+	/**
 	 * Registers driver-specific commands.  When called (during the
 	 * "flash bank" command), the driver may register addition
 	 * commands to support new flash chip functions.
@@ -96,12 +96,12 @@
 	 */
 	int (*register_commands)(struct command_context_s *cmd_ctx);
 
-	/** 
+	/**
 	 * Finish the "flash bank" command for @a bank.  The
 	 * @a bank parameter will have been filled in by the core flash
 	 * layer when this routine is called, and the driver can store
 	 * additional information in its flash_bank_t::driver_priv field.
-	 * 
+	 *
 	 * @param cmd_ctx - the command context
 	 * @param cmd     - the command, in this case 'flash'
 	 * @param args    - parameters, see below
@@ -112,7 +112,7 @@
 	 * @code
 	 * args[0] = bank
 	 * args[1] = drivername {name above}
-	 * args[2] = baseaddress 
+	 * args[2] = baseaddress
 	 * args[3] = lengthbytes
 	 * args[4] = chip_width_in bytes
 	 * args[5] = bus_width_bytes
@@ -129,7 +129,7 @@
 	 */
 	int (*flash_bank_command)(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank);
 
-	/** 
+	/**
 	 * Bank/sector erase routine (target-specific).  When
 	 * called, the flash driver should erase the specified sectors
 	 * using whatever means are at its disposal.
@@ -141,7 +141,7 @@
 	 */
 	int (*erase)(struct flash_bank_s *bank, int first, int last);
 
-	/** 
+	/**
 	 * Bank/sector protection routine (target-specific).
 	 * When called, the driver should disable 'flash write' bits (or
 	 * enable 'erase protection' bits) for the given @a bank and @a
@@ -155,7 +155,7 @@
 	 */
 	int (*protect)(struct flash_bank_s *bank, int set, int first, int last);
 
-	/** 
+	/**
 	 * Program data into the flash.  Note CPU address will be
 	 * "bank->base + offset", while the physical address is
 	 * dependent upon current target MMU mappings.
@@ -168,7 +168,7 @@
 	 */
 	int (*write)(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count);
 
-	/** 
+	/**
 	 * Probe to determine what kind of flash is present.
 	 * This is invoked by the "probe" script command.
 	 *
@@ -176,8 +176,8 @@
 	 * @returns ERROR_OK if successful; otherwise, an error code.
 	 */
 	int (*probe)(struct flash_bank_s *bank);
-	
-	/** 
+
+	/**
 	 * Check the erasure status of a flash bank.
 	 * When called, the driver routine must perform the required
 	 * checks and then set the @c flash_sector_s::is_erased field
@@ -209,7 +209,7 @@
 	 * @param char - where to put the text for the human to read
 	 * @param buf_size - the size of the human buffer.
 	 * @returns ERROR_OK if successful; otherwise, an error code.
-	 */ 
+	 */
 	int (*info)(struct flash_bank_s *bank, char *buf, int buf_size);
 
 	/**
@@ -228,7 +228,7 @@
 	int (*auto_probe)(struct flash_bank_s *bank);
 } flash_driver_t;
 
-/** 
+/**
  * Provides details of a flash bank, available either on-chip or through
  * a major interface.
  *
@@ -276,7 +276,7 @@
 extern int flash_erase_address_range(struct target_s *target, uint32_t addr, uint32_t length);
 /**
  * Writes @a image into the @a target flash.  The @a written parameter
- * will contain the 
+ * will contain the
  * @param target The target with the flash to be programmed.
  * @param image The image that will be programmed to flash.
  * @param written On return, contains the number of bytes written.

Modified: trunk/src/flash/mflash.c
===================================================================
--- trunk/src/flash/mflash.c	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/flash/mflash.c	2009-06-23 22:49:23 UTC (rev 2379)
@@ -474,7 +474,7 @@
 	residue = sect_cnt % 256;
 
 	for (i = 0; i < quotient; i++) {
-		LOG_DEBUG("mflash: sect num : %" PRIu32 " buff : 0x%0lx", sect_num, 
+		LOG_DEBUG("mflash: sect num : %" PRIu32 " buff : 0x%0lx", sect_num,
 			(unsigned long)buff_ptr);
 		ret = mg_mflash_do_read_sects(buff_ptr, sect_num, 256);
 		if (ret != ERROR_OK)
@@ -485,7 +485,7 @@
 	}
 
 	if (residue) {
-		LOG_DEBUG("mflash: sect num : %" PRIx32 " buff : %0lx", sect_num, 
+		LOG_DEBUG("mflash: sect num : %" PRIx32 " buff : %0lx", sect_num,
 			(unsigned long)buff_ptr);
 		return mg_mflash_do_read_sects(buff_ptr, sect_num, residue);
 	}
@@ -517,7 +517,7 @@
 		ret = target_write_memory(target, address, 2, MG_MFLASH_SECTOR_SIZE / 2, buff_ptr);
 		if (ret != ERROR_OK)
 			return ret;
-		
+
 		buff_ptr += MG_MFLASH_SECTOR_SIZE;
 
 		ret = target_write_u8(target, mflash_bank->base + MG_REG_OFFSET + MG_REG_COMMAND, mg_io_cmd_confirm_write);
@@ -552,7 +552,7 @@
 	residue = sect_cnt % 256;
 
 	for (i = 0; i < quotient; i++) {
-		LOG_DEBUG("mflash: sect num : %" PRIu32 "buff : %p", sect_num, 
+		LOG_DEBUG("mflash: sect num : %" PRIu32 "buff : %p", sect_num,
 			buff_ptr);
 		ret = mg_mflash_do_write_sects(buff_ptr, sect_num, 256, mg_io_cmd_write);
 		if (ret != ERROR_OK)
@@ -563,7 +563,7 @@
 	}
 
 	if (residue) {
-		LOG_DEBUG("mflash: sect num : %" PRIu32 " buff : %p", sect_num, 
+		LOG_DEBUG("mflash: sect num : %" PRIu32 " buff : %p", sect_num,
 			buff_ptr);
 		return mg_mflash_do_write_sects(buff_ptr, sect_num, residue, mg_io_cmd_write);
 	}
@@ -741,10 +741,10 @@
 			goto mg_write_cmd_err;
 		address += MG_FILEIO_CHUNK;
 	}
- 
+
 	if (res) {
 		if ((ret = fileio_read(&fileio, res, buffer, &buf_cnt)) != ERROR_OK)
-			goto mg_write_cmd_err;			
+			goto mg_write_cmd_err;
 		if ((ret = mg_mflash_write(address, buffer, res)) != ERROR_OK)
 			goto mg_write_cmd_err;
 	}
@@ -789,7 +789,7 @@
 	ret = fileio_open(&fileio, args[1], FILEIO_WRITE, FILEIO_BINARY);
 	if (ret != ERROR_OK)
 		return ret;
- 
+
 	buffer = malloc(MG_FILEIO_CHUNK);
 	if (!buffer) {
 		fileio_close(&fileio);
@@ -798,7 +798,7 @@
 
 	cnt = size / MG_FILEIO_CHUNK;
 	res = size % MG_FILEIO_CHUNK;
- 
+
 	duration_start_measure(&duration);
 
 	for (i = 0; i < cnt; i++) {
@@ -809,7 +809,7 @@
 			goto mg_dump_cmd_err;
 		address += MG_FILEIO_CHUNK;
 	}
- 
+
 	if (res) {
 		if ((ret = mg_mflash_read(address, buffer, res)) != ERROR_OK)
 			goto mg_dump_cmd_err;
@@ -834,8 +834,8 @@
 	free(duration_text);
  	free(buffer);
 	fileio_close(&fileio);
- 
-	return ret;	
+
+	return ret;
 }
 
 static int mg_set_feature(mg_feature_id feature, mg_feature_val config)
@@ -1229,7 +1229,7 @@
 
 	switch (argc) {
 		case 2:
-			if (!strcmp(args[1], "boot")) 
+			if (!strcmp(args[1], "boot"))
 				return mg_boot_config();
 			else if (!strcmp(args[1], "storage"))
 				return mg_storage_config();
@@ -1252,7 +1252,7 @@
 					return ERROR_MG_INVALID_PLL;
 				}
 
-				LOG_INFO("mflash: Fout=%" PRIu32 " Hz, feedback=%u," 
+				LOG_INFO("mflash: Fout=%" PRIu32 " Hz, feedback=%u,"
 						"indiv=%u, outdiv=%u, lock=%u",
 						(uint32_t)fout, pll.feedback_div,
 						pll.input_div, pll.output_div,

Modified: trunk/src/flash/nand.c
===================================================================
--- trunk/src/flash/nand.c	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/flash/nand.c	2009-06-23 22:49:23 UTC (rev 2379)
@@ -1138,12 +1138,12 @@
 				else
 					bad_state = " (block condition unknown)";
 
-				command_print(cmd_ctx, 
+				command_print(cmd_ctx,
 					      "\t#%i: 0x%8.8" PRIx32 " (%" PRId32 "kB) %s%s",
 					      j,
-					      p->blocks[j].offset, 
+					      p->blocks[j].offset,
 					      p->blocks[j].size / 1024,
-					      erase_state, 
+					      erase_state,
 					      bad_state);
 			}
 		}

Modified: trunk/src/flash/ocl/at91sam7x/samflash.c
===================================================================
--- trunk/src/flash/ocl/at91sam7x/samflash.c	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/flash/ocl/at91sam7x/samflash.c	2009-06-23 22:49:23 UTC (rev 2379)
@@ -174,7 +174,7 @@
 int flash_erase_all(void)
 {
 	int result;
-	
+
 	if ((result = flash_erase_plane(0)) != FLASH_STAT_OK) return result;
 
 	/* the second flash controller, if any */

Modified: trunk/src/flash/pic32mx.c
===================================================================
--- trunk/src/flash/pic32mx.c	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/flash/pic32mx.c	2009-06-23 22:49:23 UTC (rev 2379)
@@ -603,10 +603,10 @@
 	pic32mx_info->probed = 0;
 
 	device_id = ejtag_info->idcode;
-	LOG_INFO("device id = 0x%08" PRIx32 " (manuf 0x%03x dev 0x%02x, ver 0x%03x)", 
+	LOG_INFO("device id = 0x%08" PRIx32 " (manuf 0x%03x dev 0x%02x, ver 0x%03x)",
 			  device_id,
-			  (unsigned)((device_id >> 1)&0x7ff), 
-			  (unsigned)((device_id >> 12)&0xff), 
+			  (unsigned)((device_id >> 1)&0x7ff),
+			  (unsigned)((device_id >> 12)&0xff),
 			  (unsigned)((device_id >> 20)&0xfff));
 
 	if (((device_id >> 1)&0x7ff) != PIC32MX_MANUF_ID) {
@@ -698,9 +698,9 @@
 	device_id = ejtag_info->idcode;
 
 	if (((device_id >> 1)&0x7ff) != PIC32MX_MANUF_ID) {
-		snprintf(buf, buf_size, 
-				 "Cannot identify target as a PIC32MX family (manufacturer 0x%03d != 0x%03d)\n", 
-				 (unsigned)((device_id >> 1)&0x7ff), 
+		snprintf(buf, buf_size,
+				 "Cannot identify target as a PIC32MX family (manufacturer 0x%03d != 0x%03d)\n",
+				 (unsigned)((device_id >> 1)&0x7ff),
 				 PIC32MX_MANUF_ID);
 		return ERROR_FLASH_OPERATION_FAILED;
 	}
@@ -715,7 +715,7 @@
 	}
 	buf += printed;
 	buf_size -= printed;
-	printed = snprintf(buf, buf_size, "  Ver: 0x%03x", 
+	printed = snprintf(buf, buf_size, "  Ver: 0x%03x",
 					   (unsigned)((device_id >> 20)&0xfff));
 
 	return ERROR_OK;

Modified: trunk/src/flash/stellaris.c
===================================================================
--- trunk/src/flash/stellaris.c	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/flash/stellaris.c	2009-06-23 22:49:23 UTC (rev 2379)
@@ -292,32 +292,32 @@
 	{
 		device_class = 0;
 	}
-	printed = snprintf(buf, 
+	printed = snprintf(buf,
 			   buf_size,
 			   "\nLMI Stellaris information: Chip is class %i(%s) %s v%c.%i\n",
-			   device_class, 
-			   StellarisClassname[device_class], 
+			   device_class,
+			   StellarisClassname[device_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, 
+	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->did1,
+			   stellaris_info->did1,
+			   "ARMV7M",
 			   (int)((1 + ((stellaris_info->dc0 >> 16) & 0xFFFF))/4),
 			   (int)((1 + (stellaris_info->dc0 & 0xFFFF))*2));
 	buf += printed;
 	buf_size -= printed;
 
-	printed = snprintf(buf, 
+	printed = snprintf(buf,
 			   buf_size,
 			   "master clock(estimated): %ikHz, rcc is 0x%" PRIx32 " \n",
-			   (int)(stellaris_info->mck_freq / 1000), 
+			   (int)(stellaris_info->mck_freq / 1000),
 			   stellaris_info->rcc);
 	buf += printed;
 	buf_size -= printed;
@@ -326,9 +326,9 @@
 	{
 		printed = snprintf(buf,
 				   buf_size,
-				   "pagesize: %" PRIi32 ", lockbits: %i 0x%4.4" PRIx32 ", pages in lock region: %i \n", 
-				   stellaris_info->pagesize, 
-				   stellaris_info->num_lockbits, 
+				   "pagesize: %" PRIi32 ", lockbits: %i 0x%4.4" PRIx32 ", pages in lock region: %i \n",
+				   stellaris_info->pagesize,
+				   stellaris_info->num_lockbits,
 				   stellaris_info->lockbits,
 				   (int)(stellaris_info->num_pages/stellaris_info->num_lockbits));
 		buf += printed;

Modified: trunk/src/flash/str7x.c
===================================================================
--- trunk/src/flash/str7x.c	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/flash/str7x.c	2009-06-23 22:49:23 UTC (rev 2379)
@@ -75,10 +75,10 @@
 static int str7x_register_commands(struct command_context_s *cmd_ctx)
 {
 	command_t *str7x_cmd = register_command(cmd_ctx, NULL, "str7x", NULL, COMMAND_ANY, NULL);
-	
+
 	register_command(cmd_ctx, str7x_cmd, "disable_jtag", str7x_handle_disable_jtag_command, COMMAND_EXEC,
 					 "disable jtag access");
-					 
+
 	return ERROR_OK;
 }
 
@@ -95,7 +95,7 @@
 	int i;
 	int num_sectors;
 	int b0_sectors = 0, b1_sectors = 0;
-		
+
 	switch (bank->size)
 	{
 		case 16 * 1024:
@@ -114,15 +114,15 @@
 			LOG_ERROR("BUG: unknown bank->size encountered");
 			exit(-1);
 	}
-		
+
 	num_sectors = b0_sectors + b1_sectors;
-	
+
 	bank->num_sectors = num_sectors;
 	bank->sectors = malloc(sizeof(flash_sector_t) * num_sectors);
 	str7x_info->sector_bits = malloc(sizeof(uint32_t) * num_sectors);
-	
+
 	num_sectors = 0;
-	
+
 	for (i = 0; i < b0_sectors; i++)
 	{
 		bank->sectors[num_sectors].offset = mem_layout_str7bank0[i].sector_start;
@@ -131,7 +131,7 @@
 		bank->sectors[num_sectors].is_protected = 1;
 		str7x_info->sector_bits[num_sectors++] = mem_layout_str7bank0[i].sector_bit;
 	}
-	
+
 	for (i = 0; i < b1_sectors; i++)
 	{
 		bank->sectors[num_sectors].offset = mem_layout_str7bank1[i].sector_start;
@@ -140,7 +140,7 @@
 		bank->sectors[num_sectors].is_protected = 1;
 		str7x_info->sector_bits[num_sectors++] = mem_layout_str7bank1[i].sector_bit;
 	}
-	
+
 	return ERROR_OK;
 }
 
@@ -149,20 +149,20 @@
 static int str7x_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank)
 {
 	str7x_flash_bank_t *str7x_info;
-	
+
 	if (argc < 7)
 	{
 		LOG_WARNING("incomplete flash_bank str7x configuration");
 		return ERROR_FLASH_BANK_INVALID;
 	}
-	
+
 	str7x_info = malloc(sizeof(str7x_flash_bank_t));
 	bank->driver_priv = str7x_info;
-	
+
 	/* set default bits for str71x flash */
 	str7x_info->busy_bits = (FLASH_LOCK | FLASH_BSYA1 | FLASH_BSYA0);
 	str7x_info->disable_bit = (1 << 1);
-	
+
 	if (strcmp(args[6], "STR71x") == 0)
 	{
 		str7x_info->register_base = 0x40100000;
@@ -185,9 +185,9 @@
 	}
 
 	str7x_build_block_list(bank);
-	
+
 	str7x_info->write_algorithm = NULL;
-	
+
 	return ERROR_OK;
 }
 
@@ -207,7 +207,7 @@
 	uint32_t retval;
 
 	target_read_u32(target, str7x_get_flash_adr(bank, FLASH_ER), &retval);
-	
+
 	return retval;
 }
 
@@ -215,7 +215,7 @@
 {
 	str7x_flash_bank_t *str7x_info = bank->driver_priv;
 	target_t *target = bank->target;
-	
+
 	int i;
 	uint32_t retval;
 
@@ -242,12 +242,12 @@
 {
 	str7x_flash_bank_t *str7x_info = bank->driver_priv;
 	target_t *target = bank->target;
-	
+
 	int i;
 	uint32_t cmd;
 	uint32_t retval;
 	uint32_t sectors = 0;
-	
+
 	if (bank->target->state != TARGET_HALTED)
 	{
 		LOG_ERROR("Target not halted");
@@ -258,33 +258,33 @@
 	{
 		sectors |= str7x_info->sector_bits[i];
 	}
-	
+
 	LOG_DEBUG("sectors: 0x%" PRIx32 "", sectors);
-	
-	/* clear FLASH_ER register */	
+
+	/* clear FLASH_ER register */
 	target_write_u32(target, str7x_get_flash_adr(bank, FLASH_ER), 0x0);
-	
+
 	cmd = FLASH_SER;
 	target_write_u32(target, str7x_get_flash_adr(bank, FLASH_CR0), cmd);
-	
+
 	cmd = sectors;
 	target_write_u32(target, str7x_get_flash_adr(bank, FLASH_CR1), cmd);
-	
+
 	cmd = FLASH_SER | FLASH_WMS;
 	target_write_u32(target, str7x_get_flash_adr(bank, FLASH_CR0), cmd);
-	
+
 	while (((retval = str7x_status(bank)) & str7x_info->busy_bits)) {
 		alive_sleep(1);
 	}
-	
+
 	retval = str7x_result(bank);
-	
+
 	if (retval)
 	{
 		LOG_ERROR("error erasing flash bank, FLASH_ER: 0x%" PRIx32 "", retval);
 		return ERROR_FLASH_OPERATION_FAILED;
 	}
-	
+
 	for (i = first; i <= last; i++)
 		bank->sectors[i].is_erased = 1;
 
@@ -299,13 +299,13 @@
 	uint32_t cmd;
 	uint32_t retval;
 	uint32_t protect_blocks;
-	
+
 	if (bank->target->state != TARGET_HALTED)
 	{
 		LOG_ERROR("Target not halted");
 		return ERROR_TARGET_NOT_HALTED;
 	}
-	
+
 	protect_blocks = 0xFFFFFFFF;
 
 	if (set)
@@ -313,30 +313,30 @@
 		for (i = first; i <= last; i++)
 			protect_blocks &= ~(str7x_info->sector_bits[i]);
 	}
-	
-	/* clear FLASH_ER register */	
+
+	/* clear FLASH_ER register */
 	target_write_u32(target, str7x_get_flash_adr(bank, FLASH_ER), 0x0);
 
 	cmd = FLASH_SPR;
 	target_write_u32(target, str7x_get_flash_adr(bank, FLASH_CR0), cmd);
-	
+
 	cmd = str7x_get_flash_adr(bank, FLASH_NVWPAR);
 	target_write_u32(target, str7x_get_flash_adr(bank, FLASH_AR), cmd);
-	
+
 	cmd = protect_blocks;
 	target_write_u32(target, str7x_get_flash_adr(bank, FLASH_DR0), cmd);
-	
+
 	cmd = FLASH_SPR | FLASH_WMS;
 	target_write_u32(target, str7x_get_flash_adr(bank, FLASH_CR0), cmd);
-	
+
 	while (((retval = str7x_status(bank)) & str7x_info->busy_bits)) {
 		alive_sleep(1);
 	}
-	
+
 	retval = str7x_result(bank);
-	
+
 	LOG_DEBUG("retval: 0x%8.8" PRIx32 "", retval);
-	
+
 	if (retval & FLASH_ERER)
 		return ERROR_FLASH_SECTOR_NOT_ERASED;
 	else if (retval & FLASH_WPF)
@@ -355,7 +355,7 @@
 	reg_param_t reg_params[6];
 	armv4_5_algorithm_t armv4_5_info;
 	int retval = ERROR_OK;
-	
+
 	uint32_t str7x_flash_write_code[] = {
 					/* write:				*/
 		0xe3a04201, /*	mov r4, #0x10000000	*/
@@ -381,14 +381,14 @@
 					/* exit:				*/
 		0xeafffffe, /*	b exit				*/
 	};
-	
+
 	/* flash write code */
 	if (target_alloc_working_area(target, 4 * 20, &str7x_info->write_algorithm) != ERROR_OK)
 	{
 		LOG_WARNING("no working area available, can't do block memory writes");
 		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 	};
-	
+
 	target_write_buffer(target, str7x_info->write_algorithm->address, 20 * 4, (uint8_t*)str7x_flash_write_code);
 
 	/* memory buffer */
@@ -400,63 +400,63 @@
 			/* if we already allocated the writing code, but failed to get a buffer, free the algorithm */
 			if (str7x_info->write_algorithm)
 				target_free_working_area(target, str7x_info->write_algorithm);
-			
+
 			LOG_WARNING("no large enough working area available, can't do block memory writes");
 			return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 		}
 	}
-	
+
 	armv4_5_info.common_magic = ARMV4_5_COMMON_MAGIC;
 	armv4_5_info.core_mode = ARMV4_5_MODE_SVC;
 	armv4_5_info.core_state = ARMV4_5_STATE_ARM;
-	
+
 	init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
 	init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
 	init_reg_param(&reg_params[2], "r2", 32, PARAM_OUT);
 	init_reg_param(&reg_params[3], "r3", 32, PARAM_OUT);
 	init_reg_param(&reg_params[4], "r4", 32, PARAM_IN);
 	init_reg_param(&reg_params[5], "r5", 32, PARAM_OUT);
-	
+
 	while (count > 0)
 	{
 		uint32_t thisrun_count = (count > (buffer_size / 8)) ? (buffer_size / 8) : count;
-		
+
 		target_write_buffer(target, source->address, thisrun_count * 8, buffer);
-		
+
 		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, str7x_get_flash_adr(bank, FLASH_CR0));
 		buf_set_u32(reg_params[3].value, 0, 32, thisrun_count);
 		buf_set_u32(reg_params[5].value, 0, 32, str7x_info->busy_bits);
-	
+
 		if ((retval = target_run_algorithm(target, 0, NULL, 6, reg_params, str7x_info->write_algorithm->address, str7x_info->write_algorithm->address + (19 * 4), 10000, &armv4_5_info)) != ERROR_OK)
 		{
 			LOG_ERROR("error executing str7x flash write algorithm");
 			retval = ERROR_FLASH_OPERATION_FAILED;
 			break;
 		}
-	
+
 		if (buf_get_u32(reg_params[4].value, 0, 32) != 0x00)
 		{
 			retval = ERROR_FLASH_OPERATION_FAILED;
 			break;
 		}
-		
+
 		buffer += thisrun_count * 8;
 		address += thisrun_count * 8;
 		count -= thisrun_count;
 	}
-	
+
 	target_free_working_area(target, source);
 	target_free_working_area(target, str7x_info->write_algorithm);
-	
+
 	destroy_reg_param(&reg_params[0]);
 	destroy_reg_param(&reg_params[1]);
 	destroy_reg_param(&reg_params[2]);
 	destroy_reg_param(&reg_params[3]);
 	destroy_reg_param(&reg_params[4]);
 	destroy_reg_param(&reg_params[5]);
-	
+
 	return retval;
 }
 
@@ -472,7 +472,7 @@
 	int retval;
 	uint32_t check_address = offset;
 	int i;
-	
+
 	if (bank->target->state != TARGET_HALTED)
 	{
 		LOG_ERROR("Target not halted");
@@ -484,12 +484,12 @@
 		LOG_WARNING("offset 0x%" PRIx32 " breaks required 8-byte alignment", offset);
 		return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
 	}
-	
+
 	for (i = 0; i < bank->num_sectors; i++)
 	{
 		uint32_t sec_start = bank->sectors[i].offset;
 		uint32_t sec_end = sec_start + bank->sectors[i].size;
-		
+
 		/* check if destination falls within the current sector */
 		if ((check_address >= sec_start) && (check_address < sec_end))
 		{
@@ -500,15 +500,15 @@
 				check_address = sec_end;
 		}
 	}
-	
+
 	if (check_address != offset + count)
 		return ERROR_FLASH_DST_OUT_OF_BANK;
-		
-	/* clear FLASH_ER register */	
+
+	/* clear FLASH_ER register */
 	target_write_u32(target, str7x_get_flash_adr(bank, FLASH_ER), 0x0);
 
 	/* multiple dwords (8-byte) to be programmed? */
-	if (dwords_remaining > 0) 
+	if (dwords_remaining > 0)
 	{
 		/* try using a block write */
 		if ((retval = str7x_write_block(bank, buffer, offset, dwords_remaining)) != ERROR_OK)
@@ -516,14 +516,14 @@
 			if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
 			{
 				/* if block write failed (no sufficient working area),
-				 * we use normal (slow) single dword accesses */ 
+				 * we use normal (slow) single dword accesses */
 				LOG_WARNING("couldn't use block writes, falling back to single memory accesses");
 			}
 			else if (retval == ERROR_FLASH_OPERATION_FAILED)
 			{
 				/* if an error occured, we examine the reason, and quit */
 				retval = str7x_result(bank);
-				
+
 				LOG_ERROR("flash writing failed with error code: 0x%x", retval);
 				return ERROR_FLASH_OPERATION_FAILED;
 			}
@@ -541,29 +541,29 @@
 		/* command */
 		cmd = FLASH_DWPG;
 		target_write_u32(target, str7x_get_flash_adr(bank, FLASH_CR0), cmd);
-		
+
 		/* address */
 		target_write_u32(target, str7x_get_flash_adr(bank, FLASH_AR), address);
-		
+
 		/* data word 1 */
 		target_write_memory(target, str7x_get_flash_adr(bank, FLASH_DR0), 4, 1, buffer + bytes_written);
 		bytes_written += 4;
-		
+
 		/* data word 2 */
 		target_write_memory(target, str7x_get_flash_adr(bank, FLASH_DR1), 4, 1, buffer + bytes_written);
 		bytes_written += 4;
-		
+
 		/* start programming cycle */
 		cmd = FLASH_DWPG | FLASH_WMS;
 		target_write_u32(target, str7x_get_flash_adr(bank, FLASH_CR0), cmd);
-		
+
 		while (((retval = str7x_status(bank)) & str7x_info->busy_bits))
 		{
 			alive_sleep(1);
 		}
-		
+
 		retval = str7x_result(bank);
-		
+
 		if (retval & FLASH_PGER)
 			return ERROR_FLASH_OPERATION_FAILED;
 		else if (retval & FLASH_WPF)
@@ -572,51 +572,51 @@
 		dwords_remaining--;
 		address += 8;
 	}
-	
+
 	if (bytes_remaining)
 	{
 		uint8_t last_dword[8] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 		int i = 0;
-				
+
 		while (bytes_remaining > 0)
 		{
-			last_dword[i++] = *(buffer + bytes_written); 
+			last_dword[i++] = *(buffer + bytes_written);
 			bytes_remaining--;
 			bytes_written++;
 		}
-		
+
 		/* command */
 		cmd = FLASH_DWPG;
 		target_write_u32(target, str7x_get_flash_adr(bank, FLASH_CR0), cmd);
-		
+
 		/* address */
 		target_write_u32(target, str7x_get_flash_adr(bank, FLASH_AR), address);
-		
+
 		/* data word 1 */
 		target_write_memory(target, str7x_get_flash_adr(bank, FLASH_DR0), 4, 1, last_dword);
 		bytes_written += 4;
-		
+
 		/* data word 2 */
 		target_write_memory(target, str7x_get_flash_adr(bank, FLASH_DR1), 4, 1, last_dword + 4);
 		bytes_written += 4;
-		
+
 		/* start programming cycle */
 		cmd = FLASH_DWPG | FLASH_WMS;
 		target_write_u32(target, str7x_get_flash_adr(bank, FLASH_CR0), cmd);
-		
+
 		while (((retval = str7x_status(bank)) & str7x_info->busy_bits))
 		{
 			alive_sleep(1);
 		}
-		
+
 		retval = str7x_result(bank);
-		
+
 		if (retval & FLASH_PGER)
 			return ERROR_FLASH_OPERATION_FAILED;
 		else if (retval & FLASH_WPF)
 			return ERROR_FLASH_OPERATION_FAILED;
 	}
-		
+
 	return ERROR_OK;
 }
 
@@ -643,35 +643,35 @@
 	flash_bank_t *bank;
 	target_t *target = NULL;
 	str7x_flash_bank_t *str7x_info = NULL;
-	
+
 	uint32_t flash_cmd;
 	uint32_t retval;
 	uint16_t ProtectionLevel = 0;
 	uint16_t ProtectionRegs;
-	
+
 	if (argc < 1)
 	{
 		command_print(cmd_ctx, "str7x disable_jtag <bank>");
-		return ERROR_OK;	
+		return ERROR_OK;
 	}
-	
+
 	bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
 	if (!bank)
 	{
 		command_print(cmd_ctx, "str7x disable_jtag <bank> ok");
 		return ERROR_OK;
 	}
-	
+
 	str7x_info = bank->driver_priv;
-	
+
 	target = bank->target;
-	
+
 	if (target->state != TARGET_HALTED)
 	{
 		LOG_ERROR("Target not halted");
 		return ERROR_TARGET_NOT_HALTED;
 	}
-	
+
 	/* first we get protection status */
 	target_read_u32(target, str7x_get_flash_adr(bank, FLASH_NVAPR0), &retval);
 
@@ -679,7 +679,7 @@
 	{
 		ProtectionLevel = 1;
 	}
-	
+
 	target_read_u32(target, str7x_get_flash_adr(bank, FLASH_NVAPR1), &retval);
 	ProtectionRegs = ~(retval >> 16);
 
@@ -688,7 +688,7 @@
 		ProtectionRegs >>= 1;
 		ProtectionLevel++;
 	}
-	
+
 	if (ProtectionLevel == 0)
 	{
 		flash_cmd = FLASH_SPR;
@@ -707,6 +707,6 @@
 		flash_cmd = FLASH_SPR | FLASH_WMS;
 		target_write_u32(target, str7x_get_flash_adr(bank, FLASH_CR0), flash_cmd);
 	}
-	
+
 	return ERROR_OK;
 }

Modified: trunk/src/flash/tms470.c
===================================================================
--- trunk/src/flash/tms470.c	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/flash/tms470.c	2009-06-23 22:49:23 UTC (rev 2379)
@@ -49,7 +49,7 @@
 	.info = tms470_info
 };
 
-/* ---------------------------------------------------------------------- 
+/* ----------------------------------------------------------------------
                       Internal Support, Helpers
    ---------------------------------------------------------------------- */
 
@@ -288,10 +288,10 @@
 	bank->chip_width = 32;
 	bank->bus_width = 32;
 
-	LOG_INFO("Identified %s, ver=%d, core=%s, nvmem=%s.", 
+	LOG_INFO("Identified %s, ver=%d, core=%s, nvmem=%s.",
 		 part_name,
 		 (int)(silicon_version),
-		 (technology_family ? "1.8v" : "3.3v"), 
+		 (technology_family ? "1.8v" : "3.3v"),
 		 (rom_flash ? "rom" : "flash"));
 
 	tms470_info->device_ident_reg = device_ident_reg;
@@ -347,7 +347,7 @@
 
 	if (keysSet)
 	{
-		command_print(cmd_ctx, "using flash keys 0x%08" PRIx32 ", 0x%08" PRIx32 ", 0x%08" PRIx32 ", 0x%08" PRIx32 "", 
+		command_print(cmd_ctx, "using flash keys 0x%08" PRIx32 ", 0x%08" PRIx32 ", 0x%08" PRIx32 ", 0x%08" PRIx32 "",
 			      flashKeys[0], flashKeys[1], flashKeys[2], flashKeys[3]);
 	}
 	else
@@ -488,7 +488,7 @@
 
 		if (ERROR_OK == tms470_check_flash_unlocked(target))
 		{
-			/* 
+			/*
 			 * There seems to be a side-effect of reading the FMPKEY
 			 * register in that it re-enables the protection.  So we
 			 * re-enable it.
@@ -754,7 +754,7 @@
 	uint32_t flashAddr = bank->base + bank->sectors[sector].offset;
 	int result = ERROR_OK;
 
-	/* 
+	/*
 	 * Set the bit GLBCTRL4 of the GLBCTRL register (in the System
 	 * module) to enable writing to the flash registers }.
 	 */
@@ -787,8 +787,8 @@
 	}
 	bank->sectors[sector].is_protected = 0;
 
-	/* 
-	 * clear status regiser, sent erase command, kickoff erase 
+	/*
+	 * clear status regiser, sent erase command, kickoff erase
 	 */
 	target_write_u16(target, flashAddr, 0x0040);
 	LOG_DEBUG("write *(uint16_t *)0x%08" PRIx32 "=0x0040", flashAddr);
@@ -838,7 +838,7 @@
 	return result;
 }
 
-/* ---------------------------------------------------------------------- 
+/* ----------------------------------------------------------------------
               Implementation of Flash Driver Interfaces
    ---------------------------------------------------------------------- */
 
@@ -1115,7 +1115,7 @@
 	target_read_u32(target, 0xFFE88004, &fmbac2);
 	target_write_u32(target, 0xFFE88004, fmbac2 | 0xff);
 
-	/* 
+	/*
 	 * The TI primitives inspect the flash memory by reading one 32-bit
 	 * word at a time.  Here we read an entire sector and inspect it in
 	 * an attempt to reduce the JTAG overhead.

Modified: trunk/src/target/algorithm.h
===================================================================
--- trunk/src/target/algorithm.h	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/target/algorithm.h	2009-06-23 22:49:23 UTC (rev 2379)
@@ -35,7 +35,7 @@
 	uint32_t size;
 	uint8_t *value;
 	enum param_direction direction;
-} mem_param_t; 
+} mem_param_t;
 
 typedef struct reg_param_s
 {

Modified: trunk/src/target/arm11.c
===================================================================
--- trunk/src/target/arm11.c	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/target/arm11.c	2009-06-23 22:49:23 UTC (rev 2379)
@@ -1888,7 +1888,7 @@
 		if (values[i] > arm11_coproc_instruction_limits[i])
 		{
 			LOG_ERROR("Parameter %ld out of bounds (%" PRId32 " max). %s",
-				  (long)(i + 2), 
+				  (long)(i + 2),
 				  arm11_coproc_instruction_limits[i],
 				read ? arm11_mrc_syntax : arm11_mcr_syntax);
 			return -1;
@@ -1913,10 +1913,10 @@
 		arm11_run_instr_data_from_core_via_r0(arm11, instr, &result);
 
 		LOG_INFO("MRC p%d, %d, R0, c%d, c%d, %d = 0x%08" PRIx32 " (%" PRId32 ")",
-			 (int)(values[0]), 
-			 (int)(values[1]), 
-			 (int)(values[2]), 
-			 (int)(values[3]), 
+			 (int)(values[0]),
+			 (int)(values[1]),
+			 (int)(values[2]),
+			 (int)(values[3]),
 			 (int)(values[4]), result, result);
 	}
 	else

Modified: trunk/src/target/arm926ejs.h
===================================================================
--- trunk/src/target/arm926ejs.h	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/target/arm926ejs.h	2009-06-23 22:49:23 UTC (rev 2379)
@@ -39,9 +39,9 @@
 } arm926ejs_common_t;
 
 extern int arm926ejs_init_arch_info(target_t *target, arm926ejs_common_t *arm926ejs, jtag_tap_t *tap);
-extern int arm926ejs_register_commands(struct command_context_s *cmd_ctx); 
-extern int arm926ejs_arch_state(struct target_s *target); 
-extern int arm926ejs_write_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer); 
+extern int arm926ejs_register_commands(struct command_context_s *cmd_ctx);
+extern int arm926ejs_arch_state(struct target_s *target);
+extern int arm926ejs_write_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
 extern int arm926ejs_soft_reset_halt(struct target_s *target);
 
 #endif /* ARM926EJS_H */

Modified: trunk/src/target/arm9tdmi.h
===================================================================
--- trunk/src/target/arm9tdmi.h	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/target/arm9tdmi.h	2009-06-23 22:49:23 UTC (rev 2379)
@@ -59,7 +59,7 @@
 
 extern int arm9tdmi_clock_out(arm_jtag_t *jtag_info, uint32_t instr, uint32_t out, uint32_t *in, int sysspeed);
 extern int arm9tdmi_clock_data_in(arm_jtag_t *jtag_info, uint32_t *in);
-extern int arm9tdmi_clock_data_in_endianness(arm_jtag_t *jtag_info, void *in, int size, int be); 
+extern int arm9tdmi_clock_data_in_endianness(arm_jtag_t *jtag_info, void *in, int size, int be);
 extern void arm9tdmi_read_core_regs(target_t *target, uint32_t mask, uint32_t* core_regs[16]);
 extern void arm9tdmi_write_core_regs(target_t *target, uint32_t mask, uint32_t core_regs[16]);
 

Modified: trunk/src/target/arm_adi_v5.h
===================================================================
--- trunk/src/target/arm_adi_v5.h	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/target/arm_adi_v5.h	2009-06-23 22:49:23 UTC (rev 2379)
@@ -104,7 +104,7 @@
 
 } swjdp_common_t;
 
-/* Accessor function for currently selected DAP-AP number */ 
+/* Accessor function for currently selected DAP-AP number */
 static inline uint8_t dap_ap_get_select(swjdp_common_t *swjdp)
 {
 	return (uint8_t)(swjdp ->apsel >> 24);

Modified: trunk/src/target/arm_disassembler.c
===================================================================
--- trunk/src/target/arm_disassembler.c	2009-06-23 22:49:06 UTC (rev 2378)
+++ trunk/src/target/arm_disassembler.c	2009-06-23 22:49:23 UTC (rev 2379)
@@ -33,9 +33,9 @@
 };
 
 /* make up for C's missing ROR */
-uint32_t ror(uint32_t value, int places) 
-{ 
-	return (value >> places) | (value << (32 - places)); 
+uint32_t ror(uint32_t value, int places)
+{
+	return (value >> places) | (value << (32 - places));
 }
 
 int evaluate_pld(uint32_t opcode, uint32_t address, arm_instruction_t *instruction)
@@ -44,9 +44,9 @@
 	if ((opcode & 0x0d70f0000) == 0x0550f000)
 	{
 		instruction->type = ARM_PLD;
-		
+
 		snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tPLD ...TODO...", address, opcode);
-		
+
 		return ERROR_OK;
 	}
 	else
@@ -54,7 +54,7 @@
 		instruction->type = ARM_UNDEFINED_INSTRUCTION;
 		return ERROR_OK;
 	}
-	
+
 	LOG_ERROR("should never reach this point");
 	return -1;
 }
@@ -62,9 +62,9 @@
 int evaluate_swi(uint32_t opcode, uint32_t address, arm_instruction_t *instruction)
 {
 	instruction->type = ARM_SWI;
-	
+
 	snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tSWI 0x%6.6" PRIx32 "", address, opcode, (opcode & 0xffffff));
-	
+
 	return ERROR_OK;
 }
 
@@ -73,30 +73,30 @@
 	int offset;
 	uint32_t immediate;
 	uint32_t target_address;
-	
+
 	instruction->type = ARM_BLX;
 	immediate = opcode & 0x00ffffff;
-	
+
 	/* sign extend 24-bit immediate */
 	if (immediate & 0x00800000)
 		offset = 0xff000000 | immediate;
 	else
 		offset = immediate;
-	
+
 	/* shift two bits left */
 	offset <<= 2;
-	
+
 	/* odd/event halfword */
 	if (opcode & 0x01000000)
 		offset |= 0x2;
-	
+
 	target_address = address + 8 + offset;
-	
+
 	snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tBLX 0x%8.8" PRIx32 "", address, opcode, target_address);
-	
+
 	instruction->info.b_bl_bx_blx.reg_operand = -1;
 	instruction->info.b_bl_bx_blx.target_address = target_address;
-	
+
 	return ERROR_OK;
 }
 
@@ -106,32 +106,32 @@
 	uint32_t immediate;
 	int offset;
 	uint32_t target_address;
-	
+
 	immediate = opcode & 0x00ffffff;
 	L = (opcode & 0x01000000) >> 24;
-	
+
 	/* sign extend 24-bit immediate */
 	if (immediate & 0x00800000)
 		offset = 0xff000000 | immediate;
 	else
 		offset = immediate;
-	
+
 	/* shift two bits left */
 	offset <<= 2;
-	
+
 	target_address = address + 8 + offset;
 
 	if (L)
 		instruction->type = ARM_BL;
 	else
 		instruction->type = ARM_B;
-	
+
 	snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tB%s%s 0x%8.8" PRIx32 , address, opcode,
 			 (L) ? "L" : "", COND(opcode), target_address);
-	
+
 	instruction->info.b_bl_bx_blx.reg_operand = -1;
 	instruction->info.b_bl_bx_blx.target_address = target_address;
-	
+
 	return ERROR_OK;
 }
 
@@ -140,32 +140,32 @@
 int evaluate_ldc_stc_mcrr_mrrc(uint32_t opcode, uint32_t address, arm_instruction_t *instruction)
 {
 	uint8_t cp_num = (opcode & 0xf00) >> 8;
-	
+
 	/* MCRR or MRRC */
 	if (((opcode & 0x0ff00000) == 0x0c400000) || ((opcode & 0x0ff00000) == 0x0c400000))
 	{
 		uint8_t cp_opcode, Rd, Rn, CRm;
 		char *mnemonic;
-		
+
 		cp_opcode = (opcode & 0xf0) >> 4;
 		Rd = (opcode & 0xf000) >> 12;
 		Rn = (opcode & 0xf0000) >> 16;
 		CRm = (opcode & 0xf);
-		
+
 		/* MCRR */
 		if ((opcode & 0x0ff00000) == 0x0c400000)
 		{
 			instruction->type = ARM_MCRR;
 			mnemonic = "MCRR";
 		}
-		
+
 		/* MRRC */
 		if ((opcode & 0x0ff00000) == 0x0c500000)
 		{
 			instruction->type = ARM_MRRC;
 			mnemonic = "MRRC";
 		}
-		
+
 		snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s p%i, %x, r%i, r%i, c%i",
 				 address, opcode, mnemonic, COND(opcode), cp_num, cp_opcode, Rd, Rn, CRm);
 	}
@@ -175,11 +175,11 @@
 		uint8_t U, N;
 		char *mnemonic;
 		char addressing_mode[32];
-		
+
 		CRd = (opcode & 0xf000) >> 12;
 		Rn = (opcode & 0xf0000) >> 16;
 		offset = (opcode & 0xff);
-		
+
 		/* load/store */
 		if (opcode & 0x00100000)
 		{
@@ -191,10 +191,10 @@
 			instruction->type = ARM_STC;
 			mnemonic = "STC";
 		}
-		
+
 		U = (opcode & 0x00800000) >> 23;
 		N = (opcode & 0x00400000) >> 22;
-		
+
 		/* addressing modes */
 		if ((opcode & 0x01200000) == 0x01000000) /* immediate offset */
 			snprintf(addressing_mode, 32, "[r%i, #%s0x%2.2x*4]", Rn, (U) ? "" : "-", offset);
@@ -210,7 +210,7 @@
 				 (N) ? "L" : "",
 				 cp_num, CRd, addressing_mode);
 	}
-	
+
 	return ERROR_OK;
 }
 
@@ -222,14 +222,14 @@
 	char* cond;
 	char* mnemonic;
 	uint8_t cp_num, opcode_1, CRd_Rd, CRn, CRm, opcode_2;
-	
+
 	cond = ((opcode & 0xf0000000) == 0xf0000000) ? "2" : COND(opcode);
 	cp_num = (opcode & 0xf00) >> 8;
 	CRd_Rd = (opcode & 0xf000) >> 12;
 	CRn = (opcode & 0xf0000) >> 16;
 	CRm = (opcode & 0xf);
 	opcode_2 = (opcode & 0xe0) >> 5;
-	
+
 	/* CDP or MRC/MCR */
 	if (opcode & 0x00000010) /* bit 4 set -> MRC/MCR */
 	{
@@ -243,9 +243,9 @@
 			instruction->type = ARM_MCR;
 			mnemonic = "MCR";
 		}
-		
+
 		opcode_1 = (opcode & 0x00e00000) >> 21;
-		
+
 		snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s p%i, 0x%2.2x, r%i, c%i, c%i, 0x%2.2x",
 				 address, opcode, mnemonic, cond,
 				 cp_num, opcode_1, CRd_Rd, CRn, CRm, opcode_2);
@@ -254,14 +254,14 @@
 	{
 		instruction->type = ARM_CDP;
 		mnemonic = "CDP";
-		
+
 		opcode_1 = (opcode & 0x00f00000) >> 20;
-		
+
 		snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s p%i, 0x%2.2x, c%i, c%i, c%i, 0x%2.2x",
 				 address, opcode, mnemonic, cond,
 				 cp_num, opcode_1, CRd_Rd, CRn, CRm, opcode_2);
 	}
-	
+
 	return ERROR_OK;
 }
 
@@ -273,7 +273,7 @@
 	char *operation; /* "LDR" or "STR" */
 	char *suffix; /* "", "B", "T", "BT" */
 	char offset[32];
-	
+
 	/* examine flags */
 	I = (opcode & 0x02000000) >> 25;
 	P = (opcode & 0x01000000) >> 24;
@@ -281,13 +281,13 @@
 	B = (opcode & 0x00400000) >> 22;
 	W = (opcode & 0x00200000) >> 21;
 	L = (opcode & 0x00100000) >> 20;
-	
+
 	/* target register */
 	Rd = (opcode & 0xf000) >> 12;
-	
+
 	/* base register */
 	Rn = (opcode & 0xf0000) >> 16;
-	
+
 	instruction->info.load_store.Rd = Rd;
 	instruction->info.load_store.Rn = Rn;
 	instruction->info.load_store.U = U;
@@ -297,7 +297,7 @@
 		operation = "LDR";
 	else
 		operation = "STR";
-	
+
 	/* determine instruction type and suffix */
 	if (B)
 	{
@@ -337,7 +337,7 @@
 			suffix = "";
 		}
 	}
-	
+
 	if (!I) /* #+-<offset_12> */
 	{
 		uint32_t offset_12 = (opcode & 0xfff);
@@ -345,7 +345,7 @@
 			snprintf(offset, 32, ", #%s0x%" PRIx32 "", (U) ? "" : "-", offset_12);
 		else
 			snprintf(offset, 32, "%s", "");
-		
+
 		instruction->info.load_store.offset_mode = 0;
 		instruction->info.load_store.offset.offset = offset_12;
 	}
@@ -353,15 +353,15 @@
 	{
 		uint8_t shift_imm, shift;
 		uint8_t Rm;
-		
+
 		shift_imm = (opcode & 0xf80) >> 7;
 		shift = (opcode & 0x60) >> 5;
 		Rm = (opcode & 0xf);
-		
+
 		/* LSR encodes a shift by 32 bit as 0x0 */
 		if ((shift == 0x1) && (shift_imm == 0x0))
 			shift_imm = 0x20;
-		
+
 		/* ASR encodes a shift by 32 bit as 0x0 */
 		if ((shift == 0x2) && (shift_imm == 0x0))
 			shift_imm = 0x20;
@@ -369,7 +369,7 @@
 		/* ROR by 32 bit is actually a RRX */
 		if ((shift == 0x3) && (shift_imm == 0x0))
 			shift = 0x4;
-		
+
 		instruction->info.load_store.offset_mode = 1;
 		instruction->info.load_store.offset.reg.Rm = Rm;
 		instruction->info.load_store.offset.reg.shift = shift;
@@ -401,7 +401,7 @@
 			}
 		}
 	}
-	
+
 	if (P == 1)
 	{
 		if (W == 0) /* offset */
@@ -409,7 +409,7 @@
 			snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, [r%i%s]",
 					 address, opcode, operation, COND(opcode), suffix,
 					 Rd, Rn, offset);
-			
+
 			instruction->info.load_store.index_mode = 0;
 		}
 		else /* pre-indexed */
@@ -417,7 +417,7 @@
 			snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, [r%i%s]!",
 					 address, opcode, operation, COND(opcode), suffix,
 					 Rd, Rn, offset);
-			
+
 			instruction->info.load_store.index_mode = 1;
 		}
 	}
@@ -426,10 +426,10 @@
 		snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, [r%i]%s",
 				 address, opcode, operation, COND(opcode), suffix,
 				 Rd, Rn, offset);
-		
+
 		instruction->info.load_store.index_mode = 2;
 	}
-	
+
 	return ERROR_OK;
 }
 
@@ -441,7 +441,7 @@
 	char *operation; /* "LDR" or "STR" */
 	char *suffix; /* "H", "SB", "SH", "D" */
 	char offset[32];
-	
+
 	/* examine flags */
 	P = (opcode & 0x01000000) >> 24;
 	U = (opcode & 0x00800000) >> 23;
@@ -450,17 +450,17 @@
 	L = (opcode & 0x00100000) >> 20;
 	S = (opcode & 0x00000040) >> 6;
 	H = (opcode & 0x00000020) >> 5;
-	
+
 	/* target register */
 	Rd = (opcode & 0xf000) >> 12;
-	
+
 	/* base register */
 	Rn = (opcode & 0xf0000) >> 16;
-	
+
 	instruction->info.load_store.Rd = Rd;
 	instruction->info.load_store.Rn = Rn;
 	instruction->info.load_store.U = U;
-	
+
 	/* determine instruction type and suffix */
 	if (S) /* signed */
 	{
@@ -508,12 +508,12 @@
 			instruction->type = ARM_STRH;
 		}
 	}
-	
+
 	if (I) /* Immediate offset/index (#+-<offset_8>)*/
 	{
 		uint32_t offset_8 = ((opcode & 0xf00) >> 4) | (opcode & 0xf);
 		snprintf(offset, 32, "#%s0x%" PRIx32 "", (U) ? "" : "-", offset_8);
-		
+
 		instruction->info.load_store.offset_mode = 0;
 		instruction->info.load_store.offset.offset = offset_8;
 	}
@@ -522,13 +522,13 @@
 		uint8_t Rm;
 		Rm = (opcode & 0xf);
 		snprintf(offset, 32, "%sr%i", (U) ? "" : "-", Rm);
-		
+
 		instruction->info.load_store.offset_mode = 1;
 		instruction->info.load_store.offset.reg.Rm = Rm;
 		instruction->info.load_store.offset.reg.shift = 0x0;
 		instruction->info.load_store.offset.reg.shift_imm = 0x0;
 	}
-	
+
 	if (P == 1)
 	{
 		if (W == 0) /* offset */
@@ -536,7 +536,7 @@
 			snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, [r%i, %s]",
 					 address, opcode, operation, COND(opcode), suffix,
 					 Rd, Rn, offset);
-			
+
 			instruction->info.load_store.index_mode = 0;
 		}
 		else /* pre-indexed */
@@ -544,7 +544,7 @@
 			snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, [r%i, %s]!",
 					 address, opcode, operation, COND(opcode), suffix,
 					 Rd, Rn, offset);
-		
+
 			instruction->info.load_store.index_mode = 1;
 		}
 	}
@@ -553,10 +553,10 @@
 		snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, [r%i], %s",
 				 address, opcode, operation, COND(opcode), suffix,
 				 Rd, Rn, offset);
-	
+
 		instruction->info.load_store.index_mode = 2;
 	}
-	
+
 	return ERROR_OK;
 }
 
@@ -571,7 +571,7 @@
 	char *reg_list_p;
 	int i;
 	int first_reg = 1;
-	
+
 	P = (opcode & 0x01000000) >> 24;
 	U = (opcode & 0x00800000) >> 23;
 	S = (opcode & 0x00400000) >> 22;
@@ -579,12 +579,12 @@
 	L = (opcode & 0x00100000) >> 20;
 	register_list = (opcode & 0xffff);
 	Rn = (opcode & 0xf0000) >> 16;
-	
+
 	instruction->info.load_store_multiple.Rn = Rn;
 	instruction->info.load_store_multiple.register_list = register_list;
 	instruction->info.load_store_multiple.S = S;
 	instruction->info.load_store_multiple.W = W;
-	
+
 	if (L)
 	{
 		instruction->type = ARM_LDM;
@@ -595,7 +595,7 @@
 		instruction->type = ARM_STM;
 		mnemonic = "STM";
 	}
-	
+
 	if (P)
 	{
 		if (U)
@@ -622,7 +622,7 @@
 			addressing_mode = "DA";
 		}
 	}
-	
+
 	reg_list_p = reg_list;
 	for (i = 0; i <= 15; i++)
 	{
@@ -639,11 +639,11 @@
 			}
 		}
 	}
-	
+
 	snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i%s, {%s}%s",
 			 address, opcode, mnemonic, COND(opcode), addressing_mode,
 			 Rn, (W) ? "!" : "", reg_list, (S) ? "^" : "");
-	
+
 	return ERROR_OK;
 }
 
@@ -662,7 +662,7 @@
 			Rn = (opcode & 0xf000) >> 12;
 			Rd = (opcode & 0xf0000) >> 16;
 			S = (opcode & 0x00100000) >> 20;
-			
+
 			/* examine A bit (accumulate) */
 			if (opcode & 0x00200000)
 			{
@@ -676,10 +676,10 @@
 				snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\tMUL%s%s r%i, r%i, r%i",
 						 address, opcode, COND(opcode), (S) ? "S" : "", Rd, Rm, Rs);
 			}
-			
+
 			return ERROR_OK;
 		}
-		
+
 		/* Multiply (accumulate) long */
 		if ((opcode & 0x0f800000) == 0x00800000)
 		{
@@ -690,7 +690,7 @@
 			RdHi = (opcode & 0xf000) >> 12;
 			RdLow = (opcode & 0xf0000) >> 16;
 			S = (opcode & 0x00100000) >> 20;
-			
+
 			switch ((opcode & 0x00600000) >> 21)
 			{
 				case 0x0:
@@ -710,14 +710,14 @@
 					mnemonic = "SMLAL";
 					break;
 			}
-			
+
 			snprintf(instruction->text, 128, "0x%8.8" PRIx32 "\t0x%8.8" PRIx32 "\t%s%s%s r%i, r%i, r%i, r%i",
 						address, opcode, mnemonic, COND(opcode), (S) ? "S" : "",
 						RdLow, RdHi, Rm, Rs);
-			
+
 			return ERROR_OK;
 		}
-		
+
 		/* Swap/swap byte */
 		if ((opcode & 0x0f800000) == 0x01000000)
 		{
@@ -725,17 +725,17 @@...
 
[truncated message content]