Change-Id: I1a3afbddcf950689da58e0df8850a05f558d7879
Signed-off-by: Marc Schink <openocd-dev@marcschink.de>
Reviewed-on: http://openocd.zylin.com/3222
Tested-by: jenkins
Reviewed-by: Andreas Fritiofson <andreas.fritiofson@gmail.com>
14 files changed:
{
uint32_t address, cnt, res, i;
uint8_t *buffer;
{
uint32_t address, cnt, res, i;
uint8_t *buffer;
int ret;
if (CMD_ARGC != 3)
int ret;
if (CMD_ARGC != 3)
size_t filesize;
buffer = malloc(MG_FILEIO_CHUNK);
if (!buffer) {
size_t filesize;
buffer = malloc(MG_FILEIO_CHUNK);
if (!buffer) {
- int retval = fileio_size(&fileio, &filesize);
+ int retval = fileio_size(fileio, &filesize);
if (retval != ERROR_OK) {
if (retval != ERROR_OK) {
free(buffer);
return retval;
}
free(buffer);
return retval;
}
size_t buf_cnt;
for (i = 0; i < cnt; i++) {
size_t buf_cnt;
for (i = 0; i < cnt; i++) {
- ret = fileio_read(&fileio, MG_FILEIO_CHUNK, buffer, &buf_cnt);
+ ret = fileio_read(fileio, MG_FILEIO_CHUNK, buffer, &buf_cnt);
if (ret != ERROR_OK)
goto mg_write_cmd_err;
ret = mg_mflash_write(address, buffer, MG_FILEIO_CHUNK);
if (ret != ERROR_OK)
goto mg_write_cmd_err;
ret = mg_mflash_write(address, buffer, MG_FILEIO_CHUNK);
- ret = fileio_read(&fileio, res, buffer, &buf_cnt);
+ ret = fileio_read(fileio, res, buffer, &buf_cnt);
if (ret != ERROR_OK)
goto mg_write_cmd_err;
ret = mg_mflash_write(address, buffer, res);
if (ret != ERROR_OK)
goto mg_write_cmd_err;
ret = mg_mflash_write(address, buffer, res);
return ERROR_OK;
mg_write_cmd_err:
free(buffer);
return ERROR_OK;
mg_write_cmd_err:
free(buffer);
{
uint32_t address, size, cnt, res, i;
uint8_t *buffer;
{
uint32_t address, size, cnt, res, i;
uint8_t *buffer;
int ret;
if (CMD_ARGC != 4)
int ret;
if (CMD_ARGC != 4)
buffer = malloc(MG_FILEIO_CHUNK);
if (!buffer) {
buffer = malloc(MG_FILEIO_CHUNK);
if (!buffer) {
ret = mg_mflash_read(address, buffer, MG_FILEIO_CHUNK);
if (ret != ERROR_OK)
goto mg_dump_cmd_err;
ret = mg_mflash_read(address, buffer, MG_FILEIO_CHUNK);
if (ret != ERROR_OK)
goto mg_dump_cmd_err;
- ret = fileio_write(&fileio, MG_FILEIO_CHUNK, buffer, &size_written);
+ ret = fileio_write(fileio, MG_FILEIO_CHUNK, buffer, &size_written);
if (ret != ERROR_OK)
goto mg_dump_cmd_err;
address += MG_FILEIO_CHUNK;
if (ret != ERROR_OK)
goto mg_dump_cmd_err;
address += MG_FILEIO_CHUNK;
ret = mg_mflash_read(address, buffer, res);
if (ret != ERROR_OK)
goto mg_dump_cmd_err;
ret = mg_mflash_read(address, buffer, res);
if (ret != ERROR_OK)
goto mg_dump_cmd_err;
- ret = fileio_write(&fileio, res, buffer, &size_written);
+ ret = fileio_write(fileio, res, buffer, &size_written);
if (ret != ERROR_OK)
goto mg_dump_cmd_err;
}
if (ret != ERROR_OK)
goto mg_dump_cmd_err;
}
return ERROR_OK;
mg_dump_cmd_err:
free(buffer);
return ERROR_OK;
mg_dump_cmd_err:
free(buffer);
int nand_fileio_cleanup(struct nand_fileio_state *state)
{
if (state->file_opened)
int nand_fileio_cleanup(struct nand_fileio_state *state)
{
if (state->file_opened)
- fileio_close(&state->fileio);
+ fileio_close(state->fileio);
if (state->oob) {
free(state->oob);
if (state->oob) {
free(state->oob);
if (!need_size) {
size_t filesize;
if (!need_size) {
size_t filesize;
- retval = fileio_size(&state->fileio, &filesize);
+ retval = fileio_size(state->fileio, &filesize);
if (retval != ERROR_OK)
return retval;
state->size = filesize;
if (retval != ERROR_OK)
return retval;
state->size = filesize;
size_t one_read;
if (NULL != s->page) {
size_t one_read;
if (NULL != s->page) {
- fileio_read(&s->fileio, s->page_size, s->page, &one_read);
+ fileio_read(s->fileio, s->page_size, s->page, &one_read);
if (one_read < s->page_size)
memset(s->page + one_read, 0xff, s->page_size - one_read);
total_read += one_read;
if (one_read < s->page_size)
memset(s->page + one_read, 0xff, s->page_size - one_read);
total_read += one_read;
ecc += 10;
}
} else if (NULL != s->oob) {
ecc += 10;
}
} else if (NULL != s->oob) {
- fileio_read(&s->fileio, s->oob_size, s->oob, &one_read);
+ fileio_read(s->fileio, s->oob_size, s->oob, &one_read);
if (one_read < s->oob_size)
memset(s->oob + one_read, 0xff, s->oob_size - one_read);
total_read += one_read;
if (one_read < s->oob_size)
memset(s->oob + one_read, 0xff, s->oob_size - one_read);
total_read += one_read;
const int *eccpos;
bool file_opened;
const int *eccpos;
bool file_opened;
struct duration bench;
};
struct duration bench;
};
- fileio_write(&s.fileio, s.page_size, s.page, &size_written);
+ fileio_write(s.fileio, s.page_size, s.page, &size_written);
- fileio_write(&s.fileio, s.oob_size, s.oob, &size_written);
+ fileio_write(s.fileio, s.oob_size, s.oob, &size_written);
s.size -= nand->page_size;
s.address += nand->page_size;
}
s.size -= nand->page_size;
s.address += nand->page_size;
}
- retval = fileio_size(&s.fileio, &filesize);
+ retval = fileio_size(s.fileio, &filesize);
if (retval != ERROR_OK)
return retval;
if (retval != ERROR_OK)
return retval;
target_write_u32(target, FCTR, FCTR_FS_CS | FCTR_FS_WEB);
/* Try and open the file */
target_write_u32(target, FCTR, FCTR_FS_CS | FCTR_FS_WEB);
/* Try and open the file */
const char *filename = CMD_ARGV[1];
int ret = fileio_open(&fileio, filename, FILEIO_WRITE, FILEIO_BINARY);
if (ret != ERROR_OK) {
const char *filename = CMD_ARGV[1];
int ret = fileio_open(&fileio, filename, FILEIO_WRITE, FILEIO_BINARY);
if (ret != ERROR_OK) {
- ret = fileio_write(&fileio, sizeof(customer), customer, &nwritten);
+ ret = fileio_write(fileio, sizeof(customer), customer, &nwritten);
if (ret != ERROR_OK) {
LOG_ERROR("Write operation to file %s failed", filename);
if (ret != ERROR_OK) {
LOG_ERROR("Write operation to file %s failed", filename);
{
uint32_t offset;
uint8_t *buffer;
{
uint32_t offset;
uint8_t *buffer;
if (CMD_ARGC != 3)
return ERROR_COMMAND_SYNTAX_ERROR;
if (CMD_ARGC != 3)
return ERROR_COMMAND_SYNTAX_ERROR;
return ERROR_OK;
size_t filesize;
return ERROR_OK;
size_t filesize;
- retval = fileio_size(&fileio, &filesize);
+ retval = fileio_size(fileio, &filesize);
if (retval != ERROR_OK) {
if (retval != ERROR_OK) {
return retval;
}
buffer = malloc(filesize);
if (buffer == NULL) {
return retval;
}
buffer = malloc(filesize);
if (buffer == NULL) {
LOG_ERROR("Out of memory");
return ERROR_FAIL;
}
size_t buf_cnt;
LOG_ERROR("Out of memory");
return ERROR_FAIL;
}
size_t buf_cnt;
- if (fileio_read(&fileio, filesize, buffer, &buf_cnt) != ERROR_OK) {
+ if (fileio_read(fileio, filesize, buffer, &buf_cnt) != ERROR_OK) {
duration_elapsed(&bench), duration_kbps(&bench, filesize));
}
duration_elapsed(&bench), duration_kbps(&bench, filesize));
}
{
uint32_t offset;
uint8_t *buffer;
{
uint32_t offset;
uint8_t *buffer;
uint32_t length;
size_t written;
uint32_t length;
size_t written;
- retval = fileio_write(&fileio, length, buffer, &written);
- fileio_close(&fileio);
+ retval = fileio_write(fileio, length, buffer, &written);
+ fileio_close(fileio);
free(buffer);
if (retval != ERROR_OK) {
LOG_ERROR("Could not write file");
free(buffer);
if (retval != ERROR_OK) {
LOG_ERROR("Could not write file");
{
uint32_t offset;
uint8_t *buffer_file, *buffer_flash;
{
uint32_t offset;
uint8_t *buffer_file, *buffer_flash;
size_t read_cnt;
size_t filesize;
int differ;
size_t read_cnt;
size_t filesize;
int differ;
- retval = fileio_size(&fileio, &filesize);
+ retval = fileio_size(fileio, &filesize);
if (retval != ERROR_OK) {
if (retval != ERROR_OK) {
return retval;
}
buffer_file = malloc(filesize);
if (buffer_file == NULL) {
LOG_ERROR("Out of memory");
return retval;
}
buffer_file = malloc(filesize);
if (buffer_file == NULL) {
LOG_ERROR("Out of memory");
- retval = fileio_read(&fileio, filesize, buffer_file, &read_cnt);
- fileio_close(&fileio);
+ retval = fileio_read(fileio, filesize, buffer_file, &read_cnt);
+ fileio_close(fileio);
if (retval != ERROR_OK) {
LOG_ERROR("File read failure");
free(buffer_file);
if (retval != ERROR_OK) {
LOG_ERROR("File read failure");
free(buffer_file);
#include "configuration.h"
#include "fileio.h"
#include "configuration.h"
#include "fileio.h"
-struct fileio_internal {
char *url;
size_t size;
enum fileio_type type;
char *url;
size_t size;
enum fileio_type type;
-static inline int fileio_close_local(struct fileio_internal *fileio);
-static inline int fileio_open_local(struct fileio_internal *fileio)
+static inline int fileio_close_local(struct fileio *fileio)
+{
+ int retval = fclose(fileio->file);
+ if (retval != 0) {
+ if (retval == EBADF)
+ LOG_ERROR("BUG: fileio->file not a valid file descriptor");
+ else
+ LOG_ERROR("couldn't close %s: %s", fileio->url, strerror(errno));
+
+ return ERROR_FILEIO_OPERATION_FAILED;
+ }
+
+ return ERROR_OK;
+}
+
+static inline int fileio_open_local(struct fileio *fileio)
{
char file_access[4];
ssize_t file_size;
{
char file_access[4];
ssize_t file_size;
-int fileio_open(struct fileio *fileio_p,
- const char *url,
- enum fileio_access access_type,
- enum fileio_type type)
+int fileio_open(struct fileio **fileio, const char *url,
+ enum fileio_access access_type, enum fileio_type type)
- struct fileio_internal *fileio;
- fileio = malloc(sizeof(struct fileio_internal));
+ tmp = malloc(sizeof(struct fileio));
- fileio->type = type;
- fileio->access = access_type;
- fileio->url = strdup(url);
+ tmp->type = type;
+ tmp->access = access_type;
+ tmp->url = strdup(url);
- retval = fileio_open_local(fileio);
+ retval = fileio_open_local(tmp);
if (retval != ERROR_OK) {
if (retval != ERROR_OK) {
- free(fileio->url);
- free(fileio);
+ free(tmp->url);
+ free(tmp);
- fileio_p->fp = fileio;
-
- return ERROR_OK;
-}
-
-static inline int fileio_close_local(struct fileio_internal *fileio)
-{
- int retval = fclose(fileio->file);
- if (retval != 0) {
- if (retval == EBADF)
- LOG_ERROR("BUG: fileio_local->file not a valid file descriptor");
- else
- LOG_ERROR("couldn't close %s: %s", fileio->url, strerror(errno));
-
- return ERROR_FILEIO_OPERATION_FAILED;
- }
-int fileio_close(struct fileio *fileio_p)
+int fileio_close(struct fileio *fileio)
- struct fileio_internal *fileio = fileio_p->fp;
retval = fileio_close_local(fileio);
free(fileio->url);
retval = fileio_close_local(fileio);
free(fileio->url);
-int fileio_seek(struct fileio *fileio_p, size_t position)
+int fileio_seek(struct fileio *fileio, size_t position)
- struct fileio_internal *fileio = fileio_p->fp;
retval = fseek(fileio->file, position, SEEK_SET);
retval = fseek(fileio->file, position, SEEK_SET);
if (retval != 0) {
LOG_ERROR("couldn't seek file %s: %s", fileio->url, strerror(errno));
return ERROR_FILEIO_OPERATION_FAILED;
if (retval != 0) {
LOG_ERROR("couldn't seek file %s: %s", fileio->url, strerror(errno));
return ERROR_FILEIO_OPERATION_FAILED;
-static int fileio_local_read(struct fileio_internal *fileio,
- size_t size, void *buffer, size_t *size_read)
+static int fileio_local_read(struct fileio *fileio, size_t size, void *buffer,
+ size_t *size_read)
- ssize_t retval = fread(buffer, 1, size, fileio->file);
+ ssize_t retval;
+
+ retval = fread(buffer, 1, size, fileio->file);
*size_read = (retval >= 0) ? retval : 0;
*size_read = (retval >= 0) ? retval : 0;
return (retval < 0) ? retval : ERROR_OK;
}
return (retval < 0) ? retval : ERROR_OK;
}
-int fileio_read(struct fileio *fileio_p, size_t size, void *buffer,
- size_t *size_read)
+int fileio_read(struct fileio *fileio, size_t size, void *buffer,
+ size_t *size_read)
- struct fileio_internal *fileio = fileio_p->fp;
return fileio_local_read(fileio, size, buffer, size_read);
}
return fileio_local_read(fileio, size, buffer, size_read);
}
-int fileio_read_u32(struct fileio *fileio_p, uint32_t *data)
+int fileio_read_u32(struct fileio *fileio, uint32_t *data)
uint8_t buf[4];
size_t size_read;
uint8_t buf[4];
size_t size_read;
- struct fileio_internal *fileio = fileio_p->fp;
- int retval = fileio_local_read(fileio, sizeof(uint32_t), buf, &size_read);
+
+ retval = fileio_local_read(fileio, sizeof(uint32_t), buf, &size_read);
+
if (ERROR_OK == retval && sizeof(uint32_t) != size_read)
retval = -EIO;
if (ERROR_OK == retval)
*data = be_to_h_u32(buf);
if (ERROR_OK == retval && sizeof(uint32_t) != size_read)
retval = -EIO;
if (ERROR_OK == retval)
*data = be_to_h_u32(buf);
-static int fileio_local_fgets(struct fileio_internal *fileio,
- size_t size, void *buffer)
+static int fileio_local_fgets(struct fileio *fileio, size_t size, void *buffer)
{
if (fgets(buffer, size, fileio->file) == NULL)
return ERROR_FILEIO_OPERATION_FAILED;
{
if (fgets(buffer, size, fileio->file) == NULL)
return ERROR_FILEIO_OPERATION_FAILED;
-int fileio_fgets(struct fileio *fileio_p, size_t size, void *buffer)
+int fileio_fgets(struct fileio *fileio, size_t size, void *buffer)
- struct fileio_internal *fileio = fileio_p->fp;
return fileio_local_fgets(fileio, size, buffer);
}
return fileio_local_fgets(fileio, size, buffer);
}
-static int fileio_local_write(struct fileio_internal *fileio,
- size_t size, const void *buffer, size_t *size_written)
+static int fileio_local_write(struct fileio *fileio, size_t size,
+ const void *buffer, size_t *size_written)
- ssize_t retval = fwrite(buffer, 1, size, fileio->file);
+ ssize_t retval;
+
+ retval = fwrite(buffer, 1, size, fileio->file);
*size_written = (retval >= 0) ? retval : 0;
*size_written = (retval >= 0) ? retval : 0;
return (retval < 0) ? retval : ERROR_OK;
}
return (retval < 0) ? retval : ERROR_OK;
}
-int fileio_write(struct fileio *fileio_p,
- size_t size, const void *buffer, size_t *size_written)
+int fileio_write(struct fileio *fileio, size_t size, const void *buffer,
+ size_t *size_written)
- struct fileio_internal *fileio = fileio_p->fp;
- int retval = fileio_local_write(fileio, size, buffer, size_written);
+ int retval;
+
+ 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;
-int fileio_write_u32(struct fileio *fileio_p, uint32_t data)
+int fileio_write_u32(struct fileio *fileio, uint32_t data)
uint8_t buf[4];
h_u32_to_be(buf, data);
size_t size_written;
uint8_t buf[4];
h_u32_to_be(buf, data);
size_t size_written;
- int retval = fileio_write(fileio_p, 4, buf, &size_written);
+
+ retval = fileio_write(fileio, 4, buf, &size_written);
+
if (ERROR_OK == retval && size_written != sizeof(uint32_t))
retval = -EIO;
if (ERROR_OK == retval && size_written != sizeof(uint32_t))
retval = -EIO;
* Avoiding the seek on startup opens up for using streams.
*
*/
* Avoiding the seek on startup opens up for using streams.
*
*/
-int fileio_size(struct fileio *fileio_p, size_t *size)
+int fileio_size(struct fileio *fileio, size_t *size)
- struct fileio_internal *fileio = fileio_p->fp;
*size = fileio->size;
return ERROR_OK;
*size = fileio->size;
return ERROR_OK;
FILEIO_APPENDREAD, /* open for writing, position at end, allow reading */
};
FILEIO_APPENDREAD, /* open for writing, position at end, allow reading */
};
-struct fileio {
- /* The structure is opaque */
- struct fileio_internal *fp;
-};
-int fileio_open(struct fileio *fileio,
- const char *url, enum fileio_access access_type, enum fileio_type type);
+int fileio_open(struct fileio **fileio, const char *url,
+ enum fileio_access access_type, enum fileio_type type);
int fileio_close(struct fileio *fileio);
int fileio_seek(struct fileio *fileio, size_t position);
int fileio_close(struct fileio *fileio);
int fileio_seek(struct fileio *fileio, size_t position);
tdesc_length = strlen(tdesc);
tdesc_length = strlen(tdesc);
size_t size_written;
char *tdesc_filename = alloc_printf("%s.xml", target_type_name(target));
size_t size_written;
char *tdesc_filename = alloc_printf("%s.xml", target_type_name(target));
- retval = fileio_write(&fileio, tdesc_length, tdesc, &size_written);
+ retval = fileio_write(fileio, tdesc_length, tdesc, &size_written);
if (retval != ERROR_OK)
LOG_ERROR("Error while writing the tdesc file");
if (retval != ERROR_OK)
LOG_ERROR("Error while writing the tdesc file");
COMMAND_HANDLER(handle_etm_dump_command)
{
COMMAND_HANDLER(handle_etm_dump_command)
{
struct target *target;
struct arm *arm;
struct etm_context *etm_ctx;
struct target *target;
struct arm *arm;
struct etm_context *etm_ctx;
if (fileio_open(&file, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
return ERROR_FAIL;
if (fileio_open(&file, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
return ERROR_FAIL;
- fileio_write_u32(&file, etm_ctx->capture_status);
- fileio_write_u32(&file, etm_ctx->control);
- fileio_write_u32(&file, etm_ctx->trace_depth);
+ fileio_write_u32(file, etm_ctx->capture_status);
+ fileio_write_u32(file, etm_ctx->control);
+ fileio_write_u32(file, etm_ctx->trace_depth);
for (i = 0; i < etm_ctx->trace_depth; i++) {
for (i = 0; i < etm_ctx->trace_depth; i++) {
- fileio_write_u32(&file, etm_ctx->trace_data[i].pipestat);
- fileio_write_u32(&file, etm_ctx->trace_data[i].packet);
- fileio_write_u32(&file, etm_ctx->trace_data[i].flags);
+ fileio_write_u32(file, etm_ctx->trace_data[i].pipestat);
+ fileio_write_u32(file, etm_ctx->trace_data[i].packet);
+ fileio_write_u32(file, etm_ctx->trace_data[i].flags);
return ERROR_OK;
}
COMMAND_HANDLER(handle_etm_load_command)
{
return ERROR_OK;
}
COMMAND_HANDLER(handle_etm_load_command)
{
struct target *target;
struct arm *arm;
struct etm_context *etm_ctx;
struct target *target;
struct arm *arm;
struct etm_context *etm_ctx;
return ERROR_FAIL;
size_t filesize;
return ERROR_FAIL;
size_t filesize;
- int retval = fileio_size(&file, &filesize);
+ int retval = fileio_size(file, &filesize);
if (retval != ERROR_OK) {
if (retval != ERROR_OK) {
return retval;
}
if (filesize % 4) {
command_print(CMD_CTX, "size isn't a multiple of 4, no valid trace data");
return retval;
}
if (filesize % 4) {
command_print(CMD_CTX, "size isn't a multiple of 4, no valid trace data");
- fileio_read_u32(&file, &tmp); etm_ctx->capture_status = tmp;
- fileio_read_u32(&file, &tmp); etm_ctx->control = tmp;
- fileio_read_u32(&file, &etm_ctx->trace_depth);
+ fileio_read_u32(file, &tmp); etm_ctx->capture_status = tmp;
+ fileio_read_u32(file, &tmp); etm_ctx->control = tmp;
+ fileio_read_u32(file, &etm_ctx->trace_depth);
}
etm_ctx->trace_data = malloc(sizeof(struct etmv1_trace_data) * etm_ctx->trace_depth);
if (etm_ctx->trace_data == NULL) {
command_print(CMD_CTX, "not enough memory to perform operation");
}
etm_ctx->trace_data = malloc(sizeof(struct etmv1_trace_data) * etm_ctx->trace_depth);
if (etm_ctx->trace_data == NULL) {
command_print(CMD_CTX, "not enough memory to perform operation");
return ERROR_FAIL;
}
for (i = 0; i < etm_ctx->trace_depth; i++) {
uint32_t pipestat, packet, flags;
return ERROR_FAIL;
}
for (i = 0; i < etm_ctx->trace_depth; i++) {
uint32_t pipestat, packet, flags;
- fileio_read_u32(&file, &pipestat);
- fileio_read_u32(&file, &packet);
- fileio_read_u32(&file, &flags);
+ fileio_read_u32(file, &pipestat);
+ fileio_read_u32(file, &packet);
+ fileio_read_u32(file, &flags);
etm_ctx->trace_data[i].pipestat = pipestat & 0xff;
etm_ctx->trace_data[i].packet = packet & 0xffff;
etm_ctx->trace_data[i].flags = flags;
}
etm_ctx->trace_data[i].pipestat = pipestat & 0xff;
etm_ctx->trace_data[i].packet = packet & 0xffff;
etm_ctx->trace_data[i].flags = flags;
}
static int autodetect_image_type(struct image *image, const char *url)
{
int retval;
static int autodetect_image_type(struct image *image, const char *url)
{
int retval;
size_t read_bytes;
uint8_t buffer[9];
size_t read_bytes;
uint8_t buffer[9];
retval = fileio_open(&fileio, url, FILEIO_READ, FILEIO_BINARY);
if (retval != ERROR_OK)
return retval;
retval = fileio_open(&fileio, url, FILEIO_READ, FILEIO_BINARY);
if (retval != ERROR_OK)
return retval;
- retval = fileio_read(&fileio, 9, buffer, &read_bytes);
+ retval = fileio_read(fileio, 9, buffer, &read_bytes);
if (retval == ERROR_OK) {
if (read_bytes != 9)
retval = ERROR_FILEIO_OPERATION_FAILED;
}
if (retval == ERROR_OK) {
if (read_bytes != 9)
retval = ERROR_FILEIO_OPERATION_FAILED;
}
if (retval != ERROR_OK)
return retval;
if (retval != ERROR_OK)
return retval;
struct imagesection *section)
{
struct image_ihex *ihex = image->type_private;
struct imagesection *section)
{
struct image_ihex *ihex = image->type_private;
- struct fileio *fileio = &ihex->fileio;
+ struct fileio *fileio = ihex->fileio;
uint32_t full_address = 0x0;
uint32_t cooked_bytes;
int i;
uint32_t full_address = 0x0;
uint32_t cooked_bytes;
int i;
return ERROR_FILEIO_OPERATION_FAILED;
}
return ERROR_FILEIO_OPERATION_FAILED;
}
- retval = fileio_read(&elf->fileio, sizeof(Elf32_Ehdr), (uint8_t *)elf->header, &read_bytes);
+ retval = fileio_read(elf->fileio, sizeof(Elf32_Ehdr), (uint8_t *)elf->header, &read_bytes);
if (retval != ERROR_OK) {
LOG_ERROR("cannot read ELF file header, read failed");
return ERROR_FILEIO_OPERATION_FAILED;
if (retval != ERROR_OK) {
LOG_ERROR("cannot read ELF file header, read failed");
return ERROR_FILEIO_OPERATION_FAILED;
return ERROR_IMAGE_FORMAT_ERROR;
}
return ERROR_IMAGE_FORMAT_ERROR;
}
- retval = fileio_seek(&elf->fileio, field32(elf, elf->header->e_phoff));
+ retval = fileio_seek(elf->fileio, field32(elf, elf->header->e_phoff));
if (retval != ERROR_OK) {
LOG_ERROR("cannot seek to ELF program header table, read failed");
return retval;
if (retval != ERROR_OK) {
LOG_ERROR("cannot seek to ELF program header table, read failed");
return retval;
return ERROR_FILEIO_OPERATION_FAILED;
}
return ERROR_FILEIO_OPERATION_FAILED;
}
- retval = fileio_read(&elf->fileio, elf->segment_count*sizeof(Elf32_Phdr),
+ retval = fileio_read(elf->fileio, elf->segment_count*sizeof(Elf32_Phdr),
(uint8_t *)elf->segments, &read_bytes);
if (retval != ERROR_OK) {
LOG_ERROR("cannot read ELF segment headers, read failed");
(uint8_t *)elf->segments, &read_bytes);
if (retval != ERROR_OK) {
LOG_ERROR("cannot read ELF segment headers, read failed");
LOG_DEBUG("read elf: size = 0x%zu at 0x%" PRIx32 "", read_size,
field32(elf, segment->p_offset) + offset);
/* read initialized area of the segment */
LOG_DEBUG("read elf: size = 0x%zu at 0x%" PRIx32 "", read_size,
field32(elf, segment->p_offset) + offset);
/* read initialized area of the segment */
- retval = fileio_seek(&elf->fileio, field32(elf, segment->p_offset) + offset);
+ retval = fileio_seek(elf->fileio, field32(elf, segment->p_offset) + offset);
if (retval != ERROR_OK) {
LOG_ERROR("cannot find ELF segment content, seek failed");
return retval;
}
if (retval != ERROR_OK) {
LOG_ERROR("cannot find ELF segment content, seek failed");
return retval;
}
- retval = fileio_read(&elf->fileio, read_size, buffer, &really_read);
+ retval = fileio_read(elf->fileio, read_size, buffer, &really_read);
if (retval != ERROR_OK) {
LOG_ERROR("cannot read ELF segment content, read failed");
return retval;
if (retval != ERROR_OK) {
LOG_ERROR("cannot read ELF segment content, read failed");
return retval;
struct imagesection *section)
{
struct image_mot *mot = image->type_private;
struct imagesection *section)
{
struct image_mot *mot = image->type_private;
- struct fileio *fileio = &mot->fileio;
+ struct fileio *fileio = mot->fileio;
uint32_t full_address = 0x0;
uint32_t cooked_bytes;
int i;
uint32_t full_address = 0x0;
uint32_t cooked_bytes;
int i;
if (retval != ERROR_OK)
return retval;
size_t filesize;
if (retval != ERROR_OK)
return retval;
size_t filesize;
- retval = fileio_size(&image_binary->fileio, &filesize);
+ retval = fileio_size(image_binary->fileio, &filesize);
if (retval != ERROR_OK) {
if (retval != ERROR_OK) {
- fileio_close(&image_binary->fileio);
+ fileio_close(image_binary->fileio);
if (retval != ERROR_OK) {
LOG_ERROR(
"failed buffering IHEX image, check daemon output for additional information");
if (retval != ERROR_OK) {
LOG_ERROR(
"failed buffering IHEX image, check daemon output for additional information");
- fileio_close(&image_ihex->fileio);
+ fileio_close(image_ihex->fileio);
return retval;
}
} else if (image->type == IMAGE_ELF) {
return retval;
}
} else if (image->type == IMAGE_ELF) {
retval = image_elf_read_headers(image);
if (retval != ERROR_OK) {
retval = image_elf_read_headers(image);
if (retval != ERROR_OK) {
- fileio_close(&image_elf->fileio);
+ fileio_close(image_elf->fileio);
return retval;
}
} else if (image->type == IMAGE_MEMORY) {
return retval;
}
} else if (image->type == IMAGE_MEMORY) {
if (retval != ERROR_OK) {
LOG_ERROR(
"failed buffering S19 image, check daemon output for additional information");
if (retval != ERROR_OK) {
LOG_ERROR(
"failed buffering S19 image, check daemon output for additional information");
- fileio_close(&image_mot->fileio);
+ fileio_close(image_mot->fileio);
return retval;
}
} else if (image->type == IMAGE_BUILDER) {
return retval;
}
} else if (image->type == IMAGE_BUILDER) {
return ERROR_COMMAND_SYNTAX_ERROR;
/* seek to offset */
return ERROR_COMMAND_SYNTAX_ERROR;
/* seek to offset */
- retval = fileio_seek(&image_binary->fileio, offset);
+ retval = fileio_seek(image_binary->fileio, offset);
if (retval != ERROR_OK)
return retval;
/* return requested bytes */
if (retval != ERROR_OK)
return retval;
/* return requested bytes */
- retval = fileio_read(&image_binary->fileio, size, buffer, size_read);
+ retval = fileio_read(image_binary->fileio, size, buffer, size_read);
if (retval != ERROR_OK)
return retval;
} else if (image->type == IMAGE_IHEX) {
if (retval != ERROR_OK)
return retval;
} else if (image->type == IMAGE_IHEX) {
if (image->type == IMAGE_BINARY) {
struct image_binary *image_binary = image->type_private;
if (image->type == IMAGE_BINARY) {
struct image_binary *image_binary = image->type_private;
- fileio_close(&image_binary->fileio);
+ fileio_close(image_binary->fileio);
} else if (image->type == IMAGE_IHEX) {
struct image_ihex *image_ihex = image->type_private;
} else if (image->type == IMAGE_IHEX) {
struct image_ihex *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) {
struct image_elf *image_elf = image->type_private;
} else if (image->type == IMAGE_ELF) {
struct image_elf *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_SRECORD) {
struct image_mot *image_mot = image->type_private;
} else if (image->type == IMAGE_SRECORD) {
struct image_mot *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);
Elf32_Ehdr *header;
Elf32_Phdr *segments;
uint32_t segment_count;
Elf32_Ehdr *header;
Elf32_Phdr *segments;
uint32_t segment_count;
COMMAND_HANDLER(handle_dump_image_command)
{
COMMAND_HANDLER(handle_dump_image_command)
{
uint8_t *buffer;
int retval, retvaltemp;
uint32_t address, size;
uint8_t *buffer;
int retval, retvaltemp;
uint32_t address, size;
if (retval != ERROR_OK)
break;
if (retval != ERROR_OK)
break;
- retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
+ retval = fileio_write(fileio, this_run_size, buffer, &size_written);
if (retval != ERROR_OK)
break;
if (retval != ERROR_OK)
break;
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
size_t filesize;
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
size_t filesize;
- retval = fileio_size(&fileio, &filesize);
+ retval = fileio_size(fileio, &filesize);
if (retval != ERROR_OK)
return retval;
command_print(CMD_CTX,
if (retval != ERROR_OK)
return retval;
command_print(CMD_CTX,
duration_elapsed(&bench), duration_kbps(&bench, filesize));
}
duration_elapsed(&bench), duration_kbps(&bench, filesize));
}
- retvaltemp = fileio_close(&fileio);
+ retvaltemp = fileio_close(fileio);
if (retvaltemp != ERROR_OK)
return retvaltemp;
if (retvaltemp != ERROR_OK)
return retvaltemp;
struct target *target = get_current_target(CMD_CTX);
struct xscale_common *xscale = target_to_xscale(target);
struct xscale_trace_data *trace_data;
struct target *target = get_current_target(CMD_CTX);
struct xscale_common *xscale = target_to_xscale(target);
struct xscale_trace_data *trace_data;
int retval;
retval = xscale_verify_pointer(CMD_CTX, xscale);
int retval;
retval = xscale_verify_pointer(CMD_CTX, xscale);
while (trace_data) {
int i;
while (trace_data) {
int i;
- fileio_write_u32(&file, trace_data->chkpt0);
- fileio_write_u32(&file, trace_data->chkpt1);
- fileio_write_u32(&file, trace_data->last_instruction);
- fileio_write_u32(&file, trace_data->depth);
+ fileio_write_u32(file, trace_data->chkpt0);
+ fileio_write_u32(file, trace_data->chkpt1);
+ fileio_write_u32(file, trace_data->last_instruction);
+ fileio_write_u32(file, trace_data->depth);
for (i = 0; i < trace_data->depth; i++)
for (i = 0; i < trace_data->depth; i++)
- fileio_write_u32(&file, trace_data->entries[i].data |
+ fileio_write_u32(file, trace_data->entries[i].data |
((trace_data->entries[i].type & 0xffff) << 16));
trace_data = trace_data->next;
}
((trace_data->entries[i].type & 0xffff) << 16));
trace_data = trace_data->next;
}
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)