X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fflash%2Fflash.c;h=9607725834692a6702e8ef7eebd6f0b3cba8cc2a;hp=1c6773dbbcbdb93ac5f61e1088b676974d8cd7e5;hb=d3f0549f08d8aac36143bca9e7f7e1308383b7c2;hpb=f14f84ca1e5d4fbab00c52100859af5ec8226753

diff --git a/src/flash/flash.c b/src/flash/flash.c
index 1c6773dbbc..9607725834 100644
--- a/src/flash/flash.c
+++ b/src/flash/flash.c
@@ -28,6 +28,10 @@
 #include "fileio.h"
 #include "image.h"
 #include "log.h"
+#include "armv4_5.h"
+#include "algorithm.h"
+#include "binarybuffer.h"
+#include "armv7m.h"
 
 #include <string.h>
 #include <unistd.h>
@@ -49,6 +53,7 @@ int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, cha
 int handle_flash_write_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 int handle_flash_auto_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr);
@@ -93,7 +98,7 @@ static int flash_driver_write(struct flash_bank_s *bank, u8 *buffer, u32 offset,
 	retval=bank->driver->write(bank, buffer, offset, count);
 	if (retval!=ERROR_OK)
 	{
-		ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank->base, offset, retval);
+		LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank->base, offset, retval);
 	}
 
 	return retval;
@@ -106,7 +111,7 @@ static int flash_driver_erase(struct flash_bank_s *bank, int first, int last)
 	retval=bank->driver->erase(bank, first, last);
 	if (retval!=ERROR_OK)
 	{
-		ERROR("failed erasing sectors %d to %d (%d)", first, last, retval);
+		LOG_ERROR("failed erasing sectors %d to %d (%d)", first, last, retval);
 	}
 
 	return retval;
@@ -119,7 +124,7 @@ int flash_driver_protect(struct flash_bank_s *bank, int set, int first, int last
 	retval=bank->driver->protect(bank, set, first, last);
 	if (retval!=ERROR_OK)
 	{
-		ERROR("failed setting protection for areas %d to %d (%d)", first, last, retval);
+		LOG_ERROR("failed setting protection for areas %d to %d (%d)", first, last, retval);
 	}
 
 	return retval;
@@ -154,6 +159,14 @@ int flash_init_drivers(struct command_context_s *cmd_ctx)
 						 "erase sectors at <bank> <first> <last>");
 		register_command(cmd_ctx, flash_cmd, "erase_address", handle_flash_erase_address_command, COMMAND_EXEC,
 						 "erase address range <address> <length>");
+
+		register_command(cmd_ctx, flash_cmd, "fillw", handle_flash_fill_command, COMMAND_EXEC,
+						 "fill with pattern <address> <word_pattern> <count>");
+		register_command(cmd_ctx, flash_cmd, "fillh", handle_flash_fill_command, COMMAND_EXEC,
+						 "fill with pattern <address> <halfword_pattern> <count>");
+		register_command(cmd_ctx, flash_cmd, "fillb", handle_flash_fill_command, COMMAND_EXEC,
+						 "fill with pattern <address> <byte_pattern> <count>");
+
 		register_command(cmd_ctx, flash_cmd, "write_bank", handle_flash_write_bank_command, COMMAND_EXEC,
 						 "write binary data to <bank> <file> <offset>");
 		register_command(cmd_ctx, flash_cmd, "write_image", handle_flash_write_image_command, COMMAND_EXEC,
@@ -177,7 +190,7 @@ flash_bank_t *get_flash_bank_by_num_noprobe(int num)
 			return p;
 		}
 	}
-	ERROR("flash bank %d does not exist", num);
+	LOG_ERROR("flash bank %d does not exist", num);
 	return NULL;
 }
 
@@ -204,7 +217,7 @@ flash_bank_t *get_flash_bank_by_num(int num)
 
 	if (retval != ERROR_OK)
 	{
-		ERROR("auto_probe failed %d\n", retval);
+		LOG_ERROR("auto_probe failed %d\n", retval);
 		return NULL;
 	}
 	return p;
@@ -223,7 +236,7 @@ int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char
 
 	if ((target = get_target_by_num(strtoul(args[5], NULL, 0))) == NULL)
 	{
-		ERROR("target %lu not defined", strtoul(args[5], NULL, 0));
+		LOG_ERROR("target %lu not defined", strtoul(args[5], NULL, 0));
 		return ERROR_OK;
 	}
 
@@ -236,7 +249,7 @@ int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char
 			/* register flash specific commands */
 			if (flash_drivers[i]->register_commands(cmd_ctx) != ERROR_OK)
 			{
-				ERROR("couldn't register '%s' commands", args[0]);
+				LOG_ERROR("couldn't register '%s' commands", args[0]);
 				exit(-1);
 			}
 
@@ -254,7 +267,7 @@ int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char
 
 			if (flash_drivers[i]->flash_bank_command(cmd_ctx, cmd, args, argc, c) != ERROR_OK)
 			{
-				ERROR("'%s' driver rejected flash bank at 0x%8.8x", args[0], c->base);
+				LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args[0], c->base);
 				free(c);
 				return ERROR_OK;
 			}
@@ -279,7 +292,7 @@ int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char
 	/* no matching flash driver found */
 	if (!found)
 	{
-		ERROR("flash driver '%s' not found", args[0]);
+		LOG_ERROR("flash driver '%s' not found", args[0]);
 		exit(-1);
 	}
 
@@ -325,20 +338,14 @@ int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char
 			char buf[1024];
 
 			/* attempt auto probe */
-			p->driver->auto_probe(p);
+			if ((retval = p->driver->auto_probe(p)) != ERROR_OK)
+				return retval;
 
 			command_print(cmd_ctx, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
 						i, p->driver->name, p->base, p->size, p->bus_width, p->chip_width);
 			for (j = 0; j < p->num_sectors; j++)
 			{
-				char *erase_state, *protect_state;
-
-				if (p->sectors[j].is_erased == 0)
-					erase_state = "not erased";
-				else if (p->sectors[j].is_erased == 1)
-					erase_state = "erased";
-				else
-					erase_state = "erase state unknown";
+				char *protect_state;
 
 				if (p->sectors[j].is_protected == 0)
 					protect_state = "not protected";
@@ -347,16 +354,16 @@ int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char
 				else
 					protect_state = "protection state unknown";
 
-				command_print(cmd_ctx, "\t#%i: 0x%8.8x (0x%x %ikB) %s, %s",
+				command_print(cmd_ctx, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
 							j, p->sectors[j].offset, p->sectors[j].size, p->sectors[j].size>>10,
-							erase_state, protect_state);
+							protect_state);
 			}
 
 			*buf = '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
 			retval = p->driver->info(p, buf, sizeof(buf));
 			command_print(cmd_ctx, "%s", buf);
 			if (retval != ERROR_OK)
-				ERROR("error retrieving flash info (%d)", retval);
+				LOG_ERROR("error retrieving flash info (%d)", retval);
 		}
 	}
 
@@ -412,6 +419,7 @@ int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cm
 	p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
 	if (p)
 	{
+		int j;
 		if ((retval = p->driver->erase_check(p)) == ERROR_OK)
 		{
 			command_print(cmd_ctx, "successfully checked erase state", p->driver->name, p->base);
@@ -421,6 +429,23 @@ int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cm
 			command_print(cmd_ctx, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
 				args[0], p->base);
 		}
+		
+		for (j = 0; j < p->num_sectors; j++)
+		{
+			char *erase_state;
+
+			if (p->sectors[j].is_erased == 0)
+				erase_state = "not erased";
+			else if (p->sectors[j].is_erased == 1)
+				erase_state = "erased";
+			else
+				erase_state = "erase state unknown";
+
+			command_print(cmd_ctx, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
+						j, p->sectors[j].offset, p->sectors[j].size, p->sectors[j].size>>10,
+						erase_state);
+		}
+		
 	}
 
 	return ERROR_OK;
@@ -598,7 +623,7 @@ int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cm
 
 	if (!target)
 	{
-		ERROR("no target selected");
+		LOG_ERROR("no target selected");
 		return ERROR_OK;
 	}
 
@@ -645,6 +670,113 @@ int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cm
 	return retval;
 }
 
+int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+{
+	int err = ERROR_OK;
+	u32 address;
+	u32 pattern;
+	u32 count;
+	u8 chunk[1024];
+	u32 wrote = 0;
+	int chunk_count;
+	char *duration_text;
+	duration_t duration;
+	target_t *target = get_current_target(cmd_ctx);
+	u32 i;
+	int wordsize;
+	
+	if (argc != 3)
+	{
+		return ERROR_COMMAND_SYNTAX_ERROR;
+	}
+	
+	address	= strtoul(args[0], NULL, 0);
+	pattern	= strtoul(args[1], NULL, 0);
+	count 	= strtoul(args[2], NULL, 0);
+	
+	if(count == 0)
+		return ERROR_OK;
+
+
+	switch(cmd[4])
+	{
+	case 'w':
+		wordsize=4;
+		break;
+	case 'h':
+		wordsize=2;
+		break;
+	case 'b':
+		wordsize=1;
+		break;
+	default:
+		return ERROR_COMMAND_SYNTAX_ERROR;
+	}
+	
+	chunk_count = MIN(count, (1024 / wordsize));
+	switch(wordsize)
+	{
+	case 4:
+		for(i = 0; i < chunk_count; i++)
+		{
+			target_buffer_set_u32(target, chunk + i * wordsize, pattern);
+		}
+		break;
+	case 2:
+		for(i = 0; i < chunk_count; i++)
+		{
+			target_buffer_set_u16(target, chunk + i * wordsize, pattern);
+		}
+		break;
+	case 1:
+		memset(chunk, pattern, chunk_count);
+		break;
+	default:
+		LOG_ERROR("BUG: can't happen");
+		exit(-1);
+	}
+	
+	duration_start_measure(&duration);
+
+	flash_set_dirty();
+	err = flash_erase_address_range( target, address, count*wordsize );
+	if (err == ERROR_OK)
+	{
+		for (wrote=0; wrote<(count*wordsize); wrote+=sizeof(chunk))
+		{ 
+			int cur_size = MIN( (count*wordsize - wrote) , 1024 );
+			if (err == ERROR_OK)
+			{
+				flash_bank_t *bank;
+				bank = get_flash_bank_by_addr(target, address);
+				if(bank == NULL)
+				{
+					err = ERROR_FAIL;
+					break;
+				}
+				err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
+				wrote += cur_size;
+			}
+			if (err!=ERROR_OK)
+				break;
+		}
+	}
+	
+	duration_stop_measure(&duration, &duration_text);
+
+	if(err == ERROR_OK)
+	{
+		float speed;
+		speed=wrote / 1024.0;
+		speed/=((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0));
+		command_print(cmd_ctx, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
+			count*wordsize, address, duration_text,
+			speed);
+	}
+	free(duration_text);
+	return ERROR_OK;
+}
+
 int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	u32 offset;
@@ -731,14 +863,14 @@ flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
 
 		if (retval != ERROR_OK)
 		{
-			ERROR("auto_probe failed %d\n", retval);
+			LOG_ERROR("auto_probe failed %d\n", retval);
 			return NULL;
 		}
 		/* check whether address belongs to this flash bank */
 		if ((addr >= c->base) && (addr < c->base + c->size) && target == c->target)
 			return c;
 	}
-	ERROR("No flash at address 0x%08x\n", addr);
+	LOG_ERROR("No flash at address 0x%08x\n", addr);
 	return NULL;
 }
 
@@ -823,7 +955,7 @@ int flash_write(target_t *target, image_t *image, u32 *written, int erase)
 
 		if (image->sections[section].size ==  0)
 		{
-			WARNING("empty section %d", section);
+			LOG_WARNING("empty section %d", section);
 			section++;
 			section_offset = 0;
 			continue;
@@ -845,7 +977,7 @@ int flash_write(target_t *target, image_t *image, u32 *written, int erase)
 		{
 			if (image->sections[section_last + 1].base_address < (run_address + run_size))
 			{
-				DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
+				LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
 				break;
 			}
 			if (image->sections[section_last + 1].base_address != (run_address + run_size))
@@ -933,3 +1065,243 @@ int handle_flash_auto_erase_command(struct command_context_s *cmd_ctx, char *cmd
 
 	return ERROR_OK;
 }
+
+
+int default_flash_blank_check(struct flash_bank_s *bank)
+{
+	target_t *target = bank->target;
+	u8 buffer[1024];
+	int buffer_size=sizeof(buffer);
+	int i;
+	int nBytes;
+	
+	if (bank->target->state != TARGET_HALTED)
+	{
+		return ERROR_TARGET_NOT_HALTED;
+	}
+	
+	int retval;
+	int fast_check=0;
+	working_area_t *erase_check_algorithm;
+#if 0
+	/* FIX! doesn't work yet... */
+	/*
+	char test(char *a, int len, char t)
+	{
+	  int i=0;
+	
+	  for (i=0; i<len; i++)
+		{
+		  t&=a[i];
+	
+		}
+	}
+	
+	$ arm-elf-gcc -c -mthumb -O3 test.c
+	
+	$ arm-elf-objdump --disassemble test.o
+	
+	test.o:     file format elf32-littlearm
+	
+	Disassembly of section .text:
+	
+	00000000 <test>:
+	   0:   b510            push    {r4, lr}
+	   2:   0612            lsl     r2, r2, #24
+	   4:   1c04            mov     r4, r0          (add r4, r0, #0)
+	   6:   0e10            lsr     r0, r2, #24
+	   8:   2200            mov     r2, #0
+	   a:   2900            cmp     r1, #0
+	   c:   dd04            ble     18 <test+0x18>
+	   e:   5ca3            ldrb    r3, [r4, r2]
+	  10:   3201            add     r2, #1
+	  12:   4018            and     r0, r3
+	  14:   428a            cmp     r2, r1
+	  16:   dbfa            blt     e <test+0xe>
+	  18:   bd10            pop     {r4, pc}
+	  1a:   46c0            nop                     (mov r8, r8)
+	
+
+	*/
+	u16 erase_check_code[] =
+	{
+		 0x0612,//            lsl     r2, r2, #24
+		 0x1c04,//            mov     r4, r0          (add r4, r0, #0)
+		 0x0e10,//            lsr     r0, r2, #24
+		 0x2200,//            mov     r2, #0
+		 0x2900,//            cmp     r1, #0
+		 0xdd04,//            ble     18 <test+0x18>
+		 0x5ca3,//            ldrb    r3, [r4, r2]
+		 0x3201,//            add     r2, #1
+		 0x4018,//            and     r0, r3
+		 0x428a,//            cmp     r2, r1
+		 0xdbfa,//            blt     e <test+0xe>
+		 0x46c0,//            nop                     (mov r8, r8)
+		 
+	};
+
+
+	
+	/* make sure we have a working area */
+	if (target_alloc_working_area(target, ((sizeof(erase_check_code)+3)/4)*4, &erase_check_algorithm) != ERROR_OK)
+	{
+		erase_check_algorithm = NULL;
+	}
+	
+	if (erase_check_algorithm)
+	{
+		u8 erase_check_code_buf[((sizeof(erase_check_code)+3)/4)*4];
+		LOG_DEBUG("Running fast flash erase check");
+		
+		for (i = 0; i < sizeof(erase_check_code)/sizeof(*erase_check_code); i++)
+			target_buffer_set_u16(target, erase_check_code_buf + (i*2), erase_check_code[i]);
+
+		/* write algorithm code to working area */
+		if ((retval=target->type->write_memory(target, erase_check_algorithm->address, 2, sizeof(erase_check_code)/sizeof(*erase_check_code), erase_check_code_buf))==ERROR_OK)
+		{
+			for (i = 0; i < bank->num_sectors; i++)
+			{
+				u32 address = bank->base + bank->sectors[i].offset;
+				u32 size = bank->sectors[i].size;
+	
+				reg_param_t reg_params[3];
+				armv7m_algorithm_t arm_info;
+	
+				arm_info.common_magic = ARMV7M_COMMON_MAGIC;
+				arm_info.core_mode = ARMV7M_MODE_ANY;
+				arm_info.core_state = ARMV7M_STATE_THUMB;
+	
+				init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
+				buf_set_u32(reg_params[0].value, 0, 32, address);
+	
+				init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
+				buf_set_u32(reg_params[1].value, 0, 32, size);
+	
+				init_reg_param(&reg_params[2], "r2", 32, PARAM_IN_OUT);
+				buf_set_u32(reg_params[2].value, 0, 32, 0xff);
+	
+				if ((retval = target->type->run_algorithm(target, 0, NULL, 3, reg_params, erase_check_algorithm->address, 
+						erase_check_algorithm->address + sizeof(erase_check_code) - 2, 10000, &arm_info)) != ERROR_OK)
+					break;
+	
+				if (buf_get_u32(reg_params[2].value, 0, 32) == 0xff)
+					bank->sectors[i].is_erased = 1;
+				else
+					bank->sectors[i].is_erased = 0;
+	
+				destroy_reg_param(&reg_params[0]);
+				destroy_reg_param(&reg_params[1]);
+				destroy_reg_param(&reg_params[2]);
+			}
+			if (i == bank->num_sectors)
+			{
+				fast_check = 1;
+			}
+		} 
+		target_free_working_area(target, erase_check_algorithm);
+	}
+#endif
+	if (!fast_check)
+	{
+		/* try ARM7 instead */
+	
+		u32 erase_check_code[] =
+		{
+			0xe4d03001,	/* ldrb r3, [r0], #1	*/
+			0xe0022003, /* and r2, r2, r3 		*/
+			0xe2511001, /* subs r1, r1, #1		*/
+			0x1afffffb,	/* b -4 				*/
+			0xeafffffe	/* b 0 					*/
+		};
+
+		/* make sure we have a working area */
+		if (target_alloc_working_area(target, 20, &erase_check_algorithm) == ERROR_OK)
+		{
+			u8 erase_check_code_buf[5 * 4];
+
+			for (i = 0; i < 5; i++)
+				target_buffer_set_u32(target, erase_check_code_buf + (i*4), erase_check_code[i]);
+
+			/* write algorithm code to working area */
+			if ((retval=target->type->write_memory(target, erase_check_algorithm->address, 4, 5, erase_check_code_buf))==ERROR_OK)
+			{
+				for (i = 0; i < bank->num_sectors; i++)
+				{
+					u32 address = bank->base + bank->sectors[i].offset;
+					u32 size = bank->sectors[i].size;
+			
+					reg_param_t reg_params[3];
+					armv4_5_algorithm_t armv4_5_info;
+			
+					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);
+					buf_set_u32(reg_params[0].value, 0, 32, address);
+			
+					init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
+					buf_set_u32(reg_params[1].value, 0, 32, size);
+			
+					init_reg_param(&reg_params[2], "r2", 32, PARAM_IN_OUT);
+					buf_set_u32(reg_params[2].value, 0, 32, 0xff);
+			
+					if ((retval = target->type->run_algorithm(target, 0, NULL, 3, reg_params, 
+							erase_check_algorithm->address, erase_check_algorithm->address + 0x10, 10000, &armv4_5_info)) != ERROR_OK)
+						break;
+			
+					if (buf_get_u32(reg_params[2].value, 0, 32) == 0xff)
+						bank->sectors[i].is_erased = 1;
+					else
+						bank->sectors[i].is_erased = 0;
+			
+					destroy_reg_param(&reg_params[0]);
+					destroy_reg_param(&reg_params[1]);
+					destroy_reg_param(&reg_params[2]);
+				}
+				if (i == bank->num_sectors)
+				{
+					fast_check = 1;
+				}
+			} 
+			target_free_working_area(target, erase_check_algorithm);
+		}
+	}
+
+	
+	if (!fast_check)
+	{
+		LOG_USER("Running slow fallback erase check - add working memory");
+		for (i = 0; i < bank->num_sectors; i++)
+		{
+			int j;
+			bank->sectors[i].is_erased = 1;
+			
+			for (j=0; j<bank->sectors[i].size; j+=buffer_size)
+			{
+				int chunk;
+				int retval;
+				chunk=buffer_size;
+				if (chunk>(j-bank->sectors[i].size))
+				{
+					chunk=(j-bank->sectors[i].size);
+				}
+				
+				retval=target->type->read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
+				if (retval!=ERROR_OK)
+					return retval;
+			
+				for (nBytes = 0; nBytes < chunk; nBytes++)
+				{
+					if (buffer[nBytes] != 0xFF)
+					{
+						bank->sectors[i].is_erased = 0;
+						break;
+					}
+				}
+			}
+		}
+	}
+	
+	return ERROR_OK;
+}