From cbefac0be0b1b633b8d34cf75839de67064e90e2 Mon Sep 17 00:00:00 2001 From: drath Date: Tue, 29 May 2007 12:04:20 +0000 Subject: [PATCH] - add missing image handling files git-svn-id: svn://svn.berlios.de/openocd/trunk@156 b42882b7-edfa-0310-969c-e2dbd0fdcd60 --- src/target/image.c | 340 +++++++++++++++++++++++++++++++++++++++++++++ src/target/image.h | 79 +++++++++++ 2 files changed, 419 insertions(+) create mode 100644 src/target/image.c create mode 100644 src/target/image.h diff --git a/src/target/image.c b/src/target/image.c new file mode 100644 index 000000000..3cc9cc5b1 --- /dev/null +++ b/src/target/image.c @@ -0,0 +1,340 @@ +/*************************************************************************** + * Copyright (C) 2007 by Dominic Rath * + * Dominic.Rath@gmx.de * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + ***************************************************************************/ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include + +#include "image.h" + +#include "types.h" +#include "replacements.h" +#include "log.h" + +#include "fileio.h" +#include "target.h" + +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 = image->base_address; + char *buffer = malloc(ihex->raw_size); + u32 cooked_bytes = 0x0; + + ihex->raw_size = fileio->size; + ihex->buffer = malloc(ihex->raw_size >> 1); + + if ((retval = fileio_read(fileio, ihex->raw_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 != ihex->raw_size) + { + free(buffer); + ERROR("failed buffering complete IHEX file, only partially read"); + return ERROR_FILEIO_OPERATION_FAILED; + } + + image->size = 0x0; + raw_bytes = 0x0; + while (raw_bytes < raw_bytes_read) + { + u32 count; + u32 address; + u32 record_type; + u32 checksum; + + if (sscanf(&buffer[raw_bytes], ":%2x%4x%2x", &count, &address, &record_type) != 3) + { + return ERROR_IMAGE_FORMAT_ERROR; + } + raw_bytes += 9; + + if (record_type == 0) + { + if ((full_address & 0xffff) != address) + { + free(buffer); + ERROR("can't handle non-linear IHEX file"); + return ERROR_IMAGE_FORMAT_ERROR; + } + + while (count-- > 0) + { + sscanf(&buffer[raw_bytes], "%2hhx", &ihex->buffer[cooked_bytes]); + raw_bytes += 2; + cooked_bytes += 1; + full_address++; + } + } + else if (record_type == 1) + { + free(buffer); + image->size = cooked_bytes; + return ERROR_OK; + } + else if (record_type == 4) + { + u16 upper_address; + + sscanf(&buffer[raw_bytes], "%4hx", &upper_address); + raw_bytes += 4; + + if ((full_address >> 16) != upper_address) + { + free(buffer); + ERROR("can't handle non-linear IHEX file"); + return ERROR_IMAGE_FORMAT_ERROR; + } + } + else if (record_type == 5) + { + u32 start_address; + + sscanf(&buffer[raw_bytes], "%8x", &start_address); + raw_bytes += 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; + + /* 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; +} + +int image_open(image_t *image, void *source, enum fileio_access access) +{ + int retval = ERROR_OK; + + if (image->type == IMAGE_BINARY) + { + image_binary_t *image_binary; + char *url = source; + + image_binary = image->type_private = malloc(sizeof(image_binary_t)); + + if ((retval = fileio_open(&image_binary->fileio, url, access, FILEIO_BINARY)) != ERROR_OK) + { + strncpy(image->error_str, image_binary->fileio.error_str, IMAGE_MAX_ERROR_STRING); + ERROR(image->error_str); + return retval; + } + + if (access == FILEIO_WRITE) + image->size = 0; + else + image->size = image_binary->fileio.size; + + return ERROR_OK; + } + else if (image->type == IMAGE_IHEX) + { + image_ihex_t *image_ihex; + char *url = source; + + if (access != FILEIO_READ) + { + snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, + "can't open IHEX file for writing"); + ERROR(image->error_str); + return ERROR_FILEIO_ACCESS_NOT_SUPPORTED; + } + + image_ihex = image->type_private = malloc(sizeof(image_ihex_t)); + + 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); + return retval; + } + + image_ihex->position = 0; + image_ihex->raw_size = image_ihex->fileio.size; + + 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); + fileio_close(&image_ihex->fileio); + return retval; + } + } + else if (image->type == IMAGE_MEMORY) + { + image_memory_t *image_memory; + target_t *target = source; + + image_memory = image->type_private = malloc(sizeof(image_memory_t)); + + image_memory->target = target; + } + + return retval; +}; + +int image_read(image_t *image, u32 size, u8 *buffer, u32 *size_read) +{ + int retval; + + if (image->type == IMAGE_BINARY) + { + image_binary_t *image_binary = image->type_private; + + 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); + return retval; + } + } + else if (image->type == IMAGE_IHEX) + { + image_ihex_t *image_ihex = image->type_private; + + if ((image_ihex->position + size) > image->size) + { + /* don't read past the end of the file */ + size = (image->size - image_ihex->position); + } + + memcpy(buffer, image_ihex->buffer + image_ihex->position, size); + image_ihex->position += size; + *size_read = size; + image->error_str[0] = '\0'; + + return ERROR_OK; + } + else if (image->type == IMAGE_MEMORY) + { + /* TODO: handle target memory pseudo image */ + } + + return ERROR_OK; +} + +int image_write(image_t *image, u32 size, u8 *buffer, u32 *size_written) +{ + int retval = ERROR_FILEIO_OPERATION_NOT_SUPPORTED; + + if (image->type == IMAGE_BINARY) + { + image_binary_t *image_binary = image->type_private; + + if ((retval = fileio_write(&image_binary->fileio, size, buffer, size_written)) != ERROR_OK) + { + strncpy(image->error_str, image_binary->fileio.error_str, IMAGE_MAX_ERROR_STRING); + return retval; + } + } + else if (image->type == IMAGE_IHEX) + { + return ERROR_FILEIO_OPERATION_NOT_SUPPORTED; + } + else if (image->type == IMAGE_MEMORY) + { + /* TODO: handle target memory pseudo image */ + } + + if (retval != ERROR_OK) + return retval; + + image->size += size; + + return ERROR_OK; +} + +int image_close(image_t *image) +{ + 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_ihex->fileio); + + if (image_ihex->buffer) + free(image_ihex->buffer); + } + else if (image->type == IMAGE_MEMORY) + { + /* do nothing for now */ + } + + free(image->type_private); + + return ERROR_OK; +} + +int identify_image_type(image_type_t *type, char *type_string) +{ + if (type_string) + { + if (!strcmp(type_string, "bin")) + { + *type = IMAGE_BINARY; + } + else if (!strcmp(type_string, "ihex")) + { + *type = IMAGE_IHEX; + } + else + { + return ERROR_IMAGE_TYPE_UNKNOWN; + } + } + else + { + *type = IMAGE_BINARY; + } + + return ERROR_OK; +} diff --git a/src/target/image.h b/src/target/image.h new file mode 100644 index 000000000..3df175a8d --- /dev/null +++ b/src/target/image.h @@ -0,0 +1,79 @@ +/*************************************************************************** + * Copyright (C) 2007 by Dominic Rath * + * Dominic.Rath@gmx.de * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + ***************************************************************************/ +#ifndef IMAGE_H +#define IMAGE_H + +#include "fileio.h" +#include "target.h" + +#define IMAGE_MAX_ERROR_STRING (128) + +typedef enum image_type +{ + IMAGE_BINARY, /* plain binary */ + IMAGE_IHEX, /* intel hex-record format */ + IMAGE_MEMORY, /* target-memory pseudo-image */ +/* + * Possible future enhancements: + * IMAGE_ELF, + * IMAGE_SRECORD, + */ +} image_type_t; + +typedef struct image_s +{ + image_type_t type; /* image type (plain, ihex, ...) */ + void *type_private; /* type private data */ + int base_address_set; /* whether the image start address has been set */ + u32 base_address; /* base address of image in target memory */ + int start_address_set; /* whether the image has a start address (entry point) associated */ + u32 start_address; /* start address, if one is set */ + u32 size; /* image size in byte */ + char error_str[IMAGE_MAX_ERROR_STRING]; +} image_t; + +typedef struct image_binary_s +{ + fileio_t fileio; +} image_binary_t; + +typedef struct image_ihex_s +{ + fileio_t fileio; + u32 position; + u32 raw_size; + u8 *buffer; +} image_ihex_t; + +typedef struct image_memory_s +{ + target_t *target; +} image_memory_t; + +extern int image_open(image_t *image, void *source, enum fileio_access access); +extern int image_read(image_t *image, u32 size, u8 *buffer, u32 *size_written); +extern int image_write(image_t *image, u32 size, u8 *buffer, u32 *size_written); +extern int image_close(image_t *image); +extern int identify_image_type(image_type_t *type, char *type_string); + +#define ERROR_IMAGE_FORMAT_ERROR (-1400) +#define ERROR_IMAGE_TYPE_UNKNOWN (-1401) + +#endif /* IMAGE_H */