INCLUDES = -I$(top_srcdir)/src/helper -I$(top_srcdir)/src/jtag -I$(top_srcdir)/src/target $(all_includes)
METASOURCES = AUTO
noinst_LIBRARIES = libflash.a
-libflash_a_SOURCES = flash.c lpc2000.c cfi.c at91sam7.c str7x.c
-noinst_HEADERS = flash.h lpc2000.h cfi.h at91sam7.h str7x.h
+libflash_a_SOURCES = flash.c lpc2000.c cfi.c at91sam7.c str7x.c str9x.c
+noinst_HEADERS = flash.h lpc2000.h cfi.h at91sam7.h str7x.h str9x.h
count -= thisrun_count;
}
+ target_free_working_area(target, source);
+
destroy_reg_param(®_params[0]);
destroy_reg_param(®_params[1]);
destroy_reg_param(®_params[2]);
cfi_info->qry[1] = cfi_query_u8(bank, 0, 0x11);
cfi_info->qry[2] = cfi_query_u8(bank, 0, 0x12);
+ DEBUG("CFI qry returned: 0x%2.2x 0x%2.2x 0x%2.2x", cfi_info->qry[0], cfi_info->qry[1], cfi_info->qry[2]);
+
if ((cfi_info->qry[0] != 'Q') || (cfi_info->qry[1] != 'R') || (cfi_info->qry[2] != 'Y'))
{
cfi_command(bank, 0xf0, command);
extern flash_driver_t cfi_flash;
extern flash_driver_t at91sam7_flash;
extern flash_driver_t str7x_flash;
+extern flash_driver_t str9x_flash;
flash_driver_t *flash_drivers[] =
{
&cfi_flash,
&at91sam7_flash,
&str7x_flash,
+ &str9x_flash,
NULL,
};
int last = strtoul(args[2], NULL, 0);
int retval;
flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
+ struct timeval start, end, duration;
+
+ gettimeofday(&start, NULL);
+
if (!p)
{
command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
command_print(cmd_ctx, "unknown error");
}
}
+ else
+ {
+ gettimeofday(&end, NULL);
+ timeval_subtract(&duration, &end, &start);
+
+ command_print(cmd_ctx, "erased sectors %i through %i on flash bank %i in %is %ius", first, last, strtoul(args[0], 0, 0), duration.tv_sec, duration.tv_usec);
+ }
}
else
{
bank->base = 0x80000000;
}
}
+ else if (strcmp(args[5], "STR75x") == 0)
+ {
+ str7x_info->bank1 = 1;
+ if (bank->base != 0x20000000)
+ {
+ WARNING("overriding flash base address for STR75x device with 0x20000000");
+ bank->base = 0x20000000;
+ }
+ }
else
{
ERROR("unknown STR7x variant");
--- /dev/null
+/***************************************************************************
+ * Copyright (C) 2005 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 "replacements.h"
+
+#include "str9x.h"
+#include "flash.h"
+#include "target.h"
+#include "log.h"
+#include "armv4_5.h"
+#include "algorithm.h"
+#include "binarybuffer.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+str9x_mem_layout_t mem_layout_str9[] = {
+ {0x00000000, 0x10000, 0x01},
+ {0x00010000, 0x10000, 0x02},
+ {0x00020000, 0x10000, 0x04},
+ {0x00030000, 0x10000, 0x08},
+ {0x00040000, 0x10000, 0x10},
+ {0x00050000, 0x10000, 0x20},
+ {0x00060000, 0x10000, 0x40},
+ {0x00070000, 0x10000, 0x80},
+ {0x00080000, 0x02000, 0x100},
+ {0x00082000, 0x02000, 0x200},
+ {0x00084000, 0x02000, 0x400},
+ {0x00086000, 0x02000, 0x800}
+};
+
+int str9x_register_commands(struct command_context_s *cmd_ctx);
+int str9x_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank);
+int str9x_erase(struct flash_bank_s *bank, int first, int last);
+int str9x_protect(struct flash_bank_s *bank, int set, int first, int last);
+int str9x_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count);
+int str9x_probe(struct flash_bank_s *bank);
+int str9x_handle_part_id_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+int str9x_protect_check(struct flash_bank_s *bank);
+int str9x_erase_check(struct flash_bank_s *bank);
+int str9x_info(struct flash_bank_s *bank, char *buf, int buf_size);
+
+int str9x_handle_flash_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+
+flash_driver_t str9x_flash =
+{
+ .name = "str9x",
+ .register_commands = str9x_register_commands,
+ .flash_bank_command = str9x_flash_bank_command,
+ .erase = str9x_erase,
+ .protect = str9x_protect,
+ .write = str9x_write,
+ .probe = str9x_probe,
+ .erase_check = str9x_erase_check,
+ .protect_check = str9x_protect_check,
+ .info = str9x_info
+};
+
+int str9x_register_commands(struct command_context_s *cmd_ctx)
+{
+ command_t *str9x_cmd = register_command(cmd_ctx, NULL, "str9x", NULL, COMMAND_ANY, NULL);
+
+ register_command(cmd_ctx, str9x_cmd, "flash_config", str9x_handle_flash_config_command, COMMAND_EXEC,
+ "configure str9 flash controller");
+
+ return ERROR_OK;
+}
+
+int str9x_build_block_list(struct flash_bank_s *bank)
+{
+ str9x_flash_bank_t *str9x_info = bank->driver_priv;
+
+ int i;
+ int num_sectors = 0, b0_sectors = 0;
+
+ switch (bank->size)
+ {
+ case 256 * 1024:
+ b0_sectors = 4;
+ break;
+ case 512 * 1024:
+ b0_sectors = 8;
+ break;
+ default:
+ ERROR("BUG: unknown bank->size encountered");
+ exit(-1);
+ }
+
+ num_sectors = b0_sectors + 2;
+
+ bank->num_sectors = num_sectors;
+ bank->sectors = malloc(sizeof(flash_sector_t) * num_sectors);
+ str9x_info->sector_bits = malloc(sizeof(u32) * num_sectors);
+
+ num_sectors = 0;
+
+ for (i = 0; i < b0_sectors; i++)
+ {
+ bank->sectors[num_sectors].offset = mem_layout_str9[i].sector_start;
+ bank->sectors[num_sectors].size = mem_layout_str9[i].sector_size;
+ bank->sectors[num_sectors].is_erased = -1;
+ bank->sectors[num_sectors].is_protected = 1;
+ str9x_info->sector_bits[num_sectors++] = mem_layout_str9[i].sector_bit;
+ }
+
+ for (i = 8; i < 12; i++)
+ {
+ bank->sectors[num_sectors].offset = mem_layout_str9[i].sector_start;
+ bank->sectors[num_sectors].size = mem_layout_str9[i].sector_size;
+ bank->sectors[num_sectors].is_erased = -1;
+ bank->sectors[num_sectors].is_protected = 1;
+ str9x_info->sector_bits[num_sectors++] = mem_layout_str9[i].sector_bit;
+ }
+
+ return ERROR_OK;
+}
+
+/* flash bank str9x <base> <size> 0 0 <target#>
+ */
+int str9x_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank)
+{
+ str9x_flash_bank_t *str9x_info;
+
+ if (argc < 6)
+ {
+ WARNING("incomplete flash_bank str9x configuration");
+ return ERROR_FLASH_BANK_INVALID;
+ }
+
+ str9x_info = malloc(sizeof(str9x_flash_bank_t));
+ bank->driver_priv = str9x_info;
+
+ if (bank->base != 0x00000000)
+ {
+ WARNING("overriding flash base address for STR91x device with 0x00000000");
+ bank->base = 0x00000000;
+ }
+
+ str9x_info->target = get_target_by_num(strtoul(args[5], NULL, 0));
+ if (!str9x_info->target)
+ {
+ ERROR("no target '%s' configured", args[5]);
+ exit(-1);
+ }
+
+ str9x_build_block_list(bank);
+
+ str9x_info->write_algorithm = NULL;
+
+ return ERROR_OK;
+}
+
+int str9x_blank_check(struct flash_bank_s *bank, int first, int last)
+{
+ str9x_flash_bank_t *str9x_info = bank->driver_priv;
+ target_t *target = str9x_info->target;
+ u8 *buffer;
+ int i;
+ int nBytes;
+
+ if ((first < 0) || (last > bank->num_sectors))
+ return ERROR_FLASH_SECTOR_INVALID;
+
+ if (str9x_info->target->state != TARGET_HALTED)
+ {
+ return ERROR_TARGET_NOT_HALTED;
+ }
+
+ buffer = malloc(256);
+
+ for (i = first; i <= last; i++)
+ {
+ bank->sectors[i].is_erased = 1;
+
+ target->type->read_memory(target, bank->base + bank->sectors[i].offset, 4, 256/4, buffer);
+
+ for (nBytes = 0; nBytes < 256; nBytes++)
+ {
+ if (buffer[nBytes] != 0xFF)
+ {
+ bank->sectors[i].is_erased = 0;
+ break;
+ }
+ }
+ }
+
+ free(buffer);
+
+ return ERROR_OK;
+}
+
+int str9x_protect_check(struct flash_bank_s *bank)
+{
+ str9x_flash_bank_t *str9x_info = bank->driver_priv;
+ target_t *target = str9x_info->target;
+
+ int i;
+ u32 adr;
+ u16 status;
+
+ if (str9x_info->target->state != TARGET_HALTED)
+ {
+ return ERROR_TARGET_NOT_HALTED;
+ }
+
+ /* read level one protection */
+
+ adr = mem_layout_str9[10].sector_start + 4;
+
+ target_write_u32(target, adr, 0x90);
+ target_read_u16(target, adr, &status);
+ target_write_u32(target, adr, 0xFF);
+
+ for (i = 0; i < bank->num_sectors; i++)
+ {
+ if (status & str9x_info->sector_bits[i])
+ bank->sectors[i].is_protected = 1;
+ else
+ bank->sectors[i].is_protected = 0;
+ }
+
+ return ERROR_OK;
+}
+
+int str9x_erase(struct flash_bank_s *bank, int first, int last)
+{
+ str9x_flash_bank_t *str9x_info = bank->driver_priv;
+ target_t *target = str9x_info->target;
+ int i;
+ u32 adr;
+ u8 status;
+
+ if (str9x_info->target->state != TARGET_HALTED)
+ {
+ return ERROR_TARGET_NOT_HALTED;
+ }
+
+ for (i = first; i <= last; i++)
+ {
+ adr = bank->sectors[i].offset;
+
+ /* erase sectors */
+ target_write_u16(target, adr, 0x20);
+ target_write_u16(target, adr, 0xD0);
+
+ /* get status */
+ target_write_u16(target, adr, 0x70);
+
+ while (1) {
+ target_read_u8(target, adr, &status);
+ if( status & 0x80 )
+ break;
+ usleep(1000);
+ }
+
+ /* clear status, also clear read array */
+ target_write_u16(target, adr, 0x50);
+
+ /* read array command */
+ target_write_u16(target, adr, 0xFF);
+
+ if( status & 0x22 )
+ {
+ ERROR("error erasing flash bank, status: 0x%x", status);
+ return ERROR_FLASH_OPERATION_FAILED;
+ }
+ }
+
+ for (i = first; i <= last; i++)
+ bank->sectors[i].is_erased = 1;
+
+ return ERROR_OK;
+}
+
+int str9x_protect(struct flash_bank_s *bank, int set, int first, int last)
+{
+ str9x_flash_bank_t *str9x_info = bank->driver_priv;
+ target_t *target = str9x_info->target;
+ int i;
+ u32 adr;
+ u8 status;
+
+ if (str9x_info->target->state != TARGET_HALTED)
+ {
+ return ERROR_TARGET_NOT_HALTED;
+ }
+
+ for (i = first; i <= last; i++)
+ {
+ /* Level One Protection */
+
+ adr = bank->sectors[i].offset;
+
+ target_write_u16(target, adr, 0x60);
+ if( set )
+ target_write_u16(target, adr, 0x01);
+ else
+ target_write_u16(target, adr, 0xD0);
+
+ /* query status */
+ target_read_u8(target, adr, &status);
+ }
+
+ return ERROR_OK;
+}
+
+int str9x_write_block(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
+{
+ str9x_flash_bank_t *str9x_info = bank->driver_priv;
+ target_t *target = str9x_info->target;
+ u32 buffer_size = 8192;
+ working_area_t *source;
+ u32 address = bank->base + offset;
+ reg_param_t reg_params[4];
+ armv4_5_algorithm_t armv4_5_info;
+ int retval;
+
+ u32 str9x_flash_write_code[] = {
+ /* write: */
+ 0xe3c14003, /* bic r4, r1, #3 */
+ 0xe3a03040, /* mov r3, #0x40 */
+ 0xe1c430b0, /* strh r3, [r4, #0] */
+ 0xe0d030b2, /* ldrh r3, [r0], #2 */
+ 0xe0c130b2, /* strh r3, [r1], #2 */
+ 0xe3a03070, /* mov r3, #0x70 */
+ 0xe1c430b0, /* strh r3, [r4, #0] */
+ /* busy: */
+ 0xe5d43000, /* ldrb r3, [r4, #0] */
+ 0xe3130080, /* tst r3, #0x80 */
+ 0x0afffffc, /* beq busy */
+ 0xe3a05050, /* mov r5, #0x50 */
+ 0xe1c450b0, /* strh r5, [r4, #0] */
+ 0xe3a050ff, /* mov r5, #0xFF */
+ 0xe1c450b0, /* strh r5, [r4, #0] */
+ 0xe3130012, /* tst r3, #0x12 */
+ 0x1a000001, /* bne exit */
+ 0xe2522001, /* subs r2, r2, #1 */
+ 0x1affffed, /* bne write */
+ /* exit: */
+ 0xeafffffe, /* b exit */
+ };
+
+ u8 str9x_flash_write_code_buf[76];
+ int i;
+
+ /* flash write code */
+ if (!str9x_info->write_algorithm)
+ {
+ if (target_alloc_working_area(target, 4 * 19, &str9x_info->write_algorithm) != ERROR_OK)
+ {
+ WARNING("no working area available, can't do block memory writes");
+ return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
+ };
+
+ /* convert flash writing code into a buffer in target endianness */
+ for (i = 0; i < 19; i++)
+ target_buffer_set_u32(target, str9x_flash_write_code_buf + i*4, str9x_flash_write_code[i]);
+
+ target_write_buffer(target, str9x_info->write_algorithm->address, 19 * 4, str9x_flash_write_code_buf);
+ }
+
+ /* memory buffer */
+ while (target_alloc_working_area(target, buffer_size, &source) != ERROR_OK)
+ {
+ buffer_size /= 2;
+ if (buffer_size <= 256)
+ {
+ /* if we already allocated the writing code, but failed to get a buffer, free the algorithm */
+ if (str9x_info->write_algorithm)
+ target_free_working_area(target, str9x_info->write_algorithm);
+
+ WARNING("no large enough working area available, can't do block memory writes");
+ return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
+ }
+ };
+
+ armv4_5_info.common_magic = ARMV4_5_COMMON_MAGIC;
+ armv4_5_info.core_mode = ARMV4_5_MODE_SVC;
+ armv4_5_info.core_state = ARMV4_5_STATE_ARM;
+
+ init_reg_param(®_params[0], "r0", 32, PARAM_OUT);
+ init_reg_param(®_params[1], "r1", 32, PARAM_OUT);
+ init_reg_param(®_params[2], "r2", 32, PARAM_OUT);
+ init_reg_param(®_params[3], "r3", 32, PARAM_IN);
+
+ while (count > 0)
+ {
+ u32 thisrun_count = (count > (buffer_size / 2)) ? (buffer_size / 2) : count;
+
+ target_write_buffer(target, source->address, thisrun_count * 2, buffer);
+
+ buf_set_u32(reg_params[0].value, 0, 32, source->address);
+ buf_set_u32(reg_params[1].value, 0, 32, address);
+ buf_set_u32(reg_params[2].value, 0, 32, thisrun_count);
+
+ if ((retval = target->type->run_algorithm(target, 0, NULL, 4, reg_params, str9x_info->write_algorithm->address, str9x_info->write_algorithm->address + (18 * 4), 10000, &armv4_5_info)) != ERROR_OK)
+ {
+ ERROR("error executing str9x flash write algorithm");
+ return ERROR_FLASH_OPERATION_FAILED;
+ }
+
+ if (buf_get_u32(reg_params[3].value, 0, 32) != 0x80)
+ {
+ return ERROR_FLASH_OPERATION_FAILED;
+ }
+
+ buffer += thisrun_count * 2;
+ address += thisrun_count * 2;
+ count -= thisrun_count;
+ }
+
+ destroy_reg_param(®_params[0]);
+ destroy_reg_param(®_params[1]);
+ destroy_reg_param(®_params[2]);
+ destroy_reg_param(®_params[3]);
+
+ return ERROR_OK;
+}
+
+int str9x_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
+{
+ str9x_flash_bank_t *str9x_info = bank->driver_priv;
+ target_t *target = str9x_info->target;
+ u32 words_remaining = (count / 2);
+ u32 bytes_remaining = (count & 0x00000001);
+ u32 address = bank->base + offset;
+ u32 bytes_written = 0;
+ u8 status;
+ u32 retval;
+ u32 check_address = offset;
+ u32 bank_adr;
+ int i;
+
+ if (str9x_info->target->state != TARGET_HALTED)
+ {
+ return ERROR_TARGET_NOT_HALTED;
+ }
+
+ if (offset & 0x1)
+ {
+ WARNING("offset 0x%x breaks required 2-byte alignment", offset);
+ return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
+ }
+
+ for (i = 0; i < bank->num_sectors; i++)
+ {
+ u32 sec_start = bank->sectors[i].offset;
+ u32 sec_end = sec_start + bank->sectors[i].size;
+
+ /* check if destination falls within the current sector */
+ if ((check_address >= sec_start) && (check_address < sec_end))
+ {
+ /* check if destination ends in the current sector */
+ if (offset + count < sec_end)
+ check_address = offset + count;
+ else
+ check_address = sec_end;
+ }
+ }
+
+ if (check_address != offset + count)
+ return ERROR_FLASH_DST_OUT_OF_BANK;
+
+ /* multiple half words (2-byte) to be programmed? */
+ if (words_remaining > 0)
+ {
+ /* try using a block write */
+ if ((retval = str9x_write_block(bank, buffer, offset, words_remaining)) != ERROR_OK)
+ {
+ if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
+ {
+ /* if block write failed (no sufficient working area),
+ * we use normal (slow) single dword accesses */
+ WARNING("couldn't use block writes, falling back to single memory accesses");
+ }
+ else if (retval == ERROR_FLASH_OPERATION_FAILED)
+ {
+ ERROR("flash writing failed with error code: 0x%x", retval);
+ return ERROR_FLASH_OPERATION_FAILED;
+ }
+ }
+ else
+ {
+ buffer += words_remaining * 2;
+ address += words_remaining * 2;
+ words_remaining = 0;
+ }
+ }
+
+ while (words_remaining > 0)
+ {
+ bank_adr = address & 0x03;
+
+ /* write data command */
+ target_write_u16(target, bank_adr, 0x40);
+ target->type->write_memory(target, address, 2, 1, buffer + bytes_written);
+
+ /* get status command */
+ target_write_u16(target, bank_adr, 0x70);
+
+ while (1) {
+ target_read_u8(target, bank_adr, &status);
+ if( status & 0x80 )
+ break;
+ usleep(1000);
+ }
+
+ /* clear status reg and read array */
+ target_write_u16(target, bank_adr, 0x50);
+ target_write_u16(target, bank_adr, 0xFF);
+
+ if (status & 0x10)
+ return ERROR_FLASH_OPERATION_FAILED;
+ else if (status & 0x02)
+ return ERROR_FLASH_OPERATION_FAILED;
+
+ bytes_written += 2;
+ words_remaining--;
+ address += 2;
+ }
+
+ if (bytes_remaining)
+ {
+ u8 last_halfword[2] = {0xff, 0xff};
+ int i = 0;
+
+ while(bytes_remaining > 0)
+ {
+ last_halfword[i++] = *(buffer + bytes_written);
+ bytes_remaining--;
+ bytes_written++;
+ }
+
+ bank_adr = address & 0x03;
+
+ /* write data comamnd */
+ target_write_u16(target, bank_adr, 0x40);
+ target->type->write_memory(target, address, 2, 1, last_halfword);
+
+ /* query status command */
+ target_write_u16(target, bank_adr, 0x70);
+
+ while (1) {
+ target_read_u8(target, bank_adr, &status);
+ if( status & 0x80 )
+ break;
+ usleep(1000);
+ }
+
+ /* clear status reg and read array */
+ target_write_u16(target, bank_adr, 0x50);
+ target_write_u16(target, bank_adr, 0xFF);
+
+ if (status & 0x10)
+ return ERROR_FLASH_OPERATION_FAILED;
+ else if (status & 0x02)
+ return ERROR_FLASH_OPERATION_FAILED;
+ }
+
+ return ERROR_OK;
+}
+
+int str9x_probe(struct flash_bank_s *bank)
+{
+ return ERROR_OK;
+}
+
+int str9x_handle_part_id_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+{
+ return ERROR_OK;
+}
+
+int str9x_erase_check(struct flash_bank_s *bank)
+{
+ return str9x_blank_check(bank, 0, bank->num_sectors - 1);
+}
+
+int str9x_info(struct flash_bank_s *bank, char *buf, int buf_size)
+{
+ snprintf(buf, buf_size, "str9x flash driver info" );
+ return ERROR_OK;
+}
+
+int str9x_handle_flash_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+{
+ str9x_flash_bank_t *str9x_info;
+ flash_bank_t *bank;
+ target_t *target = NULL;
+
+ if (argc < 4)
+ {
+ command_print(cmd_ctx, "usage: str9x flash_config b0size b1size b0start b1start");
+ return ERROR_OK;
+ }
+
+ bank = get_flash_bank_by_num(0);
+ str9x_info = bank->driver_priv;
+ target = str9x_info->target;
+
+ if (str9x_info->target->state != TARGET_HALTED)
+ {
+ return ERROR_TARGET_NOT_HALTED;
+ }
+
+ /* config flash controller */
+ target_write_u32(target, FLASH_BBSR, strtoul(args[0], NULL, 0));
+ target_write_u32(target, FLASH_NBBSR, strtoul(args[1], NULL, 0));
+ target_write_u32(target, FLASH_BBADR, (strtoul(args[2], NULL, 0) >> 2));
+ target_write_u32(target, FLASH_NBBADR, (strtoul(args[3], NULL, 0) >> 2));
+
+ /* enable flash bank 1 */
+ target_write_u32(target, FLASH_CR, 0x18);
+ return ERROR_OK;
+}
--- /dev/null
+/***************************************************************************
+ * Copyright (C) 2005 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 STR9X_H
+#define STR9X_H
+
+#include "flash.h"
+#include "target.h"
+
+typedef struct str9x_flash_bank_s
+{
+ struct target_s *target;
+ u32 *sector_bits;
+ working_area_t *write_algorithm;
+} str9x_flash_bank_t;
+
+enum str9x_status_codes
+{
+ STR9X_CMD_SUCCESS = 0,
+ STR9X_INVALID_COMMAND = 1,
+ STR9X_SRC_ADDR_ERROR = 2,
+ STR9X_DST_ADDR_ERROR = 3,
+ STR9X_SRC_ADDR_NOT_MAPPED = 4,
+ STR9X_DST_ADDR_NOT_MAPPED = 5,
+ STR9X_COUNT_ERROR = 6,
+ STR9X_INVALID_SECTOR = 7,
+ STR9X_SECTOR_NOT_BLANK = 8,
+ STR9X_SECTOR_NOT_PREPARED = 9,
+ STR9X_COMPARE_ERROR = 10,
+ STR9X_BUSY = 11
+};
+
+/* FMI sectors */
+
+#define FMI_BANK_0 (0x5400000C << 2) /* FMI Bank 0 */
+#define FMI_BANK_1 (0x54000010 << 2) /* FMI Bank 1 */
+
+#define FMI_B0S0 (0x00000000 + FMI_BANK_0) /* Bank 0 sector 0 */
+#define FMI_B0S1 (0x00010000 + FMI_BANK_0) /* Bank 0 sector 1 */
+#define FMI_B0S2 (0x00020000 + FMI_BANK_0) /* Bank 0 sector 2 */
+#define FMI_B0S3 (0x00030000 + FMI_BANK_0) /* Bank 0 sector 3 */
+#define FMI_B0S4 (0x00040000 + FMI_BANK_0) /* Bank 0 sector 4 */
+#define FMI_B0S5 (0x00050000 + FMI_BANK_0) /* Bank 0 sector 5 */
+#define FMI_B0S6 (0x00060000 + FMI_BANK_0) /* Bank 0 sector 6 */
+#define FMI_B0S7 (0x00070000 + FMI_BANK_0) /* Bank 0 sector 7 */
+
+#define FMI_B1S0 (0x00000000 + FMI_BANK_1) /* Bank 1 sector 0 */
+#define FMI_B1S1 (0x00002000 + FMI_BANK_1) /* Bank 1 sector 1 */
+#define FMI_B1S2 (0x00004000 + FMI_BANK_1) /* Bank 1 sector 2 */
+#define FMI_B1S3 (0x00006000 + FMI_BANK_1) /* Bank 1 sector 3 */
+
+/* Flash registers */
+
+#define FLASH_BBSR 0x54000000 /* Boot Bank Size Register */
+#define FLASH_NBBSR 0x54000004 /* Non-Boot Bank Size Register */
+#define FLASH_BBADR 0x5400000C /* Boot Bank Base Address Register */
+#define FLASH_NBBADR 0x54000010 /* Non-Boot Bank Base Address Register */
+#define FLASH_CR 0x54000018 /* Control Register */
+#define FLASH_SR 0x5400001C /* Status Register */
+#define FLASH_BCE5ADDR 0x54000020 /* BC Fifth Entry Target Address Register */
+
+typedef struct str9x_mem_layout_s {
+ u32 sector_start;
+ u32 sector_size;
+ u32 sector_bit;
+} str9x_mem_layout_t;
+
+#endif /* STR9X_H */
+
return c;
}
-char* buf_to_char(u8 *buf, int size)
+int ceil_f_to_u32(float x)
{
- int char_len = CEIL(size, 8) * 2;
- char *char_buf = malloc(char_len + 1);
- int i;
- int bits_left = size;
+ u32 y;
+
+ if (x < 0) /* return zero for negative numbers */
+ return 0;
- char_buf[char_len] = 0;
+ y = x; /* cut off fraction */
- for (i = 0; i < CEIL(size, 8); i++)
+ if ((x - y) > 0.0) /* if there was a fractional part, increase by one */
+ y++;
+
+ return y;
+}
+
+char* buf_to_str(u8 *buf, int buf_len, int radix)
+{
+ const char *DIGITS = "0123456789abcdef";
+ float factor;
+ char *str;
+ int str_len;
+ int b256_len = CEIL(buf_len, 8);
+ u32 tmp;
+
+ int j; /* base-256 digits */
+ int i; /* output digits (radix) */
+
+ if (radix == 16)
{
- if (bits_left < 8)
- {
- buf[i] &= ((1 << bits_left) - 1);
- }
-
- if (((buf[i] & 0x0f) >= 0) && ((buf[i] & 0x0f) <= 9))
- char_buf[char_len - 2*i - 1] = '0' + (buf[i] & 0xf);
- else
- char_buf[char_len - 2*i - 1] = 'a' + (buf[i] & 0xf) - 10;
-
- if (((buf[i] & 0xf0) >> 4 >= 0) && ((buf[i] & 0xf0) >> 4 <= 9))
- char_buf[char_len - 2*i - 2] = '0' + ((buf[i] & 0xf0) >> 4);
- else
- char_buf[char_len - 2*i - 2] = 'a' + ((buf[i] & 0xf0) >> 4) - 10;
-
+ factor = 2.0; /* log(256) / log(16) = 2.0 */
}
+ else if (radix == 10)
+ {
+ factor = 2.40824; /* log(256) / log(10) = 2.40824 */
+ }
+ else if (radix == 8)
+ {
+ factor = 2.66667; /* log(256) / log(8) = 2.66667 */
+ }
+ else
+ return NULL;
+
+ str_len = ceil_f_to_u32(CEIL(buf_len, 8) * factor);
+ str = calloc(str_len + 1, 1);
+
+ for (i = b256_len - 1; i >= 0; i--)
+ {
+ tmp = buf[i];
+ if ((i == (buf_len / 8)) && (buf_len % 8))
+ tmp &= (0xff >> (8 - (buf_len % 8)));
- return char_buf;
+ for (j = str_len; j > 0; j--)
+ {
+ tmp += (u32)str[j-1] * 256;
+ str[j-1] = (u8)(tmp % radix);
+ tmp /= radix;
+ }
+ }
+
+ for (j = 0; j < str_len; j++)
+ str[j] = DIGITS[(int)str[j]];
+
+ return str;
}
-int char_to_buf(char *buf, int len, u8 *bin_buf, int buf_size)
+int str_to_buf(char* str, int str_len, u8 *buf, int buf_len, int radix)
{
- int bin_len = CEIL(len, 2);
- int i;
+ char *charbuf;
+ u32 tmp;
+ float factor;
+ u8 *b256_buf;
+ int b256_len;
- if (buf_size < CEIL(bin_len, 8))
- return 0;
+ int j; /* base-256 digits */
+ int i; /* input digits (ASCII) */
+
+ if (radix == 0)
+ {
+ /* identify radix, and skip radix-prefix (0, 0x or 0X) */
+ if ((str[0] == '0') && (str[1] && ((str[1] == 'x') || (str[1] == 'X'))))
+ {
+ radix = 16;
+ str += 2;
+ str_len -= 2;
+ }
+ else if ((str[0] == '0') && (str_len != 1))
+ {
+ radix = 8;
+ str += 1;
+ str_len -= 1;
+ }
+ else
+ {
+ radix = 10;
+ }
+ }
- if (len % 2)
+ if (radix == 16)
+ factor = 0.5; /* log(16) / log(256) = 0.5 */
+ else if (radix == 10)
+ factor = 0.41524; /* log(10) / log(256) = 0.41524 */
+ else if (radix == 8)
+ factor = 0.375; /* log(8) / log(256) = 0.375 */
+ else
return 0;
+
+ /* copy to zero-terminated buffer */
+ charbuf = malloc(str_len + 1);
+ memcpy(charbuf, str, str_len);
+ charbuf[str_len] = '\0';
- for (i = 0; i < strlen(buf); i++)
- {
- u32 tmp;
- sscanf(buf + 2*i, "%2x", &tmp);
- bin_buf[i] = tmp & 0xff;
+ /* number of digits in base-256 notation */
+ b256_len = ceil_f_to_u32(str_len * factor);
+ b256_buf = calloc(b256_len, 1);
+
+ /* go through zero terminated buffer */
+ for (i = 0; charbuf[i]; i++)
+ {
+ tmp = charbuf[i];
+ if ((tmp >= '0') && (tmp <= '9'))
+ tmp = (tmp - '0');
+ else if ((tmp >= 'a') && (tmp <= 'f'))
+ tmp = (tmp - 'a' + 10);
+ else if ((tmp >= 'A') && (tmp <= 'F'))
+ tmp = (tmp - 'A' + 10);
+ else continue; /* skip characters other than [0-9,a-f,A-F] */
+
+ if (tmp >= radix)
+ continue; /* skip digits invalid for the current radix */
+
+ for (j = 0; j < b256_len; j++)
+ {
+ tmp += (u32)b256_buf[j] * radix;
+ b256_buf[j] = (u8)(tmp & 0xFF);
+ tmp >>= 8;
+ }
+
}
- return bin_len * 8;
+ for (j = 0; j < CEIL(buf_len, 8); j++)
+ buf[j] = b256_buf[j];
+
+ /* mask out bits that don't belong to the buffer */
+ if (buf_len % 8)
+ buf[(buf_len / 8)] &= 0xff >> (8 - (buf_len % 8));
+
+ free(b256_buf);
+ free(charbuf);
+
+ return i;
}
int buf_to_u32_handler(u8 *in_buf, void *priv)
extern u8* buf_set_ones(u8 *buf, int count);
extern u8* buf_set_buf(u8 *src, int src_start, u8 *dst, int dst_start, int len);
-extern char* buf_to_char(u8 *buf, int size);
-extern int char_to_buf(char *buf, int len, u8 *bin_buf, int buf_size);
+extern int str_to_buf(char* str, int len, u8 *bin_buf, int buf_size, int radix);
+extern char* buf_to_str(u8 *buf, int size, int radix);
extern int buf_to_u32_handler(u8 *in_buf, void *priv);
last_var_p = &((*last_var_p)->next);
}
- if ((args[0][0] >= 0) && (args[0][0] <= 9))
+ if ((args[0][0] >= '0') && (args[0][0] <= '9'))
{
command_print(cmd_ctx, "invalid name specified (first character may not be a number)");
return ERROR_OK;
{
if (cmd->fields[i].out_value)
{
- char* char_buf = buf_to_char(cmd->fields[i].out_value, cmd->fields[i].num_bits);
- buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
#ifdef _DEBUG_JTAG_IO_
- DEBUG("fields[%i].out_value: %s", i, char_buf);
+ char* char_buf = buf_to_str(cmd->fields[i].out_value, cmd->fields[i].num_bits, 16);
#endif
+ buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
+#ifdef _DEBUG_JTAG_IO_
+ DEBUG("fields[%i].out_value: 0x%s", i, char_buf);
free(char_buf);
+#endif
}
bit_count += cmd->fields[i].num_bits;
#ifdef _DEBUG_JTAG_IO_
char *char_buf;
- char_buf = buf_to_char(captured, num_bits);
- DEBUG("fields[%i].in_value: %s", i, char_buf);
+ char_buf = buf_to_str(captured, num_bits, 16);
+ DEBUG("fields[%i].in_value: 0x%s", i, char_buf);
free(char_buf);
#endif
if ((cmd->fields[i].in_check_mask && buf_cmp_mask(captured, cmd->fields[i].in_check_value, cmd->fields[i].in_check_mask, num_bits))
|| (!cmd->fields[i].in_check_mask && buf_cmp(captured, cmd->fields[i].in_check_mask, num_bits)))
{
- char *captured_char = buf_to_char(captured, num_bits);
- char *in_check_value_char = buf_to_char(cmd->fields[i].in_check_value, num_bits);
- char *in_check_mask_char = buf_to_char(cmd->fields[i].in_check_mask, num_bits);
+ char *captured_char = buf_to_str(captured, num_bits, 16);
+ char *in_check_value_char = buf_to_str(cmd->fields[i].in_check_value, num_bits, 16);
+ char *in_check_mask_char = buf_to_str(cmd->fields[i].in_check_mask, num_bits, 16);
/* TODO: error reporting */
- WARNING("value captured during scan didn't pass the requested check: captured: %s check_value: %s check_mask: %s", captured_char, in_check_value_char, in_check_mask_char);
+ WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s check_mask: 0x%s", captured_char, in_check_value_char, in_check_mask_char);
retval = ERROR_JTAG_QUEUE_FAILED;
free(captured_char);
free(in_check_value_char);
{
if (buf_get_u32(ir_test, chain_pos, 2) != 0x1)
{
- char *cbuf = buf_to_char(ir_test, total_ir_length);
- ERROR("Error validating JTAG scan chain, IR mismatch, scan returned %s", cbuf);
+ char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
+ ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
free(cbuf);
exit(-1);
}
if (buf_get_u32(ir_test, chain_pos, 2) != 0x3)
{
- char *cbuf = buf_to_char(ir_test, total_ir_length);
- ERROR("Error validating JTAG scan chain, IR mismatch, scan returned %s", cbuf);
+ char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
+ ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
free(cbuf);
exit(-1);
}
return ERROR_OK;
}
+void gdb_send_error(connection_t *connection, u8 the_error)
+{
+ char err[4];
+ snprintf(err, 4, "E%2.2X", the_error );
+ gdb_put_packet(connection, err, 3);
+}
+
int gdb_last_signal_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
{
char sig_reply[4];
return ERROR_OK;
}
-void gdb_get_registers_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
+void gdb_str_to_target(target_t *target, char *str, char *tstr)
+{
+ int str_len = strlen(str);
+ int i;
+
+ if (str_len % 2)
+ {
+ ERROR("BUG: gdb value with uneven number of characters encountered");
+ exit(-1);
+ }
+
+ if (target->endianness == TARGET_LITTLE_ENDIAN)
+ {
+ for (i = 0; i < str_len; i+=2)
+ {
+ tstr[str_len - i - 1] = str[i + 1];
+ tstr[str_len - i - 2] = str[i];
+ }
+ }
+ else
+ {
+ for (i = 0; i < str_len; i++)
+ {
+ tstr[i] = str[i];
+ }
+ }
+}
+
+void gdb_target_to_str(target_t *target, char *tstr, char *str)
+{
+ int str_len = strlen(tstr);
+ int i;
+
+ if (str_len % 2)
+ {
+ ERROR("BUG: gdb value with uneven number of characters encountered");
+ exit(-1);
+ }
+
+ if (target->endianness == TARGET_LITTLE_ENDIAN)
+ {
+ for (i = 0; i < str_len; i+=2)
+ {
+ str[str_len - i - 1] = tstr[i + 1];
+ str[str_len - i - 2] = tstr[i];
+ }
+ }
+ else
+ {
+ for (i = 0; i < str_len; i++)
+ {
+ str[i] = tstr[i];
+ }
+ }
+}
+
+int gdb_get_registers_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
{
reg_t **reg_list;
int reg_list_size;
switch (retval)
{
case ERROR_TARGET_NOT_HALTED:
- ERROR("gdb requested registers, but we're not halted");
- exit(-1);
+ ERROR("gdb requested registers but we're not halted, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
default:
+ /* this is a bug condition - get_gdb_reg_list() may not return any other error */
ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
exit(-1);
}
for (i = 0; i < reg_list_size; i++)
{
- int j;
- char *hex_buf = buf_to_char(reg_list[i]->value, reg_list[i]->size);
+ char *hex_buf = buf_to_str(reg_list[i]->value, reg_list[i]->size, 16);
DEBUG("hex_buf: %s", hex_buf);
- for (j = CEIL(reg_list[i]->size, 8) * 2; j > 0; j -= 2)
- {
- *reg_packet_p++ = hex_buf[j - 2];
- *reg_packet_p++ = hex_buf[j - 1];
- }
+ gdb_str_to_target(target, hex_buf, reg_packet_p);
+ reg_packet_p += CEIL(reg_list[i]->size, 8) * 2;
free(hex_buf);
}
gdb_put_packet(connection, reg_packet, CEIL(reg_packet_size, 8) * 2);
free(reg_packet);
+ free(reg_list);
+
+ return ERROR_OK;
}
-void gdb_set_registers_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_set_registers_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
int i;
reg_t **reg_list;
if (packet_size % 2)
{
- WARNING("GDB set_registers packet with uneven characters received");
- return;
+ WARNING("GDB set_registers packet with uneven characters received, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
}
if ((retval = target->type->get_gdb_reg_list(target, ®_list, ®_list_size)) != ERROR_OK)
switch (retval)
{
case ERROR_TARGET_NOT_HALTED:
- ERROR("gdb requested registers, but we're not halted");
- exit(-1);
+ ERROR("gdb tried to registers but we're not halted, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
default:
+ /* this is a bug condition - get_gdb_reg_list() may not return any other error */
ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
exit(-1);
}
packet_p = packet;
for (i = 0; i < reg_list_size; i++)
{
- char_to_buf(packet, CEIL(reg_list[i]->size, 8) * 2, reg_list[i]->value, reg_list[i]->size);
- reg_list[i]->dirty = 1;
+ u8 *bin_buf;
+ char *hex_buf;
+ reg_arch_type_t *arch_type;
+
+ /* convert from GDB-string (target-endian) to hex-string (big-endian) */
+ hex_buf = malloc(CEIL(reg_list[i]->size, 8) * 2);
+ gdb_target_to_str(target, packet_p, hex_buf);
+
+ /* convert hex-string to binary buffer */
+ bin_buf = malloc(CEIL(reg_list[i]->size, 8));
+ str_to_buf(hex_buf, CEIL(reg_list[i]->size, 8) * 2, bin_buf, reg_list[i]->size, 16);
+
+ /* get register arch_type, and call set method */
+ arch_type = register_get_arch_type(reg_list[i]->arch_type);
+ if (arch_type == NULL)
+ {
+ ERROR("BUG: encountered unregistered arch type");
+ exit(-1);
+ }
+ arch_type->set(reg_list[i], bin_buf);
+
+ /* advance packet pointer */
+ packet_p += (CEIL(reg_list[i]->size, 8) * 2);
+
+ free(bin_buf);
+ free(hex_buf);
}
+
+ /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
+ free(reg_list);
gdb_put_packet(connection, "OK", 2);
+
+ return ERROR_OK;
}
-void gdb_get_register_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_get_register_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
- char *hex_buf;
char *reg_packet;
- char *reg_packet_p;
int reg_num = strtoul(packet + 1, NULL, 16);
reg_t **reg_list;
int reg_list_size;
int retval;
- int i;
+ char *hex_buf;
DEBUG("");
switch (retval)
{
case ERROR_TARGET_NOT_HALTED:
- ERROR("gdb requested registers, but we're not halted");
- exit(-1);
+ ERROR("gdb requested registers but we're not halted, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
default:
+ /* this is a bug condition - get_gdb_reg_list() may not return any other error */
ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
exit(-1);
}
exit(-1);
}
- hex_buf = buf_to_char(reg_list[reg_num]->value, reg_list[reg_num]->size);
- reg_packet = reg_packet_p = malloc(CEIL(reg_list[reg_num]->size, 8) * 2);
+ reg_packet = malloc(CEIL(reg_list[reg_num]->size, 8) * 2);
+
+ hex_buf = buf_to_str(reg_list[reg_num]->value, reg_list[reg_num]->size, 16);
- for (i = CEIL(reg_list[reg_num]->size, 8) * 2; i > 0; i -= 2)
- {
- *reg_packet_p++ = hex_buf[i - 2];
- *reg_packet_p++ = hex_buf[i - 1];
- }
+ gdb_str_to_target(target, reg_packet, hex_buf);
gdb_put_packet(connection, reg_packet, CEIL(reg_list[reg_num]->size, 8) * 2);
+ free(reg_list);
free(reg_packet);
free(hex_buf);
+ return ERROR_OK;
}
-void gdb_set_register_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_set_register_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
char *separator;
+ char *hex_buf;
+ u8 *bin_buf;
int reg_num = strtoul(packet + 1, &separator, 16);
reg_t **reg_list;
int reg_list_size;
int retval;
-
+ reg_arch_type_t *arch_type;
+
DEBUG("");
if ((retval = target->type->get_gdb_reg_list(target, ®_list, ®_list_size)) != ERROR_OK)
switch (retval)
{
case ERROR_TARGET_NOT_HALTED:
- ERROR("gdb requested registers, but we're not halted");
- exit(-1);
+ ERROR("gdb tried to set a register but we're not halted, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
default:
+ /* this is a bug condition - get_gdb_reg_list() may not return any other error */
ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
exit(-1);
}
if (reg_list_size < reg_num)
{
ERROR("gdb requested a non-existing register");
- exit(-1);
+ return ERROR_SERVER_REMOTE_CLOSED;
}
if (*separator != '=')
{
- ERROR("GDB set register packet, but no '=' following the register number");
- exit(-1);
+ ERROR("GDB 'set register packet', but no '=' following the register number");
+ return ERROR_SERVER_REMOTE_CLOSED;
}
- char_to_buf(separator + 1, CEIL(reg_list[reg_num]->size, 8) * 2, reg_list[reg_num]->value, reg_list[reg_num]->size);
- reg_list[reg_num]->dirty = 1;
+ /* convert from GDB-string (target-endian) to hex-string (big-endian) */
+ hex_buf = malloc(CEIL(reg_list[reg_num]->size, 8) * 2);
+ gdb_target_to_str(target, separator + 1, hex_buf);
+
+ /* convert hex-string to binary buffer */
+ bin_buf = malloc(CEIL(reg_list[reg_num]->size, 8));
+ str_to_buf(hex_buf, CEIL(reg_list[reg_num]->size, 8) * 2, bin_buf, reg_list[reg_num]->size, 16);
+
+ /* get register arch_type, and call set method */
+ arch_type = register_get_arch_type(reg_list[reg_num]->arch_type);
+ if (arch_type == NULL)
+ {
+ ERROR("BUG: encountered unregistered arch type");
+ exit(-1);
+ }
+ arch_type->set(reg_list[reg_num], bin_buf);
gdb_put_packet(connection, "OK", 2);
+ free(bin_buf);
+ free(hex_buf);
+ free(reg_list);
+
+ return ERROR_OK;
}
-void gdb_read_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_memory_packet_error(connection_t *connection, int retval)
+{
+ switch (retval)
+ {
+ case ERROR_TARGET_NOT_HALTED:
+ ERROR("gdb tried to read memory but we're not halted, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
+ break;
+ case ERROR_TARGET_DATA_ABORT:
+ gdb_send_error(connection, EIO);
+ break;
+ case ERROR_TARGET_TRANSLATION_FAULT:
+ gdb_send_error(connection, EFAULT);
+ break;
+ case ERROR_TARGET_UNALIGNED_ACCESS:
+ gdb_send_error(connection, EFAULT);
+ break;
+ default:
+ ERROR("BUG: unexpected error %i", retval);
+ exit(-1);
+ }
+
+ return ERROR_OK;
+}
+
+int gdb_read_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
char *separator;
u32 addr = 0;
char *hex_buffer;
int i;
+ int retval;
/* skip command character */
packet++;
addr = strtoul(packet, &separator, 16);
if (*separator != ',')
- return;
+ {
+ ERROR("incomplete read memory packet received, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
+ }
len = strtoul(separator+1, NULL, 16);
{
case 4:
if ((addr % 4) == 0)
- target->type->read_memory(target, addr, 4, 1, buffer);
+ retval = target->type->read_memory(target, addr, 4, 1, buffer);
else
- target->type->read_memory(target, addr, 1, len, buffer);
+ retval = target->type->read_memory(target, addr, 1, len, buffer);
break;
case 2:
if ((addr % 2) == 0)
- target->type->read_memory(target, addr, 2, 1, buffer);
+ retval = target->type->read_memory(target, addr, 2, 1, buffer);
else
- target->type->read_memory(target, addr, 1, len, buffer);
+ retval = target->type->read_memory(target, addr, 1, len, buffer);
break;
default:
if (((addr % 4) == 0) && ((len % 4) == 0))
- target->type->read_memory(target, addr, 4, len / 4, buffer);
+ retval = target->type->read_memory(target, addr, 4, len / 4, buffer);
else
- target->type->read_memory(target, addr, 1, len, buffer);
+ retval = target->type->read_memory(target, addr, 1, len, buffer);
}
- hex_buffer = malloc(len * 2 + 1);
+ if (retval == ERROR_OK)
+ {
+ hex_buffer = malloc(len * 2 + 1);
+
+ for (i=0; i<len; i++)
+ snprintf(hex_buffer + 2*i, 3, "%2.2x", buffer[i]);
- for (i=0; i<len; i++)
- snprintf(hex_buffer + 2*i, 3, "%2.2x", buffer[i]);
-
- gdb_put_packet(connection, hex_buffer, len * 2);
+ gdb_put_packet(connection, hex_buffer, len * 2);
- free(hex_buffer);
+ free(hex_buffer);
+ }
+ else
+ {
+ if ((retval = gdb_memory_packet_error(connection, retval)) != ERROR_OK)
+ return retval;
+ }
+
free(buffer);
+
+ return ERROR_OK;
}
-void gdb_write_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_write_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
char *separator;
u32 addr = 0;
u8 *buffer;
int i;
+ int retval;
/* skip command character */
packet++;
addr = strtoul(packet, &separator, 16);
if (*separator != ',')
- return;
+ {
+ ERROR("incomplete write memory packet received, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
+ }
len = strtoul(separator+1, &separator, 16);
if (*(separator++) != ':')
- return;
+ {
+ ERROR("incomplete write memory packet received, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
+ }
buffer = malloc(len);
/* handle sized writes */
case 4:
if ((addr % 4) == 0)
- target->type->write_memory(target, addr, 4, 1, buffer);
+ retval = target->type->write_memory(target, addr, 4, 1, buffer);
else
- target->type->write_memory(target, addr, 1, len, buffer);
+ retval = target->type->write_memory(target, addr, 1, len, buffer);
break;
case 2:
if ((addr % 2) == 0)
- target->type->write_memory(target, addr, 2, 1, buffer);
+ retval = target->type->write_memory(target, addr, 2, 1, buffer);
else
- target->type->write_memory(target, addr, 1, len, buffer);
+ retval = target->type->write_memory(target, addr, 1, len, buffer);
break;
case 3:
case 1:
- target->type->write_memory(target, addr, 1, len, buffer);
+ retval = target->type->write_memory(target, addr, 1, len, buffer);
break;
/* handle bulk writes */
default:
- target_write_buffer(target, addr, len, buffer);
+ retval = target_write_buffer(target, addr, len, buffer);
break;
}
- gdb_put_packet(connection, "OK", 2);
+ if (retval == ERROR_OK)
+ {
+ gdb_put_packet(connection, "OK", 2);
+ }
+ else
+ {
+ if ((retval = gdb_memory_packet_error(connection, retval)) != ERROR_OK)
+ return retval;
+ }
free(buffer);
+
+ return ERROR_OK;
}
-void gdb_write_memory_binary_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_write_memory_binary_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
char *separator;
u32 addr = 0;
u32 len = 0;
u8 *buffer;
+ int retval;
/* skip command character */
packet++;
addr = strtoul(packet, &separator, 16);
if (*separator != ',')
- return;
+ {
+ ERROR("incomplete write memory binary packet received, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
+ }
len = strtoul(separator+1, &separator, 16);
if (*(separator++) != ':')
- return;
+ {
+ ERROR("incomplete write memory binary packet received, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
+ }
if( len ) {
{
case 4:
if ((addr % 4) == 0)
- target->type->write_memory(target, addr, 4, 1, buffer);
+ retval = target->type->write_memory(target, addr, 4, 1, buffer);
else
- target->type->write_memory(target, addr, 1, len, buffer);
+ retval = target->type->write_memory(target, addr, 1, len, buffer);
break;
case 2:
if ((addr % 2) == 0)
- target->type->write_memory(target, addr, 2, 1, buffer);
+ retval = target->type->write_memory(target, addr, 2, 1, buffer);
else
- target->type->write_memory(target, addr, 1, len, buffer);
+ retval = target->type->write_memory(target, addr, 1, len, buffer);
break;
case 3:
case 1:
- target->type->write_memory(target, addr, 1, len, buffer);
+ retval = target->type->write_memory(target, addr, 1, len, buffer);
break;
default:
- target_write_buffer(target, addr, len, buffer);
+ retval = target_write_buffer(target, addr, len, buffer);
break;
}
free(buffer);
}
- gdb_put_packet(connection, "OK", 2);
+ if (retval == ERROR_OK)
+ {
+ gdb_put_packet(connection, "OK", 2);
+ }
+ else
+ {
+ if ((retval = gdb_memory_packet_error(connection, retval)) != ERROR_OK)
+ return retval;
+ }
+
+ return ERROR_OK;
}
void gdb_step_continue_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
if (packet_size > 1)
{
- u32 address = 0;
packet[packet_size] = 0;
address = strtoul(packet + 1, NULL, 16);
}
}
}
-void gdb_breakpoint_watchpoint_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_bp_wp_packet_error(connection_t *connection, int retval)
+{
+ switch (retval)
+ {
+ case ERROR_TARGET_NOT_HALTED:
+ ERROR("gdb tried to set a breakpoint but we're not halted, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
+ break;
+ case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
+ gdb_send_error(connection, EBUSY);
+ break;
+ default:
+ ERROR("BUG: unexpected error %i", retval);
+ exit(-1);
+ }
+
+ return ERROR_OK;
+}
+
+int gdb_breakpoint_watchpoint_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
int type;
enum breakpoint_type bp_type;
wp_type = WPT_ACCESS;
if (*separator != ',')
- return;
+ {
+ ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
+ }
address = strtoul(separator+1, &separator, 16);
if (*separator != ',')
- return;
+ {
+ ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
+ return ERROR_SERVER_REMOTE_CLOSED;
+ }
size = strtoul(separator+1, &separator, 16);
{
if ((retval = breakpoint_add(target, address, size, bp_type)) != ERROR_OK)
{
- if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
- {
- gdb_put_packet(connection, "E00", 3);
- break;
- }
+ if ((retval = gdb_bp_wp_packet_error(connection, retval)) != ERROR_OK)
+ return retval;
+ }
+ else
+ {
+ gdb_put_packet(connection, "OK", 2);
}
}
else
{
breakpoint_remove(target, address);
+ gdb_put_packet(connection, "OK", 2);
}
- gdb_put_packet(connection, "OK", 2);
break;
case 2:
case 3:
case 4:
{
if (packet[0] == 'Z')
- watchpoint_add(target, address, size, type-2, 0, 0xffffffffu);
+ {
+ if ((retval = watchpoint_add(target, address, size, type-2, 0, 0xffffffffu)) != ERROR_OK)
+ {
+ if ((retval = gdb_bp_wp_packet_error(connection, retval)) != ERROR_OK)
+ return retval;
+ }
+ else
+ {
+ gdb_put_packet(connection, "OK", 2);
+ }
+ }
else
+ {
watchpoint_remove(target, address);
- gdb_put_packet(connection, "OK", 2);
+ gdb_put_packet(connection, "OK", 2);
+ }
break;
}
default:
break;
}
+ return ERROR_OK;
}
void gdb_query_packet(connection_t *connection, char *packet, int packet_size)
{
command_context_t *cmd_ctx = connection->cmd_ctx;
- gdb_service_t *gdb_service = connection->service->priv;
- target_t *target = gdb_service->target;
if (strstr(packet, "qRcmd,"))
{
case ERROR_SERVER_REMOTE_CLOSED:
return ERROR_SERVER_REMOTE_CLOSED;
default:
- ERROR("unexpected error");
+ ERROR("BUG: unexpected error");
exit(-1);
}
}
if (packet_size > 0)
{
+ retval = ERROR_OK;
switch (packet[0])
{
case 'H':
gdb_query_packet(connection, packet, packet_size);
break;
case 'g':
- gdb_get_registers_packet(connection, target, packet, packet_size);
+ retval = gdb_get_registers_packet(connection, target, packet, packet_size);
break;
case 'G':
- gdb_set_registers_packet(connection, target, packet, packet_size);
+ retval = gdb_set_registers_packet(connection, target, packet, packet_size);
break;
case 'p':
- gdb_get_register_packet(connection, target, packet, packet_size);
+ retval = gdb_get_register_packet(connection, target, packet, packet_size);
break;
case 'P':
- gdb_set_register_packet(connection, target, packet, packet_size);
+ retval = gdb_set_register_packet(connection, target, packet, packet_size);
break;
case 'm':
- gdb_read_memory_packet(connection, target, packet, packet_size);
+ retval = gdb_read_memory_packet(connection, target, packet, packet_size);
break;
case 'M':
- gdb_write_memory_packet(connection, target, packet, packet_size);
+ retval = gdb_write_memory_packet(connection, target, packet, packet_size);
break;
case 'z':
case 'Z':
- gdb_breakpoint_watchpoint_packet(connection, target, packet, packet_size);
+ retval = gdb_breakpoint_watchpoint_packet(connection, target, packet, packet_size);
break;
case '?':
gdb_last_signal_packet(connection, target, packet, packet_size);
gdb_put_packet(connection, "OK", 2);
break;
case 'X':
- gdb_write_memory_binary_packet(connection, target, packet, packet_size);
+ if ((retval = gdb_write_memory_binary_packet(connection, target, packet, packet_size)) != ERROR_OK)
+ return retval;
break;
case 'k':
gdb_put_packet(connection, "OK", 2);
gdb_put_packet(connection, NULL, 0);
break;
}
+
+ /* if a packet handler returned an error, exit input loop */
+ if (retval != ERROR_OK)
+ return retval;
}
if (gdb_con->ctrl_c)
.write_memory = arm7_9_write_memory,
.bulk_write_memory = arm7_9_bulk_write_memory,
+ .run_algorithm = armv4_5_run_algorithm,
+
.add_breakpoint = arm7_9_add_breakpoint,
.remove_breakpoint = arm7_9_remove_breakpoint,
.add_watchpoint = arm7_9_add_watchpoint,
.write_memory = arm7_9_write_memory,
.bulk_write_memory = arm7_9_bulk_write_memory,
+ .run_algorithm = armv4_5_run_algorithm,
+
.add_breakpoint = arm7_9_add_breakpoint,
.remove_breakpoint = arm7_9_remove_breakpoint,
.add_watchpoint = arm7_9_add_watchpoint,
return retval;
}
-int armv4_5_set_core_reg(reg_t *reg, u32 value)
+int armv4_5_set_core_reg(reg_t *reg, u8 *buf)
{
armv4_5_core_reg_t *armv4_5 = reg->arch_info;
target_t *target = armv4_5->target;
+ armv4_5_common_t *armv4_5_target = target->arch_info;
+ u32 value = buf_get_u32(buf, 0, 32);
if (target->state != TARGET_HALTED)
{
return ERROR_TARGET_NOT_HALTED;
}
+ if (reg == &armv4_5_target->core_cache->reg_list[ARMV4_5_CPSR])
+ {
+ if (value & 0x20)
+ {
+ /* T bit should be set */
+ if (armv4_5_target->core_state == ARMV4_5_STATE_ARM)
+ {
+ /* change state to Thumb */
+ DEBUG("changing to Thumb state");
+ armv4_5_target->core_state = ARMV4_5_STATE_THUMB;
+ }
+ }
+ else
+ {
+ /* T bit should be cleared */
+ if (armv4_5_target->core_state == ARMV4_5_STATE_THUMB)
+ {
+ /* change state to ARM */
+ DEBUG("changing to ARM state");
+ armv4_5_target->core_state = ARMV4_5_STATE_ARM;
+ }
+ }
+ }
+
buf_set_u32(reg->value, 0, 32, value);
reg->dirty = 1;
reg->valid = 1;
exit(-1);
}
- armv4_5_set_core_reg(reg, buf_get_u32(reg_params[i].value, 0, 32));
+ armv4_5_set_core_reg(reg, reg_params[i].value);
}
armv4_5->core_state = armv4_5_algorithm_info->core_state;
int embeddedice_get_reg(reg_t *reg);
int embeddedice_set_reg(reg_t *reg, u32 value);
+int embeddedice_set_reg_w_exec(reg_t *reg, u8 *buf);
int embeddedice_write_reg(reg_t *reg, u32 value);
int embeddedice_read_reg(reg_t *reg);
return ERROR_OK;
}
-int embeddedice_set_reg_w_exec(reg_t *reg, u32 value)
+int embeddedice_set_reg_w_exec(reg_t *reg, u8 *buf)
{
- embeddedice_set_reg(reg, value);
+ embeddedice_set_reg(reg, buf_get_u32(buf, 0, reg->size));
if (jtag_execute_queue() != ERROR_OK)
{
extern int embeddedice_read_reg_w_check(reg_t *reg, u8* check_value, u8* check_mask);
extern int embeddedice_store_reg(reg_t *reg);
extern int embeddedice_set_reg(reg_t *reg, u32 value);
-extern int embeddedice_set_reg_w_exec(reg_t *reg, u32 value);
+extern int embeddedice_set_reg_w_exec(reg_t *reg, u8 *buf);
#endif /* EMBEDDED_ICE_H */
int etm_get_reg(reg_t *reg);
int etm_set_reg(reg_t *reg, u32 value);
+int etm_set_reg_w_exec(reg_t *reg, u8 *buf);
int etm_write_reg(reg_t *reg, u32 value);
int etm_read_reg(reg_t *reg);
return ERROR_OK;
}
-int etm_set_reg_w_exec(reg_t *reg, u32 value)
+int etm_set_reg_w_exec(reg_t *reg, u8 *buf)
{
- etm_set_reg(reg, value);
+ etm_set_reg(reg, buf_get_u32(buf, 0, reg->size));
if (jtag_execute_queue() != ERROR_OK)
{
extern int etm_read_reg_w_check(reg_t *reg, u8* check_value, u8* check_mask);\r
extern int etm_store_reg(reg_t *reg);\r
extern int etm_set_reg(reg_t *reg, u32 value);\r
-extern int etm_set_reg_w_exec(reg_t *reg, u32 value);\r
+extern int etm_set_reg_w_exec(reg_t *reg, u8 *buf);\r
\r
#endif /* ETM_H */\r
return cache_p;
}
-int register_reg_arch_type(int (*get)(reg_t *reg), int (*set)(reg_t *reg, u32 value))
+int register_reg_arch_type(int (*get)(reg_t *reg), int (*set)(reg_t *reg, u8 *buf))
{
reg_arch_type_t** arch_type_p = ®_arch_types;
int id = 0;
{
int id;
int (*get)(reg_t *reg);
- int (*set)(reg_t *reg, u32 value);
+ int (*set)(reg_t *reg, u8 *buf);
struct reg_arch_type_s *next;
} reg_arch_type_t;
extern reg_t* register_get_by_name(reg_cache_t *first, char *name, int search_all);
extern reg_cache_t** register_get_last_cache_p(reg_cache_t **first);
-extern int register_reg_arch_type(int (*get)(reg_t *reg), int (*set)(reg_t *reg, u32 value));
+extern int register_reg_arch_type(int (*get)(reg_t *reg), int (*set)(reg_t *reg, u8 *buf));
extern reg_arch_type_t* register_get_arch_type(int id);
#endif /* REGISTER_H */
int i;
for (i = 0; i < cache->num_regs; i++)
{
- value = buf_to_char(cache->reg_list[i].value, cache->reg_list[i].size);
+ value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
command_print(cmd_ctx, "(%i) %s (/%i): 0x%s (dirty: %i, valid: %i)", count++, cache->reg_list[i].name, cache->reg_list[i].size, value, cache->reg_list[i].dirty, cache->reg_list[i].valid);
free(value);
}
}
arch_type->get(reg);
}
- value = buf_to_char(reg->value, reg->size);
+ value = buf_to_str(reg->value, reg->size, 16);
command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
free(value);
return ERROR_OK;
/* set register value */
if (argc == 2)
{
- u32 new_value = strtoul(args[1], NULL, 0);
+ u8 *buf = malloc(CEIL(reg->size, 8));
+ str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
+
reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
if (arch_type == NULL)
{
return ERROR_OK;
}
- arch_type->set(reg, new_value);
- value = buf_to_char(reg->value, reg->size);
+ arch_type->set(reg, buf);
+
+ value = buf_to_str(reg->value, reg->size, 16);
command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
free(value);
+ free(buf);
+
return ERROR_OK;
}
{
if (breakpoint->type == BKPT_SOFT)
{
- char* buf = buf_to_char(breakpoint->orig_instr, breakpoint->length);
+ char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
free(buf);
}
projects / openocd / commitdiff