which svnversion > /dev/null 2>&1 && REV=`svnversion`
echo -n $REV
which svnversion > /dev/null 2>&1 && REV=`svnversion`
echo -n $REV
/* convert ELF header field to host endianness */
#define field16(elf, field)\
((elf->endianness == ELFDATA2LSB)? \
/* convert ELF header field to host endianness */
#define field16(elf, field)\
((elf->endianness == ELFDATA2LSB)? \
- le_to_h_u16((u8*)&field) : be_to_h_u16((u8*)&field))
+ le_to_h_u16((u8*)&field) : be_to_h_u16((u8*)&field))
#define field32(elf, field)\
((elf->endianness == ELFDATA2LSB)? \
#define field32(elf, field)\
((elf->endianness == ELFDATA2LSB)? \
- le_to_h_u32((u8*)&field) : be_to_h_u32((u8*)&field))
+ le_to_h_u32((u8*)&field) : be_to_h_u32((u8*)&field))
static int autodetect_image_type(image_t *image, char *url)
{
static int autodetect_image_type(image_t *image, char *url)
{
fileio_t fileio;
u32 read_bytes;
u8 buffer[9];
fileio_t fileio;
u32 read_bytes;
u8 buffer[9];
/* read the first 4 bytes of image */
if ((retval = fileio_open(&fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
{
/* read the first 4 bytes of image */
if ((retval = fileio_open(&fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
{
- snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, "cannot open image: %s", fileio.error_str);
+ snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, "cannot open image: %s", fileio.error_str);
ERROR(image->error_str);
return retval;
}
ERROR(image->error_str);
return retval;
}
{
return autodetect_image_type(image, url);
}
{
return autodetect_image_type(image, url);
}
u32 cooked_bytes;
int i;
char lpszLine[1023];
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];
/* 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];
section[image->num_sections].base_address = 0x0;
section[image->num_sections].size = 0x0;
section[image->num_sections].flags = 0;
section[image->num_sections].base_address = 0x0;
section[image->num_sections].size = 0x0;
section[image->num_sections].flags = 0;
while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
{
u32 count;
while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
{
u32 count;
u32 checksum;
u8 cal_checksum = 0;
u32 bytes_read = 0;
u32 checksum;
u8 cal_checksum = 0;
u32 bytes_read = 0;
if (sscanf(&lpszLine[bytes_read], ":%2x%4x%2x", &count, &address, &record_type) != 3)
{
return ERROR_IMAGE_FORMAT_ERROR;
}
bytes_read += 9;
if (sscanf(&lpszLine[bytes_read], ":%2x%4x%2x", &count, &address, &record_type) != 3)
{
return ERROR_IMAGE_FORMAT_ERROR;
}
bytes_read += 9;
cal_checksum += (u8)count;
cal_checksum += (u8)(address >> 8);
cal_checksum += (u8)address;
cal_checksum += (u8)record_type;
cal_checksum += (u8)count;
cal_checksum += (u8)(address >> 8);
cal_checksum += (u8)address;
cal_checksum += (u8)record_type;
if (record_type == 0) /* Data Record */
{
if ((full_address & 0xffff) != address)
if (record_type == 0) /* Data Record */
{
if ((full_address & 0xffff) != address)
(full_address & 0xffff0000) | address;
full_address = (full_address & 0xffff0000) | address;
}
(full_address & 0xffff0000) | address;
full_address = (full_address & 0xffff0000) | address;
}
while (count-- > 0)
{
sscanf(&lpszLine[bytes_read], "%2x", (u32*)&ihex->buffer[cooked_bytes]);
while (count-- > 0)
{
sscanf(&lpszLine[bytes_read], "%2x", (u32*)&ihex->buffer[cooked_bytes]);
{
/* finish the current section */
image->num_sections++;
{
/* finish the current section */
image->num_sections++;
/* copy section information */
image->sections = malloc(sizeof(image_section_t) * image->num_sections);
for (i = 0; i < image->num_sections; i++)
/* copy section information */
image->sections = malloc(sizeof(image_section_t) * image->num_sections);
for (i = 0; i < image->num_sections; i++)
image->sections[i].size = section[i].size;
image->sections[i].flags = section[i].flags;
}
image->sections[i].size = section[i].size;
image->sections[i].flags = section[i].flags;
}
return ERROR_OK;
}
else if (record_type == 2) /* Linear Address Record */
{
u16 upper_address;
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;
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,
if ((full_address >> 4) != upper_address)
{
/* we encountered a nonconsecutive location, create a new section,
section[image->num_sections].flags = 0;
section[image->num_sections].private = &ihex->buffer[cooked_bytes];
}
section[image->num_sections].flags = 0;
section[image->num_sections].private = &ihex->buffer[cooked_bytes];
}
- section[image->num_sections].base_address =
+ section[image->num_sections].base_address =
(full_address & 0xffff) | (upper_address << 4);
full_address = (full_address & 0xffff) | (upper_address << 4);
}
(full_address & 0xffff) | (upper_address << 4);
full_address = (full_address & 0xffff) | (upper_address << 4);
}
else if (record_type == 3) /* Start Segment Address Record */
{
u32 dummy;
else if (record_type == 3) /* Start Segment Address Record */
{
u32 dummy;
/* "Start Segment Address Record" will not be supported */
/* but we must consume it, and do not create an error. */
while (count-- > 0)
/* "Start Segment Address Record" will not be supported */
/* but we must consume it, and do not create an error. */
while (count-- > 0)
else if (record_type == 4) /* Extended Linear Address Record */
{
u16 upper_address;
else if (record_type == 4) /* Extended 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;
sscanf(&lpszLine[bytes_read], "%4hx", &upper_address);
cal_checksum += (u8)(upper_address >> 8);
cal_checksum += (u8)upper_address;
bytes_read += 4;
if ((full_address >> 16) != upper_address)
{
/* we encountered a nonconsecutive location, create a new section,
if ((full_address >> 16) != upper_address)
{
/* we encountered a nonconsecutive location, create a new section,
section[image->num_sections].flags = 0;
section[image->num_sections].private = &ihex->buffer[cooked_bytes];
}
section[image->num_sections].flags = 0;
section[image->num_sections].private = &ihex->buffer[cooked_bytes];
}
- section[image->num_sections].base_address =
+ section[image->num_sections].base_address =
(full_address & 0xffff) | (upper_address << 16);
full_address = (full_address & 0xffff) | (upper_address << 16);
}
(full_address & 0xffff) | (upper_address << 16);
full_address = (full_address & 0xffff) | (upper_address << 16);
}
else if (record_type == 5) /* Start Linear Address Record */
{
u32 start_address;
else if (record_type == 5) /* Start Linear Address Record */
{
u32 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;
bytes_read += 8;
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;
bytes_read += 8;
image->start_address_set = 1;
image->start_address = be_to_h_u32((u8*)&start_address);
}
image->start_address_set = 1;
image->start_address = be_to_h_u32((u8*)&start_address);
}
ERROR("unhandled IHEX record type: %i", record_type);
return ERROR_IMAGE_FORMAT_ERROR;
}
ERROR("unhandled IHEX record type: %i", record_type);
return ERROR_IMAGE_FORMAT_ERROR;
}
sscanf(&lpszLine[bytes_read], "%2x", &checksum);
bytes_read += 2;
sscanf(&lpszLine[bytes_read], "%2x", &checksum);
bytes_read += 2;
if ((u8)checksum != (u8)(~cal_checksum + 1))
{
/* checksum failed */
if ((u8)checksum != (u8)(~cal_checksum + 1))
{
/* checksum failed */
return ERROR_IMAGE_CHECKSUM;
}
}
return ERROR_IMAGE_CHECKSUM;
}
}
ERROR("premature end of IHEX file, no end-of-file record found");
return ERROR_IMAGE_FORMAT_ERROR;
}
ERROR("premature end of IHEX file, no end-of-file record found");
return ERROR_IMAGE_FORMAT_ERROR;
}
image->start_address_set = 1;
image->start_address = field32(elf, elf->header->e_entry);
image->start_address_set = 1;
image->start_address = field32(elf, elf->header->e_entry);
int retval;
*size_read = 0;
int retval;
*size_read = 0;
DEBUG("load segment %d at 0x%x (sz = 0x%x)", section, offset, size);
/* read initialized data in current segment if any */
DEBUG("load segment %d at 0x%x (sz = 0x%x)", section, offset, size);
/* read initialized data in current segment if any */
if (!size)
return ERROR_OK;
}
if (!size)
return ERROR_OK;
}
u32 cooked_bytes;
int i;
char lpszLine[1023];
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];
/* 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];
mot->buffer = malloc(fileio->size >> 1);
cooked_bytes = 0x0;
image->num_sections = 0;
mot->buffer = malloc(fileio->size >> 1);
cooked_bytes = 0x0;
image->num_sections = 0;
section[image->num_sections].base_address = 0x0;
section[image->num_sections].size = 0x0;
section[image->num_sections].flags = 0;
section[image->num_sections].base_address = 0x0;
section[image->num_sections].size = 0x0;
section[image->num_sections].flags = 0;
while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
{
u32 count;
while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
{
u32 count;
u32 checksum;
u8 cal_checksum = 0;
u32 bytes_read = 0;
u32 checksum;
u8 cal_checksum = 0;
u32 bytes_read = 0;
/* get record type and record length */
if (sscanf(&lpszLine[bytes_read], "S%1x%2x", &record_type, &count) != 2)
{
return ERROR_IMAGE_FORMAT_ERROR;
}
/* get record type and record length */
if (sscanf(&lpszLine[bytes_read], "S%1x%2x", &record_type, &count) != 2)
{
return ERROR_IMAGE_FORMAT_ERROR;
}
bytes_read += 4;
cal_checksum += (u8)count;
bytes_read += 4;
cal_checksum += (u8)count;
/* skip checksum byte */
count -=1;
/* skip checksum byte */
count -=1;
if (record_type == 0)
{
/* S0 - starting record (optional) */
int iValue;
if (record_type == 0)
{
/* S0 - starting record (optional) */
int iValue;
while (count-- > 0) {
sscanf(&lpszLine[bytes_read], "%2x", &iValue);
cal_checksum += (u8)iValue;
while (count-- > 0) {
sscanf(&lpszLine[bytes_read], "%2x", &iValue);
cal_checksum += (u8)iValue;
bytes_read += 4;
count -=2;
break;
bytes_read += 4;
count -=2;
break;
case 2:
/* S2 - 24 bit address data record */
sscanf(&lpszLine[bytes_read], "%6x", &address);
case 2:
/* S2 - 24 bit address data record */
sscanf(&lpszLine[bytes_read], "%6x", &address);
bytes_read += 6;
count -=3;
break;
bytes_read += 6;
count -=3;
break;
case 3:
/* S3 - 32 bit address data record */
sscanf(&lpszLine[bytes_read], "%8x", &address);
case 3:
/* S3 - 32 bit address data record */
sscanf(&lpszLine[bytes_read], "%8x", &address);
if (full_address != address)
{
/* we encountered a nonconsecutive location, create a new section,
if (full_address != address)
{
/* we encountered a nonconsecutive location, create a new section,
section[image->num_sections].base_address = address;
full_address = address;
}
section[image->num_sections].base_address = address;
full_address = address;
}
while (count-- > 0)
{
sscanf(&lpszLine[bytes_read], "%2x", (u32*)&mot->buffer[cooked_bytes]);
while (count-- > 0)
{
sscanf(&lpszLine[bytes_read], "%2x", (u32*)&mot->buffer[cooked_bytes]);
{
/* S5 is the data count record, we ignore it */
u32 dummy;
{
/* S5 is the data count record, we ignore it */
u32 dummy;
while (count-- > 0)
{
sscanf(&lpszLine[bytes_read], "%2x", &dummy);
while (count-- > 0)
{
sscanf(&lpszLine[bytes_read], "%2x", &dummy);
{
/* S7, S8, S9 - ending records for 32, 24 and 16bit */
image->num_sections++;
{
/* S7, S8, S9 - ending records for 32, 24 and 16bit */
image->num_sections++;
/* copy section information */
image->sections = malloc(sizeof(image_section_t) * image->num_sections);
for (i = 0; i < image->num_sections; i++)
/* copy section information */
image->sections = malloc(sizeof(image_section_t) * image->num_sections);
for (i = 0; i < image->num_sections; i++)
image->sections[i].size = section[i].size;
image->sections[i].flags = section[i].flags;
}
image->sections[i].size = section[i].size;
image->sections[i].flags = section[i].flags;
}
ERROR("unhandled S19 record type: %i", record_type);
return ERROR_IMAGE_FORMAT_ERROR;
}
ERROR("unhandled S19 record type: %i", record_type);
return ERROR_IMAGE_FORMAT_ERROR;
}
/* account for checksum, will always be 0xFF */
sscanf(&lpszLine[bytes_read], "%2x", &checksum);
cal_checksum += (u8)checksum;
bytes_read += 2;
/* account for checksum, will always be 0xFF */
sscanf(&lpszLine[bytes_read], "%2x", &checksum);
cal_checksum += (u8)checksum;
bytes_read += 2;
if( cal_checksum != 0xFF )
{
/* checksum failed */
if( cal_checksum != 0xFF )
{
/* checksum failed */
return ERROR_IMAGE_CHECKSUM;
}
}
return ERROR_IMAGE_CHECKSUM;
}
}
ERROR("premature end of S19 file, no end-of-file record found");
return ERROR_IMAGE_FORMAT_ERROR;
}
ERROR("premature end of S19 file, no end-of-file record found");
return ERROR_IMAGE_FORMAT_ERROR;
}
int image_open(image_t *image, char *url, char *type_string)
{
int retval = ERROR_OK;
int image_open(image_t *image, char *url, char *type_string)
{
int retval = ERROR_OK;
if ((retval = identify_image_type(image, type_string, url)) != ERROR_OK)
{
return retval;
}
if ((retval = identify_image_type(image, type_string, url)) != ERROR_OK)
{
return retval;
}
if (image->type == IMAGE_BINARY)
{
image_binary_t *image_binary;
if (image->type == IMAGE_BINARY)
{
image_binary_t *image_binary;
image_binary = image->type_private = malloc(sizeof(image_binary_t));
image_binary = image->type_private = malloc(sizeof(image_binary_t));
if ((retval = fileio_open(&image_binary->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
{
if ((retval = fileio_open(&image_binary->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
{
- strncpy(image->error_str, image_binary->fileio.error_str, IMAGE_MAX_ERROR_STRING);
+ strncpy(image->error_str, image_binary->fileio.error_str, IMAGE_MAX_ERROR_STRING);
ERROR(image->error_str);
return retval;
}
ERROR(image->error_str);
return retval;
}
image->num_sections = 1;
image->sections = malloc(sizeof(image_section_t));
image->sections[0].base_address = 0x0;
image->num_sections = 1;
image->sections = malloc(sizeof(image_section_t));
image->sections[0].base_address = 0x0;
else if (image->type == IMAGE_IHEX)
{
image_ihex_t *image_ihex;
else if (image->type == IMAGE_IHEX)
{
image_ihex_t *image_ihex;
image_ihex = image->type_private = malloc(sizeof(image_ihex_t));
image_ihex = image->type_private = malloc(sizeof(image_ihex_t));
if ((retval = fileio_open(&image_ihex->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
{
if ((retval = fileio_open(&image_ihex->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
{
- strncpy(image->error_str, image_ihex->fileio.error_str, IMAGE_MAX_ERROR_STRING);
+ strncpy(image->error_str, image_ihex->fileio.error_str, IMAGE_MAX_ERROR_STRING);
ERROR(image->error_str);
return retval;
}
ERROR(image->error_str);
return retval;
}
if ((retval = image_ihex_buffer_complete(image)) != ERROR_OK)
{
snprintf(image->error_str, IMAGE_MAX_ERROR_STRING,
if ((retval = image_ihex_buffer_complete(image)) != ERROR_OK)
{
snprintf(image->error_str, IMAGE_MAX_ERROR_STRING,
else if (image->type == IMAGE_ELF)
{
image_elf_t *image_elf;
else if (image->type == IMAGE_ELF)
{
image_elf_t *image_elf;
image_elf = image->type_private = malloc(sizeof(image_elf_t));
image_elf = image->type_private = malloc(sizeof(image_elf_t));
if ((retval = fileio_open(&image_elf->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
{
if ((retval = fileio_open(&image_elf->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
{
- strncpy(image->error_str, image_elf->fileio.error_str, IMAGE_MAX_ERROR_STRING);
+ strncpy(image->error_str, image_elf->fileio.error_str, IMAGE_MAX_ERROR_STRING);
ERROR(image->error_str);
return retval;
}
ERROR(image->error_str);
return retval;
}
if ((retval = image_elf_read_headers(image)) != ERROR_OK)
{
snprintf(image->error_str, IMAGE_MAX_ERROR_STRING,
if ((retval = image_elf_read_headers(image)) != ERROR_OK)
{
snprintf(image->error_str, IMAGE_MAX_ERROR_STRING,
else if (image->type == IMAGE_MEMORY)
{
image_memory_t *image_memory;
else if (image->type == IMAGE_MEMORY)
{
image_memory_t *image_memory;
image->num_sections = 1;
image->sections = malloc(sizeof(image_section_t));
image->sections[0].base_address = 0x0;
image->sections[0].size = 0xffffffff;
image->sections[0].flags = 0;
image->num_sections = 1;
image->sections = malloc(sizeof(image_section_t));
image->sections[0].base_address = 0x0;
image->sections[0].size = 0xffffffff;
image->sections[0].flags = 0;
image_memory = image->type_private = malloc(sizeof(image_memory_t));
image_memory = image->type_private = malloc(sizeof(image_memory_t));
image_memory->target = get_target_by_num(strtoul(url, NULL, 0));;
image_memory->cache = NULL;
image_memory->cache_address = 0x0;
image_memory->target = get_target_by_num(strtoul(url, NULL, 0));;
image_memory->cache = NULL;
image_memory->cache_address = 0x0;
else if (image->type == IMAGE_SRECORD)
{
image_mot_t *image_mot;
else if (image->type == IMAGE_SRECORD)
{
image_mot_t *image_mot;
image_mot = image->type_private = malloc(sizeof(image_mot_t));
image_mot = image->type_private = malloc(sizeof(image_mot_t));
if ((retval = fileio_open(&image_mot->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
{
if ((retval = fileio_open(&image_mot->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
{
- strncpy(image->error_str, image_mot->fileio.error_str, IMAGE_MAX_ERROR_STRING);
+ strncpy(image->error_str, image_mot->fileio.error_str, IMAGE_MAX_ERROR_STRING);
ERROR(image->error_str);
return retval;
}
ERROR(image->error_str);
return retval;
}
if ((retval = image_mot_buffer_complete(image)) != ERROR_OK)
{
snprintf(image->error_str, IMAGE_MAX_ERROR_STRING,
if ((retval = image_mot_buffer_complete(image)) != ERROR_OK)
{
snprintf(image->error_str, IMAGE_MAX_ERROR_STRING,
image->base_address = 0;
image->base_address_set = 0;
}
image->base_address = 0;
image->base_address_set = 0;
}
if (image->type == IMAGE_BINARY)
{
image_binary_t *image_binary = image->type_private;
if (image->type == IMAGE_BINARY)
{
image_binary_t *image_binary = image->type_private;
/* only one section in a plain binary */
if (section != 0)
return ERROR_INVALID_ARGUMENTS;
/* only one section in a plain binary */
if (section != 0)
return ERROR_INVALID_ARGUMENTS;
/* seek to offset */
if ((retval = fileio_seek(&image_binary->fileio, offset)) != ERROR_OK)
{
strncpy(image->error_str, image_binary->fileio.error_str, IMAGE_MAX_ERROR_STRING);
return retval;
}
/* seek to offset */
if ((retval = fileio_seek(&image_binary->fileio, offset)) != ERROR_OK)
{
strncpy(image->error_str, image_binary->fileio.error_str, IMAGE_MAX_ERROR_STRING);
return retval;
}
/* return requested bytes */
if ((retval = fileio_read(&image_binary->fileio, size, buffer, size_read)) != ERROR_OK)
{
/* return requested bytes */
if ((retval = fileio_read(&image_binary->fileio, size, buffer, size_read)) != ERROR_OK)
{
memcpy(buffer, (u8*)image->sections[section].private + offset, size);
*size_read = size;
image->error_str[0] = '\0';
memcpy(buffer, (u8*)image->sections[section].private + offset, size);
*size_read = size;
image->error_str[0] = '\0';
return ERROR_OK;
}
else if (image->type == IMAGE_ELF)
return ERROR_OK;
}
else if (image->type == IMAGE_ELF)
{
image_memory_t *image_memory = image->type_private;
u32 address = image->sections[section].base_address + offset;
{
image_memory_t *image_memory = image->type_private;
u32 address = image->sections[section].base_address + offset;
while ((size - *size_read) > 0)
{
u32 size_in_cache;
while ((size - *size_read) > 0)
{
u32 size_in_cache;
if (!image_memory->cache
|| (address < image_memory->cache_address)
|| (address >= (image_memory->cache_address + IMAGE_MEMORY_CACHE_SIZE)))
{
if (!image_memory->cache)
image_memory->cache = malloc(IMAGE_MEMORY_CACHE_SIZE);
if (!image_memory->cache
|| (address < image_memory->cache_address)
|| (address >= (image_memory->cache_address + IMAGE_MEMORY_CACHE_SIZE)))
{
if (!image_memory->cache)
image_memory->cache = malloc(IMAGE_MEMORY_CACHE_SIZE);
if (target_read_buffer(image_memory->target, address & ~(IMAGE_MEMORY_CACHE_SIZE - 1),
IMAGE_MEMORY_CACHE_SIZE, image_memory->cache) != ERROR_OK)
{
if (target_read_buffer(image_memory->target, address & ~(IMAGE_MEMORY_CACHE_SIZE - 1),
IMAGE_MEMORY_CACHE_SIZE, image_memory->cache) != ERROR_OK)
{
}
image_memory->cache_address = address & ~(IMAGE_MEMORY_CACHE_SIZE - 1);
}
}
image_memory->cache_address = address & ~(IMAGE_MEMORY_CACHE_SIZE - 1);
}
size_in_cache = (image_memory->cache_address + IMAGE_MEMORY_CACHE_SIZE) - address;
size_in_cache = (image_memory->cache_address + IMAGE_MEMORY_CACHE_SIZE) - address;
memcpy(buffer + *size_read,
image_memory->cache + (address - image_memory->cache_address),
(size_in_cache > size) ? size : size_in_cache
);
memcpy(buffer + *size_read,
image_memory->cache + (address - image_memory->cache_address),
(size_in_cache > size) ? size : size_in_cache
);
*size_read += (size_in_cache > size) ? size : size_in_cache;
address += (size_in_cache > size) ? size : size_in_cache;
}
*size_read += (size_in_cache > size) ? size : size_in_cache;
address += (size_in_cache > size) ? size : size_in_cache;
}
memcpy(buffer, (u8*)image->sections[section].private + offset, size);
*size_read = size;
image->error_str[0] = '\0';
memcpy(buffer, (u8*)image->sections[section].private + offset, size);
*size_read = size;
image->error_str[0] = '\0';
return ERROR_OK;
}
else if (image->type == IMAGE_BUILDER)
return ERROR_OK;
}
else if (image->type == IMAGE_BUILDER)
memcpy(buffer, (u8*)image->sections[section].private + offset, size);
*size_read = size;
image->error_str[0] = '\0';
memcpy(buffer, (u8*)image->sections[section].private + offset, size);
*size_read = size;
image->error_str[0] = '\0';
return ERROR_OK;
}
int image_add_section(image_t *image, u32 base, u32 size, int flags, u8 *data)
{
image_section_t *section;
return ERROR_OK;
}
int image_add_section(image_t *image, u32 base, u32 size, int flags, u8 *data)
{
image_section_t *section;
/* only image builder supports adding sections */
if (image->type != IMAGE_BUILDER)
return ERROR_INVALID_ARGUMENTS;
/* only image builder supports adding sections */
if (image->type != IMAGE_BUILDER)
return ERROR_INVALID_ARGUMENTS;
/* see if there's a previous section */
if (image->num_sections)
{
section = &image->sections[image->num_sections - 1];
/* see if there's a previous section */
if (image->num_sections)
{
section = &image->sections[image->num_sections - 1];
/* see if it's enough to extend the last section,
* adding data to previous sections or merging is not supported */
if (((section->base_address + section->size) == base) && (section->flags == flags))
/* see if it's enough to extend the last section,
* adding data to previous sections or merging is not supported */
if (((section->base_address + section->size) == base) && (section->flags == flags))
/* allocate new section */
image->num_sections++;
image->sections = realloc(image->sections, sizeof(image_section_t) * image->num_sections);
/* allocate new section */
image->num_sections++;
image->sections = realloc(image->sections, sizeof(image_section_t) * image->num_sections);
section->flags = flags;
section->private = malloc(sizeof(u8) * size);
memcpy((u8*)section->private, data, size);
section->flags = flags;
section->private = malloc(sizeof(u8) * size);
memcpy((u8*)section->private, data, size);
if (image->type == IMAGE_BINARY)
{
image_binary_t *image_binary = image->type_private;
if (image->type == IMAGE_BINARY)
{
image_binary_t *image_binary = image->type_private;
fileio_close(&image_binary->fileio);
}
else if (image->type == IMAGE_IHEX)
{
image_ihex_t *image_ihex = image->type_private;
fileio_close(&image_binary->fileio);
}
else if (image->type == IMAGE_IHEX)
{
image_ihex_t *image_ihex = image->type_private;
fileio_close(&image_ihex->fileio);
fileio_close(&image_ihex->fileio);
if (image_ihex->buffer)
{
free(image_ihex->buffer);
if (image_ihex->buffer)
{
free(image_ihex->buffer);
else if (image->type == IMAGE_ELF)
{
image_elf_t *image_elf = image->type_private;
else if (image->type == IMAGE_ELF)
{
image_elf_t *image_elf = image->type_private;
fileio_close(&image_elf->fileio);
fileio_close(&image_elf->fileio);
if (image_elf->header)
{
free(image_elf->header);
if (image_elf->header)
{
free(image_elf->header);
else if (image->type == IMAGE_MEMORY)
{
image_memory_t *image_memory = image->type_private;
else if (image->type == IMAGE_MEMORY)
{
image_memory_t *image_memory = image->type_private;
if (image_memory->cache)
{
free(image_memory->cache);
if (image_memory->cache)
{
free(image_memory->cache);
else if (image->type == IMAGE_SRECORD)
{
image_mot_t *image_mot = image->type_private;
else if (image->type == IMAGE_SRECORD)
{
image_mot_t *image_mot = image->type_private;
fileio_close(&image_mot->fileio);
fileio_close(&image_mot->fileio);
if (image_mot->buffer)
{
free(image_mot->buffer);
if (image_mot->buffer)
{
free(image_mot->buffer);
else if (image->type == IMAGE_BUILDER)
{
int i;
else if (image->type == IMAGE_BUILDER)
{
int i;
for (i = 0; i < image->num_sections; i++)
{
free(image->sections[i].private);
for (i = 0; i < image->num_sections; i++)
{
free(image->sections[i].private);
free(image->type_private);
image->type_private = NULL;
}
free(image->type_private);
image->type_private = NULL;
}
if (image->sections)
{
free(image->sections);
image->sections = NULL;
}
if (image->sections)
{
free(image->sections);
image->sections = NULL;
}
int image_calculate_checksum(u8* buffer, u32 nbytes, u32* checksum)
{
u32 crc = 0xffffffff;
int image_calculate_checksum(u8* buffer, u32 nbytes, u32* checksum)
{
u32 crc = 0xffffffff;
if (!crc32_table[1])
{
/* Initialize the CRC table and the decoding table. */
if (!crc32_table[1])
{
/* Initialize the CRC table and the decoding table. */
while (nbytes--)
{
/* as per gdb */
crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buffer++) & 255];
}
while (nbytes--)
{
/* as per gdb */
crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buffer++) & 255];
}
*checksum = crc;
return ERROR_OK;
}
*checksum = crc;
return ERROR_OK;
}
int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
+ const int line_bytecnt = 32;
int count = 1;
int size = 4;
int count = 1;
int size = 4;
+ u32 address = 0;
+ int line_modulo;
switch (cmd[2])
{
case 'w':
switch (cmd[2])
{
case 'w':
+ size = 4; line_modulo = line_bytecnt / 4;
+ size = 2; line_modulo = line_bytecnt / 2;
+ size = 1; line_modulo = line_bytecnt / 1;
break;
default:
return ERROR_OK;
}
buffer = calloc(count, size);
break;
default:
return ERROR_OK;
}
buffer = calloc(count, size);
- if ((retval = target->type->read_memory(target, address, size, count, buffer)) != ERROR_OK)
+ retval = target->type->read_memory(target, address, size, count, buffer);
+ if (retval != ERROR_OK)
for (i = 0; i < count; i++)
{
for (i = 0; i < count; i++)
{
+ if (i%line_modulo == 0)
output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
switch (size)
output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
switch (size)
- if ((i%8 == 7) || (i == count - 1))
+ if ((i%line_modulo == line_modulo-1) || (i == count - 1))
{
command_print(cmd_ctx, output);
output_len = 0;
{
command_print(cmd_ctx, output);
output_len = 0;
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)