More precise, less code.
- removed unused code in fileio.c
- Windows should now find debug_handler.bin
git-svn-id: svn://svn.berlios.de/openocd/trunk@390
b42882b7-edfa-0310-969c-
e2dbd0fdcd60
if (image_open(&image, info->driverPath, NULL) != ERROR_OK)
{
if (image_open(&image, info->driverPath, NULL) != ERROR_OK)
{
- ERROR("load_image error: %s", image.error_str);
return ERROR_FLASH_BANK_INVALID;
}
return ERROR_FLASH_BANK_INVALID;
}
retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL);
if (retval != ERROR_OK)
{
retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL);
if (retval != ERROR_OK)
{
- command_print(cmd_ctx, "image_open error: %s", image.error_str);
if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
{
if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
{
- command_print(cmd_ctx, "flash write_binary error: %s", fileio.error_str);
return ERROR_OK;
}
buffer = malloc(fileio.size);
if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
{
return ERROR_OK;
}
buffer = malloc(fileio.size);
if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
{
- command_print(cmd_ctx, "flash write_binary error: %s", fileio.error_str);
if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
{
if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
{
- command_print(cmd_ctx, "file open error: %s", fileio.error_str);
if (fileio_open(&fileio, args[1], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
{
if (fileio_open(&fileio, args[1], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
{
- command_print(cmd_ctx, "dump_image error: %s", fileio.error_str);
#include "types.h"
#include "replacements.h"
#include "log.h"
#include "types.h"
#include "replacements.h"
#include "log.h"
+#include "configuration.h"
int fileio_open_local(fileio_t *fileio)
{
int fileio_open_local(fileio_t *fileio)
{
- fileio_local_t *fileio_local = malloc(sizeof(fileio_local_t));
char access[4];
switch (fileio->access)
char access[4];
switch (fileio->access)
strcpy(access, "a+");
break;
default:
strcpy(access, "a+");
break;
default:
ERROR("BUG: access neither read, write nor readwrite");
return ERROR_INVALID_ARGUMENTS;
}
ERROR("BUG: access neither read, write nor readwrite");
return ERROR_INVALID_ARGUMENTS;
}
/* win32 always opens in binary mode */
#ifndef _WIN32
if (fileio->type == FILEIO_BINARY)
/* win32 always opens in binary mode */
#ifndef _WIN32
if (fileio->type == FILEIO_BINARY)
- if (!(fileio_local->file = fopen(fileio->url, access)))
+ if (!(fileio->file = open_file_from_path (fileio->url, access)))
- free(fileio_local);
- snprintf(fileio->error_str, FILEIO_MAX_ERROR_STRING, "couldn't open %s", fileio->url);
+ ERROR("couldn't open %s", fileio->url);
return ERROR_FILEIO_OPERATION_FAILED;
}
return ERROR_FILEIO_OPERATION_FAILED;
}
* that refers to e.g. a tftp client */
int result, result2;
* that refers to e.g. a tftp client */
int result, result2;
- result = fseek(fileio_local->file, 0, SEEK_END);
-
- fileio->size = ftell(fileio_local->file);
+ result = fseek(fileio->file, 0, SEEK_END);
+
+ fileio->size = ftell(fileio->file);
- result2 = fseek(fileio_local->file, 0, SEEK_SET);
+ result2 = fseek(fileio->file, 0, SEEK_SET);
- if ((fileio->size < 0) || (result < 0) || (result2 < 0))
+ if ((fileio->size<0)||(result<0)||(result2<0))
{
fileio_close(fileio);
return ERROR_FILEIO_OPERATION_FAILED;
{
fileio_close(fileio);
return ERROR_FILEIO_OPERATION_FAILED;
- fileio->location_private = fileio_local;
-
return ERROR_OK;
}
int fileio_open(fileio_t *fileio, char *url, enum fileio_access access, enum fileio_type type)
{
int retval = ERROR_OK;
return ERROR_OK;
}
int fileio_open(fileio_t *fileio, char *url, enum fileio_access access, enum fileio_type type)
{
int retval = ERROR_OK;
- char *resource_identifier = NULL;
- /* try to identify file location. We only hijack the file paths we understand, the rest is
- * passed on to the OS which might implement e.g. tftp via a mounted tftp device.
- */
- if ((resource_identifier = strstr(url, "bootp://")) && (resource_identifier == url))
- {
- ERROR("bootp resource location isn't supported yet");
- return ERROR_FILEIO_RESOURCE_TYPE_UNKNOWN;
- }
- else
- {
- /* default to local files */
- fileio->location = FILEIO_LOCAL;
- }
-
fileio->type = type;
fileio->access = access;
fileio->url = strdup(url);
fileio->type = type;
fileio->access = access;
fileio->url = strdup(url);
- switch (fileio->location)
- {
- case FILEIO_LOCAL:
- retval = fileio_open_local(fileio);
- break;
- default:
- ERROR("BUG: should never get here");
- exit(-1);
- }
-
- if (retval != ERROR_OK)
- return retval;
-
- return ERROR_OK;
+ retval = fileio_open_local(fileio);
+
+ return retval;
}
int fileio_close_local(fileio_t *fileio)
{
int retval;
}
int fileio_close_local(fileio_t *fileio)
{
int retval;
- fileio_local_t *fileio_local = fileio->location_private;
-
- if (fileio->location_private == NULL)
- {
- snprintf(fileio->error_str, FILEIO_MAX_ERROR_STRING, "couldn't close %s: ", fileio->url);
- return ERROR_FILEIO_OPERATION_FAILED;
- }
-
- if ((retval = fclose(fileio_local->file)) != 0)
+ if ((retval = fclose(fileio->file)) != 0)
- snprintf(fileio->error_str, FILEIO_MAX_ERROR_STRING, "BUG: fileio_local->file not a valid file descriptor");
+ ERROR("BUG: fileio_local->file not a valid file descriptor");
- snprintf(fileio->error_str, FILEIO_MAX_ERROR_STRING, "couldn't close %s: %s", fileio->url, strerror(errno));
+ ERROR("couldn't close %s: %s", fileio->url, strerror(errno));
}
return ERROR_FILEIO_OPERATION_FAILED;
}
}
return ERROR_FILEIO_OPERATION_FAILED;
}
- free(fileio->location_private);
- fileio->location_private = NULL;
-
- switch (fileio->location)
- {
- case FILEIO_LOCAL:
- retval = fileio_close_local(fileio);
- break;
- default:
- ERROR("BUG: should never get here");
- retval = ERROR_FILEIO_OPERATION_FAILED;
- }
-
- if (retval != ERROR_OK)
- return retval;
+ retval = fileio_close_local(fileio);
free(fileio->url);
fileio->url = NULL;
free(fileio->url);
fileio->url = NULL;
-int fileio_seek_local(fileio_t *fileio, u32 position)
+int fileio_seek(fileio_t *fileio, u32 position)
- fileio_local_t *fileio_local = fileio->location_private;
-
- if ((retval = fseek(fileio_local->file, position, SEEK_SET)) != 0)
+ if ((retval = fseek(fileio->file, position, SEEK_SET)) != 0)
- snprintf(fileio->error_str, FILEIO_MAX_ERROR_STRING, "couldn't seek file %s: %s", fileio->url, strerror(errno));
+ ERROR("couldn't seek file %s: %s", fileio->url, strerror(errno));
return ERROR_FILEIO_OPERATION_FAILED;
}
return ERROR_OK;
}
return ERROR_FILEIO_OPERATION_FAILED;
}
return ERROR_OK;
}
-int fileio_seek(fileio_t *fileio, u32 position)
-{
- switch (fileio->location)
- {
- case FILEIO_LOCAL:
- return fileio_seek_local(fileio, position);
- break;
- default:
- ERROR("BUG: should never get here");
- }
-
- return ERROR_OK;
-}
-
int fileio_local_read(fileio_t *fileio, u32 size, u8 *buffer, u32 *size_read)
{
int fileio_local_read(fileio_t *fileio, u32 size, u8 *buffer, u32 *size_read)
{
- fileio_local_t *fileio_local = fileio->location_private;
-
- *size_read = fread(buffer, 1, size, fileio_local->file);
+ *size_read = fread(buffer, 1, size, fileio->file);
return ERROR_OK;
}
int fileio_read(fileio_t *fileio, u32 size, u8 *buffer, u32 *size_read)
{
return ERROR_OK;
}
int fileio_read(fileio_t *fileio, u32 size, u8 *buffer, u32 *size_read)
{
- switch (fileio->location)
- {
- case FILEIO_LOCAL:
- return fileio_local_read(fileio, size, buffer, size_read);
- break;
- default:
- ERROR("BUG: should never get here");
- exit(-1);
- }
+ return fileio_local_read(fileio, size, buffer, size_read);
}
int fileio_read_u32(fileio_t *fileio, u32 *data)
}
int fileio_read_u32(fileio_t *fileio, u32 *data)
u32 size_read;
int retval;
u32 size_read;
int retval;
- switch (fileio->location)
- {
- case FILEIO_LOCAL:
- if ((retval = fileio_local_read(fileio, 4, buf, &size_read)) != ERROR_OK)
- return retval;
- *data = be_to_h_u32(buf);
- break;
- default:
- ERROR("BUG: should never get here");
- exit(-1);
- }
+ if ((retval = fileio_local_read(fileio, 4, buf, &size_read)) != ERROR_OK)
+ return retval;
+ *data = be_to_h_u32(buf);
return ERROR_OK;
}
int fileio_local_fgets(fileio_t *fileio, u32 size, u8 *buffer)
{
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)
+ if( fgets(buffer, size, fileio->file) == NULL)
return ERROR_FILEIO_OPERATION_FAILED;
return ERROR_OK;
return ERROR_FILEIO_OPERATION_FAILED;
return ERROR_OK;
int fileio_fgets(fileio_t *fileio, u32 size, u8 *buffer)
{
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);
- }
+ return fileio_local_fgets(fileio, size, buffer);
}
int fileio_local_write(fileio_t *fileio, u32 size, u8 *buffer, u32 *size_written)
{
}
int fileio_local_write(fileio_t *fileio, u32 size, u8 *buffer, u32 *size_written)
{
- fileio_local_t *fileio_local = fileio->location_private;
-
- *size_written = fwrite(buffer, 1, size, fileio_local->file);
+ *size_written = fwrite(buffer, 1, size, fileio->file);
- switch (fileio->location)
- {
- case FILEIO_LOCAL:
- retval = fileio_local_write(fileio, size, buffer, size_written);
- break;
- default:
- ERROR("BUG: should never get here");
- exit(-1);
- }
+ retval = fileio_local_write(fileio, size, buffer, size_written);
if (retval == ERROR_OK)
fileio->size += *size_written;
if (retval == ERROR_OK)
fileio->size += *size_written;
- switch (fileio->location)
- {
- case FILEIO_LOCAL:
- if ((retval = fileio_local_write(fileio, 4, buf, &size_written)) != ERROR_OK)
- return retval;
- break;
- default:
- ERROR("BUG: should never get here");
- }
+ if ((retval = fileio_local_write(fileio, 4, buf, &size_written)) != ERROR_OK)
+ return retval;
-enum fileio_location
-{
- FILEIO_LOCAL,
-/*
- * Possible future enhancements:
- * FILEIO_NFS,
- * FILEIO_BOOTP,
- * FILEIO_[XYZ]MODEM,
- * FILEIO_HTTP,
- * FILEIO_FTP,
- */
-};
typedef struct fileio_s
{
char *url;
typedef struct fileio_s
{
char *url;
- char error_str[FILEIO_MAX_ERROR_STRING];
long long size;
enum fileio_type type;
long long size;
enum fileio_type type;
- enum fileio_location location;
enum fileio_access access;
enum fileio_access access;
- void *location_private;
-} fileio_t;
-
-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_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);
{
if (retval == ERROR_JTAG_RESET_WOULD_ASSERT_TRST)
{
{
if (retval == ERROR_JTAG_RESET_WOULD_ASSERT_TRST)
{
- WARNING("srst resets test logic, too");
retval = jtag_add_reset(1, 1);
}
}
retval = jtag_add_reset(1, 1);
}
}
{
if (retval == ERROR_JTAG_RESET_WOULD_ASSERT_TRST)
{
{
if (retval == ERROR_JTAG_RESET_WOULD_ASSERT_TRST)
{
- WARNING("srst resets test logic, too");
retval = jtag_add_reset(1, 1);
}
retval = jtag_add_reset(1, 1);
}
case 2:
max_port_size = 16;
break;
case 2:
max_port_size = 16;
break;
+ default:
+ ERROR("Illegal max_port_size");
+ exit(-1);
}
command_print(cmd_ctx, "max. port size: %i", max_port_size);
}
command_print(cmd_ctx, "max. port size: %i", max_port_size);
if (image_open(etm_ctx->image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
{
if (image_open(etm_ctx->image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
{
- command_print(cmd_ctx, "image opening error: %s", etm_ctx->image->error_str);
free(etm_ctx->image);
etm_ctx->image = NULL;
return ERROR_OK;
free(etm_ctx->image);
etm_ctx->image = NULL;
return ERROR_OK;
if (fileio_open(&file, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
{
if (fileio_open(&file, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
{
- command_print(cmd_ctx, "file open error: %s", file.error_str);
if (fileio_open(&file, args[0], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
{
if (fileio_open(&file, args[0], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
{
- command_print(cmd_ctx, "file open error: %s", file.error_str);
#include "target.h"
/* convert ELF header field to host endianness */
#include "target.h"
/* 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))
+#define field16(elf,field)\
+ ((elf->endianness==ELFDATA2LSB)? \
+ le_to_h_u16((u8*)&field):be_to_h_u16((u8*)&field))
-#define field32(elf, field)\
- ((elf->endianness == ELFDATA2LSB)? \
- le_to_h_u32((u8*)&field) : be_to_h_u32((u8*)&field))
+#define field32(elf,field)\
+ ((elf->endianness==ELFDATA2LSB)? \
+ 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);
- ERROR(image->error_str);
return retval;
}
if ((retval = fileio_read(&fileio, 9, buffer, &read_bytes)) != ERROR_OK)
{
return retval;
}
if ((retval = fileio_read(&fileio, 9, buffer, &read_bytes)) != ERROR_OK)
{
- snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, "cannot read image header: %s", fileio.error_str);
- ERROR(image->error_str);
return ERROR_FILEIO_OPERATION_FAILED;
}
if (read_bytes != 9)
{
return ERROR_FILEIO_OPERATION_FAILED;
}
if (read_bytes != 9)
{
- snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, "cannot read image, only partially read");
- ERROR(image->error_str);
return ERROR_FILEIO_OPERATION_FAILED;
}
fileio_close(&fileio);
return ERROR_FILEIO_OPERATION_FAILED;
}
fileio_close(&fileio);
DEBUG("ELF image detected.");
image->type = IMAGE_ELF;
}
DEBUG("ELF image detected.");
image->type = IMAGE_ELF;
}
- else if ((buffer[0] == ':') /* record start byte */
+ else if ((buffer[0]==':') /* record start byte */
&&(isxdigit(buffer[1]))
&&(isxdigit(buffer[2]))
&&(isxdigit(buffer[3]))
&&(isxdigit(buffer[4]))
&&(isxdigit(buffer[5]))
&&(isxdigit(buffer[6]))
&&(isxdigit(buffer[1]))
&&(isxdigit(buffer[2]))
&&(isxdigit(buffer[3]))
&&(isxdigit(buffer[4]))
&&(isxdigit(buffer[5]))
&&(isxdigit(buffer[6]))
- &&(buffer[7] == '0') /* record type : 00 -> 05 */
- &&(buffer[8] >= '0') && (buffer[8] < '6'))
+ &&(buffer[7]=='0') /* record type : 00 -> 05 */
+ &&(buffer[8]>='0')&&(buffer[8]<'6'))
{
DEBUG("IHEX image detected.");
image->type = IMAGE_IHEX;
{
DEBUG("IHEX image detected.");
image->type = IMAGE_IHEX;
{
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;
}
return ERROR_FILEIO_OPERATION_FAILED;
}
return ERROR_FILEIO_OPERATION_FAILED;
}
- if (strncmp((char*)elf->header->e_ident,ELFMAG,SELFMAG) != 0)
+ if (strncmp((char*)elf->header->e_ident,ELFMAG,SELFMAG)!=0)
{
ERROR("invalid ELF file, bad magic number");
return ERROR_IMAGE_FORMAT_ERROR;
}
{
ERROR("invalid ELF file, bad magic number");
return ERROR_IMAGE_FORMAT_ERROR;
}
- if (elf->header->e_ident[EI_CLASS] != ELFCLASS32)
+ if (elf->header->e_ident[EI_CLASS]!=ELFCLASS32)
{
ERROR("invalid ELF file, only 32bits files are supported");
return ERROR_IMAGE_FORMAT_ERROR;
{
ERROR("invalid ELF file, only 32bits files are supported");
return ERROR_IMAGE_FORMAT_ERROR;
elf->endianness = elf->header->e_ident[EI_DATA];
elf->endianness = elf->header->e_ident[EI_DATA];
- if ((elf->endianness != ELFDATA2LSB)
- &&(elf->endianness != ELFDATA2MSB))
+ if ((elf->endianness!=ELFDATA2LSB)
+ &&(elf->endianness!=ELFDATA2MSB))
{
ERROR("invalid ELF file, unknown endianess setting");
return ERROR_IMAGE_FORMAT_ERROR;
}
{
ERROR("invalid ELF file, unknown endianess setting");
return ERROR_IMAGE_FORMAT_ERROR;
}
- elf->segment_count = field16(elf, elf->header->e_phnum);
- if (elf->segment_count == 0)
+ elf->segment_count = field16(elf,elf->header->e_phnum);
+ if (elf->segment_count==0)
{
ERROR("invalid ELF file, no program headers");
return ERROR_IMAGE_FORMAT_ERROR;
}
{
ERROR("invalid ELF file, no program headers");
return ERROR_IMAGE_FORMAT_ERROR;
}
- elf->segments = malloc(elf->segment_count * sizeof(Elf32_Phdr));
+ elf->segments = malloc(elf->segment_count*sizeof(Elf32_Phdr));
- if ((retval = fileio_read(&elf->fileio, elf->segment_count * sizeof(Elf32_Phdr), (u8*)elf->segments, &read_bytes)) != ERROR_OK)
+ if ((retval = fileio_read(&elf->fileio, elf->segment_count*sizeof(Elf32_Phdr), (u8*)elf->segments, &read_bytes)) != ERROR_OK)
{
ERROR("cannot read ELF segment headers, read failed");
return retval;
}
{
ERROR("cannot read ELF segment headers, read failed");
return retval;
}
- if (read_bytes != elf->segment_count * sizeof(Elf32_Phdr))
+ if (read_bytes != elf->segment_count*sizeof(Elf32_Phdr))
{
ERROR("cannot read ELF segment headers, only partially read");
return ERROR_FILEIO_OPERATION_FAILED;
{
ERROR("cannot read ELF segment headers, only partially read");
return ERROR_FILEIO_OPERATION_FAILED;
/* count useful segments (loadable), ignore BSS section */
image->num_sections = 0;
/* count useful segments (loadable), ignore BSS section */
image->num_sections = 0;
- for (i = 0; i < elf->segment_count; i++)
+ for (i=0;i<elf->segment_count;i++)
if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
image->num_sections++;
/* alloc and fill sections array with loadable segments */
image->sections = malloc(image->num_sections * sizeof(image_section_t));
if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
image->num_sections++;
/* alloc and fill sections array with loadable segments */
image->sections = malloc(image->num_sections * sizeof(image_section_t));
- for (i = 0, j = 0; i < elf->segment_count; i++)
+ for (i=0,j=0;i<elf->segment_count;i++)
{
if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
{
{
if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
{
- image->sections[j].size = field32(elf, elf->segments[i].p_filesz);
- image->sections[j].base_address = field32(elf, elf->segments[i].p_paddr);
+ image->sections[j].size = field32(elf,elf->segments[i].p_filesz);
+ image->sections[j].base_address = field32(elf,elf->segments[i].p_paddr);
image->sections[j].private = &elf->segments[i];
image->sections[j].private = &elf->segments[i];
- image->sections[j].flags = field32(elf, elf->segments[i].p_flags);
+ image->sections[j].flags = field32(elf,elf->segments[i].p_flags);
image->start_address_set = 1;
image->start_address_set = 1;
- image->start_address = field32(elf, elf->header->e_entry);
+ image->start_address = field32(elf,elf->header->e_entry);
{
image_elf_t *elf = image->type_private;
Elf32_Phdr *segment = (Elf32_Phdr *)image->sections[section].private;
{
image_elf_t *elf = image->type_private;
Elf32_Phdr *segment = (Elf32_Phdr *)image->sections[section].private;
- u32 read_size, really_read;
+ u32 read_size,really_read;
int retval;
*size_read = 0;
int retval;
*size_read = 0;
-
- DEBUG("load segment %d at 0x%x (sz = 0x%x)", section, offset, size);
+
+ DEBUG("load segment %d at 0x%x (sz=0x%x)",section,offset,size);
/* read initialized data in current segment if any */
/* read initialized data in current segment if any */
- if (offset < field32(elf, segment->p_filesz))
+ if (offset<field32(elf,segment->p_filesz))
{
/* maximal size present in file for the current segment */
{
/* maximal size present in file for the current segment */
- read_size = MIN(size, field32(elf, segment->p_filesz) - offset);
- DEBUG("read elf: size = 0x%x at 0x%x", read_size,
- field32(elf, segment->p_offset) + offset);
+ read_size = MIN(size, field32(elf,segment->p_filesz)-offset);
+ DEBUG("read elf: size = 0x%x at 0x%x",read_size,
+ field32(elf,segment->p_offset)+offset);
/* read initialized area of the segment */
/* read initialized area of the segment */
- if ((retval = fileio_seek(&elf->fileio, field32(elf, segment->p_offset) + offset)) != ERROR_OK)
+ if ((retval = fileio_seek(&elf->fileio, field32(elf,segment->p_offset)+offset)) != ERROR_OK)
{
ERROR("cannot find ELF segment content, seek failed");
return retval;
{
ERROR("cannot find ELF segment content, seek failed");
return retval;
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);
bytes_read += 8;
count -=4;
break;
bytes_read += 8;
count -=4;
break;
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);
- ERROR(image->error_str);
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);
- ERROR(image->error_str);
if ((retval = image_ihex_buffer_complete(image)) != ERROR_OK)
{
if ((retval = image_ihex_buffer_complete(image)) != ERROR_OK)
{
- snprintf(image->error_str, IMAGE_MAX_ERROR_STRING,
- "failed buffering IHEX image, check daemon output for additional information");
- ERROR(image->error_str);
+ ERROR("failed buffering IHEX image, check daemon output for additional information");
fileio_close(&image_ihex->fileio);
return retval;
}
fileio_close(&image_ihex->fileio);
return retval;
}
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);
- ERROR(image->error_str);
if ((retval = image_elf_read_headers(image)) != ERROR_OK)
{
if ((retval = image_elf_read_headers(image)) != ERROR_OK)
{
- snprintf(image->error_str, IMAGE_MAX_ERROR_STRING,
- "failed to read ELF headers, check daemon output for additional information");
- ERROR(image->error_str);
fileio_close(&image_elf->fileio);
return retval;
}
fileio_close(&image_elf->fileio);
return retval;
}
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);
- ERROR(image->error_str);
if ((retval = image_mot_buffer_complete(image)) != ERROR_OK)
{
if ((retval = image_mot_buffer_complete(image)) != ERROR_OK)
{
- snprintf(image->error_str, IMAGE_MAX_ERROR_STRING,
- "failed buffering S19 image, check daemon output for additional information");
- ERROR(image->error_str);
+ ERROR("failed buffering S19 image, check daemon output for additional information");
fileio_close(&image_mot->fileio);
return retval;
}
fileio_close(&image_mot->fileio);
return retval;
}
{
/* relocate */
int section;
{
/* relocate */
int section;
- for (section = 0; section < image->num_sections; section++)
+ for (section=0; section < image->num_sections; section++)
- image->sections[section].base_address += image->base_address;
+ image->sections[section].base_address+=image->base_address;
}
/* we're done relocating. The two statements below are mainly
* for documenation purposes: stop anyone from empirically
* thinking they should use these values henceforth. */
}
/* we're done relocating. The two statements below are mainly
* for documenation purposes: stop anyone from empirically
* thinking they should use these values henceforth. */
- 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)
{
/* 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 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)
{
- strncpy(image->error_str, image_binary->fileio.error_str, IMAGE_MAX_ERROR_STRING);
{
memcpy(buffer, (u8*)image->sections[section].private + offset, size);
*size_read = size;
{
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;
{
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)
{
memcpy(buffer, (u8*)image->sections[section].private + offset, size);
*size_read = size;
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';
-
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);
if (image_elf->header)
fileio_close(&image_elf->fileio);
if (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 base_address; /* base address, if one is set */
int start_address_set; /* whether the image has a start address (entry point) associated */
u32 start_address; /* start address, if one is set */
int base_address; /* base address, if one is set */
int start_address_set; /* whether the image has a start address (entry point) associated */
u32 start_address; /* start address, if one is set */
- char error_str[IMAGE_MAX_ERROR_STRING];
} image_t;
typedef struct image_binary_s
} image_t;
typedef struct image_binary_s
int xscale_receive(target_t *target, u32 *buffer, int num_words)
{
int xscale_receive(target_t *target, u32 *buffer, int num_words)
{
armv4_5_common_t *armv4_5 = target->arch_info;
xscale_common_t *xscale = armv4_5->arch_info;
armv4_5_common_t *armv4_5 = target->arch_info;
xscale_common_t *xscale = armv4_5->arch_info;
jtag_add_runtest(1, -1);
/* repeat until all words have been collected */
jtag_add_runtest(1, -1);
/* repeat until all words have been collected */
while (words_done < num_words)
{
/* schedule reads */
while (words_done < num_words)
{
/* schedule reads */
- if (words_scheduled == 0)
+ if (words_scheduled==0)
- if (attempts++ == 1000)
{
ERROR("Failed to receiving data from debug handler after 1000 attempts");
{
ERROR("Failed to receiving data from debug handler after 1000 attempts");
- retval = ERROR_JTAG_QUEUE_FAILED;
+ retval=ERROR_JTAG_QUEUE_FAILED;
noconsume_path[6] = TAP_SDS;
noconsume_path[7] = TAP_CD;
noconsume_path[8] = TAP_SD;
noconsume_path[6] = TAP_SDS;
noconsume_path[7] = TAP_CD;
noconsume_path[8] = TAP_SD;
fields[0].device = xscale->jtag_info.chain_pos;
fields[0].num_bits = 3;
fields[0].out_value = NULL;
fields[0].device = xscale->jtag_info.chain_pos;
fields[0].num_bits = 3;
fields[0].out_value = NULL;
{
jtag_set_check_value(fields+2, &field2_check_value, &field2_check_mask, NULL);
}
{
jtag_set_check_value(fields+2, &field2_check_value, &field2_check_mask, NULL);
}
if (size==4)
{
int endianness = target->endianness;
if (size==4)
{
int endianness = target->endianness;
{
while (done_count++ < count)
{
{
while (done_count++ < count)
{
- /* extract sized element from target-endian buffer, and put it
- * into little-endian output buffer
- */
- switch (size)
- {
- case 2:
- buf_set_u32(output, 0, 32, target_buffer_get_u16(target, buffer));
- break;
- case 1:
- output[0] = *buffer;
- break;
- default:
- ERROR("BUG: size neither 4, 2 nor 1");
- exit(-1);
- }
-
- jtag_add_dr_scan(3, fields, TAP_RTI);
- buffer += size;
- }
+ /* extract sized element from target-endian buffer, and put it
+ * into little-endian output buffer
+ */
+ switch (size)
+ {
+ case 2:
+ buf_set_u32(output, 0, 32, target_buffer_get_u16(target, buffer));
+ break;
+ case 1:
+ output[0] = *buffer;
+ break;
+ default:
+ ERROR("BUG: size neither 4, 2 nor 1");
+ exit(-1);
+ }
+ jtag_add_dr_scan(3, fields, TAP_RTI);
+ buffer += size;
+ }
+
}
if ((retval = jtag_execute_queue()) != ERROR_OK)
}
if ((retval = jtag_execute_queue()) != ERROR_OK)
/* here we "lie" so GDB won't get stuck and a reset can be perfomed */
target->state = TARGET_HALTED;
}
/* here we "lie" so GDB won't get stuck and a reset can be perfomed */
target->state = TARGET_HALTED;
}
-
- /* debug_entry could have overwritten target state (i.e. immediate resume)
- * don't signal event handlers in that case
- */
+
+ /* debug_entry could have overwritten target state (i.e. immediate resume)
+ * don't signal event handlers in that case
+ */
if (target->state != TARGET_HALTED)
return ERROR_OK;
if (target->state != TARGET_HALTED)
return ERROR_OK;
else
target_call_event_callbacks(target, TARGET_EVENT_DEBUG_HALTED);
}
else
target_call_event_callbacks(target, TARGET_EVENT_DEBUG_HALTED);
}
xscale_write_dcsr(target, 1, 0);
/* Load debug handler */
xscale_write_dcsr(target, 1, 0);
/* Load debug handler */
- if (fileio_open(&debug_handler, PKGLIBDIR "/xscale/debug_handler.bin", FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
+ if (fileio_open(&debug_handler, "xscale/debug_handler.bin", FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
- ERROR("file open error: %s", debug_handler.error_str);
if ((retval = fileio_read(&debug_handler, 32, buffer, &buf_cnt)) != ERROR_OK)
{
if ((retval = fileio_read(&debug_handler, 32, buffer, &buf_cnt)) != ERROR_OK)
{
- ERROR("reading debug handler failed: %s", debug_handler.error_str);
}
for (i = 0; i < buf_cnt; i += 4)
}
for (i = 0; i < buf_cnt; i += 4)
{
armv4_5_common_t *armv4_5 = target->arch_info;
xscale_common_t *xscale = armv4_5->arch_info;
{
armv4_5_common_t *armv4_5 = target->arch_info;
xscale_common_t *xscale = armv4_5->arch_info;
reg_t *dbcon = &xscale->reg_cache->reg_list[XSCALE_DBCON];
u32 dbcon_value = buf_get_u32(dbcon->value, 0, 32);
reg_t *dbcon = &xscale->reg_cache->reg_list[XSCALE_DBCON];
u32 dbcon_value = buf_get_u32(dbcon->value, 0, 32);
xscale->armv4_5_mmu.enable_mmu_caches = xscale_enable_mmu_caches;
xscale->armv4_5_mmu.has_tiny_pages = 1;
xscale->armv4_5_mmu.mmu_enabled = 0;
xscale->armv4_5_mmu.enable_mmu_caches = xscale_enable_mmu_caches;
xscale->armv4_5_mmu.has_tiny_pages = 1;
xscale->armv4_5_mmu.mmu_enabled = 0;
xscale->fast_memory_access = 0;
return ERROR_OK;
xscale->fast_memory_access = 0;
return ERROR_OK;
if ((retval = xscale_get_arch_pointers(target, &armv4_5, &xscale)) != ERROR_OK)
{
return retval;
if ((retval = xscale_get_arch_pointers(target, &armv4_5, &xscale)) != ERROR_OK)
{
return retval;
*physical = ret;
return ERROR_OK;
}
*physical = ret;
return ERROR_OK;
}
{
armv4_5_common_t *armv4_5 = target->arch_info;
xscale_common_t *xscale = armv4_5->arch_info;
{
armv4_5_common_t *armv4_5 = target->arch_info;
xscale_common_t *xscale = armv4_5->arch_info;
if (target->state != TARGET_HALTED)
{
ERROR("Target not halted");
return ERROR_TARGET_INVALID;
}
if (target->state != TARGET_HALTED)
{
ERROR("Target not halted");
return ERROR_TARGET_INVALID;
}
*enabled = xscale->armv4_5_mmu.mmu_enabled;
return ERROR_OK;
}
*enabled = xscale->armv4_5_mmu.mmu_enabled;
return ERROR_OK;
}
int xscale_handle_mmu_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
{
target_t *target = get_current_target(cmd_ctx);
int xscale_handle_mmu_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
{
target_t *target = get_current_target(cmd_ctx);
if (image_open(xscale->trace.image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
{
if (image_open(xscale->trace.image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
{
- command_print(cmd_ctx, "image opening error: %s", xscale->trace.image->error_str);
free(xscale->trace.image);
xscale->trace.image = NULL;
return ERROR_OK;
free(xscale->trace.image);
xscale->trace.image = NULL;
return ERROR_OK;
if (fileio_open(&file, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
{
if (fileio_open(&file, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
{
- command_print(cmd_ctx, "file open error: %s", file.error_str);
register_command(cmd_ctx, xscale_cmd, "cp15", xscale_handle_cp15, COMMAND_EXEC, "access coproc 15 <register> [value]");
register_command(cmd_ctx, xscale_cmd, "fast_memory_access", handle_xscale_fast_memory_access_command,
COMMAND_ANY, "use fast memory accesses instead of slower but potentially unsafe slow accesses <enable|disable>");
register_command(cmd_ctx, xscale_cmd, "cp15", xscale_handle_cp15, COMMAND_EXEC, "access coproc 15 <register> [value]");
register_command(cmd_ctx, xscale_cmd, "fast_memory_access", handle_xscale_fast_memory_access_command,
COMMAND_ANY, "use fast memory accesses instead of slower but potentially unsafe slow accesses <enable|disable>");
armv4_5_register_commands(cmd_ctx);
armv4_5_register_commands(cmd_ctx);
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)