interesting
/
riscv-openocd
mirror of https://github.com/riscv/riscv-openocd.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

- flash autoerase <on|off> cmd added, default is off - flash banks are calculated and erased prior to write (flash write_image only) 

- corrected array overrun in armv7m.c
- corrected breakpoint memory allocation bug
- image read now uses fgets, vastly improves reading of large files
- improved hex file reading, support for Linear Address Record added

git-svn-id: svn://svn.berlios.de/openocd/trunk@208 b42882b7-edfa-0310-969c-e2dbd0fdcd60
This commit is contained in:
ntfreak 2007-10-01 08:31:30 +00:00
parent ed36a8d15d
commit 995326b600
9 changed files with 153 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
src/flash/flash.c
View File

@ -49,6 +49,7 @@ int handle_flash_write_command(struct command_context_s *cmd_ctx, char *cmd, cha
int handle_flash_write_binary_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_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 drivers
*/
@ -76,6 +77,7 @@ flash_driver_t *flash_drivers[] =
flash_bank_t *flash_banks;
static command_t *flash_cmd;
static int auto_erase = 0;
int flash_register_commands(struct command_context_s *cmd_ctx)
{
@ -110,6 +112,8 @@ int flash_init(struct command_context_s *cmd_ctx)
"write image <file> [offset] [type]");
register_command(cmd_ctx, flash_cmd, "protect", handle_flash_protect_command, COMMAND_EXEC,
"set protection of sectors at <bank> <first> <last> <on|off>");
register_command(cmd_ctx, flash_cmd, "auto_erase", handle_flash_auto_erase_command, COMMAND_EXEC,
"auto erase flash sectors <on|off>");
}
return ERROR_OK;
@ -566,7 +570,7 @@ int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cm
failed = malloc(sizeof(int) * image.num_sections);
if ((retval = flash_write(target, &image, &written, &error_str, failed)) != ERROR_OK)
if ((retval = flash_write(target, &image, &written, &error_str, failed, auto_erase)) != ERROR_OK)
{
command_print(cmd_ctx, "failed writing image %s: %s", args[0], error_str);
free(error_str);
@ -700,17 +704,16 @@ flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
int flash_erase(target_t *target, u32 addr, u32 length)
{
flash_bank_t *c;
unsigned long sector_size;
int first;
int last;
int first = -1;
int last = -1;
int i;
if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
/* sanity checks */
if (c->size == 0 || c->num_sectors == 0 || c->size % c->num_sectors)
return ERROR_FLASH_BANK_INVALID;
if (c->size == 0 || c->num_sectors == 0)
return ERROR_FLASH_BANK_INVALID;
if (length == 0)
{
/* special case, erase whole bank when length is zero */
@ -722,22 +725,29 @@ int flash_erase(target_t *target, u32 addr, u32 length)
/* check whether it fits */
if (addr + length > c->base + c->size)
return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
/* calculate sector size */
sector_size = c->size / c->num_sectors;
/* check alignment */
if ((addr - c->base) % sector_size || length % sector_size)
return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
first = (addr - c->base) / sector_size;
last = first + length / sector_size - 1;
addr -= c->base;
for (i = 0; i < c->num_sectors; i++)
{
/* check whether sector overlaps with the given range and is not yet erased */
if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
/* if first is not set yet then this is the first sector */
if (first == -1)
first = i;
last = i; /* and it is the last one so far in any case */
}
}
if( first == -1 || last == -1 )
return ERROR_OK;
return c->driver->erase(c, first, last);
}
/* write an image to flash memory of the given target */
int flash_write(target_t *target, image_t *image, u32 *written, char **error_str, int *failed)
int flash_write(target_t *target, image_t *image, u32 *written, char **error_str, int *failed, int erase)
{
int retval;
int i;
@ -854,7 +864,20 @@ int flash_write(target_t *target, image_t *image, u32 *written, char **error_str
}
}
retval = c->driver->write(c, buffer, run_address - c->base, run_size);
retval = ERROR_OK;
if (erase)
{
/* calculate and erase sectors */
retval = flash_erase( target, run_address, run_size );
}
if (retval == ERROR_OK)
{
/* write flash sectors */
retval = c->driver->write(c, buffer, run_address - c->base, run_size);
}
free(buffer);
if (retval != ERROR_OK)
@ -896,3 +919,20 @@ int flash_write(target_t *target, image_t *image, u32 *written, char **error_str
return ERROR_OK;
}
int handle_flash_auto_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
if (argc != 1)
{
command_print(cmd_ctx, "usage: flash auto_erase <on|off>");
return ERROR_OK;
}
if (strcmp(args[0], "on") == 0)
auto_erase = 1;
else if (strcmp(args[0], "off") == 0)
auto_erase = 0;
return ERROR_OK;
}

2
src/flash/flash.h
View File

@ -67,7 +67,7 @@ extern int flash_register_commands(struct command_context_s *cmd_ctx);
extern int flash_init(struct command_context_s *cmd_ctx);
extern int flash_erase(target_t *target, u32 addr, u32 length);
extern int flash_write(target_t *target, image_t *image, u32 *written, char **error, int *failed);
extern int flash_write(target_t *target, image_t *image, u32 *written, char **error, int *failed, int erase);
extern flash_bank_t *get_flash_bank_by_num(int num);
extern flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr);

23
src/helper/fileio.c
View File

@ -284,6 +284,29 @@ int fileio_read_u32(fileio_t *fileio, u32 *data)
return ERROR_OK;
}
int fileio_local_fgets(fileio_t *fileio, u32 size, u8 *buffer)
{
fileio_local_t *fileio_local = fileio->location_private;
if( fgets(buffer, size, fileio_local->file) == NULL)
return ERROR_FILEIO_OPERATION_FAILED;
return ERROR_OK;
}
int fileio_fgets(fileio_t *fileio, u32 size, u8 *buffer)
{
switch (fileio->location)
{
case FILEIO_LOCAL:
return fileio_local_fgets(fileio, size, buffer);
break;
default:
ERROR("BUG: should never get here");
exit(-1);
}
}
int fileio_local_write(fileio_t *fileio, u32 size, u8 *buffer, u32 *size_written)
{
fileio_local_t *fileio_local = fileio->location_private;

1
src/helper/fileio.h
View File

@ -79,6 +79,7 @@ typedef struct fileio_local_s
extern int fileio_write(fileio_t *fileio, u32 size, u8 *buffer, u32 *size_written);
extern int fileio_read(fileio_t *fileio, u32 size, u8 *buffer, u32 *size_read);
extern int fileio_fgets(fileio_t *fileio, u32 size, u8 *buffer);
extern int fileio_seek(fileio_t *fileio, u32 position);
extern int fileio_close(fileio_t *fileio);
extern int fileio_open(fileio_t *fileio, char *url, enum fileio_access access, enum fileio_type type);

2
src/jtag/ft2232.c
View File

@ -249,7 +249,7 @@ int ft2232_speed(int speed)
u32 bytes_written;
buf[0] = 0x86; /* command "set divisor" */
buf[1] = speed & 0xff; /* valueL (0=6MHz, 1=3MHz, 2=1.5MHz, ...*/
buf[1] = speed & 0xff; /* valueL (0=6MHz, 1=3MHz, 2=2.0MHz, ...*/
buf[2] = (speed >> 8) & 0xff; /* valueH */
DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);

2
src/server/gdb_server.c
View File

@ -1274,7 +1274,7 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p
char *error_str;
/* process the flashing buffer */
if ((result = flash_write(gdb_service->target, gdb_connection->vflash_image, &written, &error_str, NULL)) != ERROR_OK)
if ((result = flash_write(gdb_service->target, gdb_connection->vflash_image, &written, &error_str, NULL, 0)) != ERROR_OK)
{
if (result == ERROR_FLASH_DST_OUT_OF_BANK)
gdb_put_packet(connection, "E.memtype", 9);

2
src/target/armv7m.c
View File

@ -186,7 +186,7 @@ int armv7m_restore_context(target_t *target)
if (armv7m->pre_restore_context)
armv7m->pre_restore_context(target);
for (i = ARMV7NUMCOREREGS; i >= 0; i--)
for (i = ARMV7NUMCOREREGS-1; i >= 0; i--)
{
if (armv7m->core_cache->reg_list[i].dirty)
{

2
src/target/breakpoints.c
View File

@ -62,7 +62,7 @@ int breakpoint_add(target_t *target, u32 address, u32 length, enum breakpoint_ty
(*breakpoint_p)->length = length;
(*breakpoint_p)->type = type;
(*breakpoint_p)->set = 0;
(*breakpoint_p)->orig_instr = malloc(CEIL(length, 8));
(*breakpoint_p)->orig_instr = malloc(length);
(*breakpoint_p)->next = NULL;
if ((retval = target->type->add_breakpoint(target, *breakpoint_p)) != ERROR_OK)

153
src/target/image.c
View File

@ -154,52 +154,37 @@ int image_ihex_buffer_complete(image_t *image)
{
image_ihex_t *ihex = image->type_private;
fileio_t *fileio = &ihex->fileio;
u32 raw_bytes_read, raw_bytes;
int retval;
u32 full_address = 0x0;
char *buffer = malloc(fileio->size);
u32 cooked_bytes;
int i;
char lpszLine[1023];
/* we can't determine the number of sections that we'll have to create ahead of time,
* so we locally hold them until parsing is finished */
image_section_t section[IMAGE_MAX_SECTIONS];
if ((retval = fileio_read(fileio, fileio->size, (u8*)buffer, &raw_bytes_read)) != ERROR_OK)
{
free(buffer);
ERROR("failed buffering IHEX file, read failed");
return ERROR_FILEIO_OPERATION_FAILED;
}
if (raw_bytes_read != fileio->size)
{
free(buffer);
ERROR("failed buffering complete IHEX file, only partially read");
return ERROR_FILEIO_OPERATION_FAILED;
}
ihex->buffer = malloc(fileio->size >> 1);
raw_bytes = 0x0;
cooked_bytes = 0x0;
image->num_sections = 0;
section[image->num_sections].private = &ihex->buffer[cooked_bytes];
section[image->num_sections].base_address = 0x0;
section[image->num_sections].size = 0x0;
section[image->num_sections].flags = 0;
while (raw_bytes < raw_bytes_read)
while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
{
u32 count;
u32 address;
u32 record_type;
u32 checksum;
u8 cal_checksum = 0;
u32 bytes_read = 0;
if (sscanf(&buffer[raw_bytes], ":%2x%4x%2x", &count, &address, &record_type) != 3)
if (sscanf(&lpszLine[bytes_read], ":%2x%4x%2x", &count, &address, &record_type) != 3)
{
return ERROR_IMAGE_FORMAT_ERROR;
}
raw_bytes += 9;
bytes_read += 9;
cal_checksum += (u8)count;
cal_checksum += (u8)(address >> 8);
@ -228,9 +213,9 @@ int image_ihex_buffer_complete(image_t *image)
while (count-- > 0)
{
sscanf(&buffer[raw_bytes], "%2hhx", &ihex->buffer[cooked_bytes]);
sscanf(&lpszLine[bytes_read], "%2x", (u32*)&ihex->buffer[cooked_bytes]);
cal_checksum += (u8)ihex->buffer[cooked_bytes];
raw_bytes += 2;
bytes_read += 2;
cooked_bytes += 1;
section[image->num_sections].size += 1;
full_address++;
@ -252,17 +237,43 @@ int image_ihex_buffer_complete(image_t *image)
image->sections[i].flags = section[i].flags;
}
free(buffer);
return ERROR_OK;
}
else if (record_type == 2) /* Linear Address Record */
{
u16 upper_address;
sscanf(&lpszLine[bytes_read], "%4hx", &upper_address);
cal_checksum += (u8)(upper_address >> 8);
cal_checksum += (u8)upper_address;
bytes_read += 4;
if ((full_address >> 4) != upper_address)
{
/* we encountered a nonconsecutive location, create a new section,
* unless the current section has zero size, in which case this specifies
* the current section's base address
*/
if (section[image->num_sections].size != 0)
{
image->num_sections++;
section[image->num_sections].size = 0x0;
section[image->num_sections].flags = 0;
section[image->num_sections].private = &ihex->buffer[cooked_bytes];
}
section[image->num_sections].base_address =
(full_address & 0xffff) | (upper_address << 4);
full_address = (full_address & 0xffff) | (upper_address << 4);
}
}
else if (record_type == 4) /* Extended Linear Address Record */
{
u16 upper_address;
sscanf(&buffer[raw_bytes], "%4hx", &upper_address);
sscanf(&lpszLine[bytes_read], "%4hx", &upper_address);
cal_checksum += (u8)(upper_address >> 8);
cal_checksum += (u8)upper_address;
raw_bytes += 4;
bytes_read += 4;
if ((full_address >> 16) != upper_address)
{
@ -286,43 +297,33 @@ int image_ihex_buffer_complete(image_t *image)
{
u32 start_address;
sscanf(&buffer[raw_bytes], "%8x", &start_address);
sscanf(&lpszLine[bytes_read], "%8x", &start_address);
cal_checksum += (u8)(start_address >> 24);
cal_checksum += (u8)(start_address >> 16);
cal_checksum += (u8)(start_address >> 8);
cal_checksum += (u8)start_address;
raw_bytes += 8;
bytes_read += 8;
image->start_address_set = 1;
image->start_address = be_to_h_u32((u8*)&start_address);
}
else
{
free(buffer);
ERROR("unhandled IHEX record type: %i", record_type);
return ERROR_IMAGE_FORMAT_ERROR;
}
sscanf(&buffer[raw_bytes], "%2x", &checksum);
raw_bytes += 2;
sscanf(&lpszLine[bytes_read], "%2x", &checksum);
bytes_read += 2;
if ((u8)checksum != (u8)(~cal_checksum + 1))
{
/* checksum failed */
free(buffer);
ERROR("incorrect record checksum found in IHEX file");
return ERROR_IMAGE_CHECKSUM;
}
/* consume new-line character(s) */
if ((buffer[raw_bytes] == '\n') || (buffer[raw_bytes] == '\r'))
raw_bytes++;
if ((buffer[raw_bytes] == '\n') || (buffer[raw_bytes] == '\r'))
raw_bytes++;
}
free(buffer);
ERROR("premature end of IHEX file, no end-of-file record found");
return ERROR_IMAGE_FORMAT_ERROR;
}
@ -466,33 +467,16 @@ int image_mot_buffer_complete(image_t *image)
{
image_mot_t *mot = image->type_private;
fileio_t *fileio = &mot->fileio;
u32 raw_bytes_read, raw_bytes;
int retval;
u32 full_address = 0x0;
char *buffer = malloc(fileio->size);
u32 cooked_bytes;
int i;
char lpszLine[1023];
/* we can't determine the number of sections that we'll have to create ahead of time,
* so we locally hold them until parsing is finished */
image_section_t section[IMAGE_MAX_SECTIONS];
if ((retval = fileio_read(fileio, fileio->size, (u8*)buffer, &raw_bytes_read)) != ERROR_OK)
{
free(buffer);
ERROR("failed buffering S19 file, read failed");
return ERROR_FILEIO_OPERATION_FAILED;
}
if (raw_bytes_read != fileio->size)
{
free(buffer);
ERROR("failed buffering complete IHEX file, only partially read");
return ERROR_FILEIO_OPERATION_FAILED;
}
mot->buffer = malloc(fileio->size >> 1);
raw_bytes = 0x0;
cooked_bytes = 0x0;
image->num_sections = 0;
section[image->num_sections].private = &mot->buffer[cooked_bytes];
@ -500,21 +484,22 @@ int image_mot_buffer_complete(image_t *image)
section[image->num_sections].size = 0x0;
section[image->num_sections].flags = 0;
while (raw_bytes < raw_bytes_read)
while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
{
u32 count;
u32 address;
u32 record_type;
u32 checksum;
u8 cal_checksum = 0;
u32 bytes_read = 0;
/* get record type and record length */
if (sscanf(&buffer[raw_bytes], "S%1x%2x", &record_type, &count) != 2)
if (sscanf(&lpszLine[bytes_read], "S%1x%2x", &record_type, &count) != 2)
{
return ERROR_IMAGE_FORMAT_ERROR;
}
raw_bytes += 4;
bytes_read += 4;
cal_checksum += (u8)count;
/* skip checksum byte */
@ -526,9 +511,9 @@ int image_mot_buffer_complete(image_t *image)
int iValue;
while (count-- > 0) {
sscanf(&buffer[raw_bytes], "%2x", &iValue);
sscanf(&lpszLine[bytes_read], "%2x", &iValue);
cal_checksum += (u8)iValue;
raw_bytes += 2;
bytes_read += 2;
}
}
else if (record_type >= 1 && record_type <= 3)
@ -537,31 +522,31 @@ int image_mot_buffer_complete(image_t *image)
{
case 1:
/* S1 - 16 bit address data record */
sscanf(&buffer[raw_bytes], "%4x", &address);
sscanf(&lpszLine[bytes_read], "%4x", &address);
cal_checksum += (u8)(address >> 8);
cal_checksum += (u8)address;
raw_bytes += 4;
bytes_read += 4;
count -=2;
break;
case 2:
/* S2 - 24 bit address data record */
sscanf(&buffer[raw_bytes], "%6x", &address);
sscanf(&lpszLine[bytes_read], "%6x", &address);
cal_checksum += (u8)(address >> 16);
cal_checksum += (u8)(address >> 8);
cal_checksum += (u8)address;
raw_bytes += 6;
bytes_read += 6;
count -=3;
break;
case 3:
/* S3 - 32 bit address data record */
sscanf(&buffer[raw_bytes], "%8x", &address);
sscanf(&lpszLine[bytes_read], "%8x", &address);
cal_checksum += (u8)(address >> 24);
cal_checksum += (u8)(address >> 16);
cal_checksum += (u8)(address >> 8);
cal_checksum += (u8)address;
raw_bytes += 8;
bytes_read += 8;
count -=4;
break;
@ -580,16 +565,15 @@ int image_mot_buffer_complete(image_t *image)
section[image->num_sections].flags = 0;
section[image->num_sections].private = &mot->buffer[cooked_bytes];
}
section[image->num_sections].base_address =
full_address | address;
full_address = full_address | address;
section[image->num_sections].base_address = address;
full_address = address;
}
while (count-- > 0)
{
sscanf(&buffer[raw_bytes], "%2hhx", &mot->buffer[cooked_bytes]);
sscanf(&lpszLine[bytes_read], "%2x", (u32*)&mot->buffer[cooked_bytes]);
cal_checksum += (u8)mot->buffer[cooked_bytes];
raw_bytes += 2;
bytes_read += 2;
cooked_bytes += 1;
section[image->num_sections].size += 1;
full_address++;
@ -611,38 +595,27 @@ int image_mot_buffer_complete(image_t *image)
image->sections[i].flags = section[i].flags;
}
free(buffer);
return ERROR_OK;
}
else
{
free(buffer);
ERROR("unhandled S19 record type: %i", record_type);
return ERROR_IMAGE_FORMAT_ERROR;
}
/* account for checksum, will always be 0xFF */
sscanf(&buffer[raw_bytes], "%2x", &checksum);
sscanf(&lpszLine[bytes_read], "%2x", &checksum);
cal_checksum += (u8)checksum;
raw_bytes += 2;
bytes_read += 2;
if( cal_checksum != 0xFF )
{
/* checksum failed */
free(buffer);
ERROR("incorrect record checksum found in S19 file");
return ERROR_IMAGE_CHECKSUM;
}
/* consume new-line character(s) */
if ((buffer[raw_bytes] == '\n') || (buffer[raw_bytes] == '\r'))
raw_bytes++;
if ((buffer[raw_bytes] == '\n') || (buffer[raw_bytes] == '\r'))
raw_bytes++;
}
free(buffer);
ERROR("premature end of S19 file, no end-of-file record found");
return ERROR_IMAGE_FORMAT_ERROR;
}