- Replace ')\(=\)\(\w\)' with ') \1 \2'.
- Replace '\(\w\)\(=\)(' with '\1 \2 ('.
- Replace '\(\w\)\(=\)\(\w\)' with '\1 \2 \3'.
git-svn-id: svn://svn.berlios.de/openocd/trunk@2372
b42882b7-edfa-0310-969c-
e2dbd0fdcd60
73 files changed:
}
mkdir(zylin_config_dir, 0777);
}
mkdir(zylin_config_dir, 0777);
- char *dirname=alloc_printf("%s/target", zylin_config_dir);
+ char *dirname = alloc_printf("%s/target", zylin_config_dir);
mkdir(dirname, 0777);
free(dirname);
mkdir(dirname, 0777);
free(dirname);
- dirname=alloc_printf("%s/board", zylin_config_dir);
+ dirname = alloc_printf("%s/board", zylin_config_dir);
mkdir(dirname, 0777);
free(dirname);
mkdir(dirname, 0777);
free(dirname);
- dirname=alloc_printf("%s/event", zylin_config_dir);
+ dirname = alloc_printf("%s/event", zylin_config_dir);
mkdir(dirname, 0777);
free(dirname);
mkdir(dirname, 0777);
free(dirname);
if (logAllToSerial)
{
diag_printf(
if (logAllToSerial)
{
diag_printf(
- "%s/logserial=1 => sending log output to serial port using \"debug_level 3\" as default.\n", zylin_config_dir);
+ "%s/logserial = 1 => sending log output to serial port using \"debug_level 3\" as default.\n", zylin_config_dir);
command_run_line(cmd_ctx, "debug_level 3");
}
command_run_line(cmd_ctx, "debug_level 3");
}
if (fmcn > 0xFF)
fmcn = 0xFF;
if (fmcn > 0xFF)
fmcn = 0xFF;
- /* Only allow fmcn=0 if clock period is > 30 us = 33kHz. */
+ /* Only allow fmcn = 0 if clock period is > 30 us = 33kHz. */
if (at91sam7_info->mck_freq <= 33333ul)
fmcn = 0;
if (at91sam7_info->mck_freq <= 33333ul)
fmcn = 0;
- /* Only allow fws=0 if clock frequency is < 30 MHz. */
+ /* Only allow fws = 0 if clock frequency is < 30 MHz. */
if (at91sam7_info->mck_freq > 30000000ul)
fws = 1;
if (at91sam7_info->mck_freq > 30000000ul)
fws = 1;
/* calculate bank size */
bank_size = sectors_num * pages_per_sector * page_size;
/* calculate bank size */
bank_size = sectors_num * pages_per_sector * page_size;
- for (bnk=0; bnk<banks_num; bnk++)
+ for (bnk = 0; bnk<banks_num; bnk++)
/* allocate sectors */
t_bank->sectors = malloc(sectors_num * sizeof(flash_sector_t));
/* allocate sectors */
t_bank->sectors = malloc(sectors_num * sizeof(flash_sector_t));
- for (sec=0; sec<sectors_num; sec++)
+ for (sec = 0; sec<sectors_num; sec++)
{
t_bank->sectors[sec].offset = sec * pages_per_sector * page_size;
t_bank->sectors[sec].size = pages_per_sector * page_size;
{
t_bank->sectors[sec].offset = sec * pages_per_sector * page_size;
t_bank->sectors[sec].size = pages_per_sector * page_size;
at91sam7_set_flash_mode(bank, FMR_TIMING_FLASH);
fast_check = 1;
at91sam7_set_flash_mode(bank, FMR_TIMING_FLASH);
fast_check = 1;
- for (nSector=0; nSector<bank->num_sectors; nSector++)
+ for (nSector = 0; nSector<bank->num_sectors; nSector++)
{
retval = target_blank_check_memory(target, bank->base+bank->sectors[nSector].offset,
bank->sectors[nSector].size, &blank);
{
retval = target_blank_check_memory(target, bank->base+bank->sectors[nSector].offset,
bank->sectors[nSector].size, &blank);
LOG_USER("Running slow fallback erase check - add working memory");
buffer = malloc(bank->sectors[0].size);
LOG_USER("Running slow fallback erase check - add working memory");
buffer = malloc(bank->sectors[0].size);
- for (nSector=0; nSector<bank->num_sectors; nSector++)
+ for (nSector = 0; nSector<bank->num_sectors; nSector++)
{
bank->sectors[nSector].is_erased = 1;
retval = target_read_memory(target, bank->base+bank->sectors[nSector].offset, 4,
{
bank->sectors[nSector].is_erased = 1;
retval = target_read_memory(target, bank->base+bank->sectors[nSector].offset, 4,
if (retval != ERROR_OK)
return retval;
if (retval != ERROR_OK)
return retval;
- for (nByte=0; nByte<bank->sectors[nSector].size; nByte++)
+ for (nByte = 0; nByte<bank->sectors[nSector].size; nByte++)
{
if (buffer[nByte] != 0xFF)
{
{
if (buffer[nByte] != 0xFF)
{
at91sam7_info->lockbits = (status >> 16);
at91sam7_info->num_lockbits_on = 0;
at91sam7_info->lockbits = (status >> 16);
at91sam7_info->num_lockbits_on = 0;
- for (lock_pos=0; lock_pos<bank->num_sectors; lock_pos++)
+ for (lock_pos = 0; lock_pos<bank->num_sectors; lock_pos++)
{
if ( ((status >> (16+lock_pos))&(0x0001)) == 1)
{
{
if ( ((status >> (16+lock_pos))&(0x0001)) == 1)
{
at91sam7_info->nvmbits = (status >> 8)&0xFF;
at91sam7_info->num_nvmbits_on = 0;
at91sam7_info->nvmbits = (status >> 8)&0xFF;
at91sam7_info->num_nvmbits_on = 0;
- for (gpnvm_pos=0; gpnvm_pos<at91sam7_info->num_nvmbits; gpnvm_pos++)
+ for (gpnvm_pos = 0; gpnvm_pos<at91sam7_info->num_nvmbits; gpnvm_pos++)
{
if ( ((status >> (8+gpnvm_pos))&(0x01)) == 1)
{
{
if ( ((status >> (8+gpnvm_pos))&(0x01)) == 1)
{
/* calculate bank size */
bank_size = num_sectors * pages_per_sector * page_size;
/* calculate bank size */
bank_size = num_sectors * pages_per_sector * page_size;
- for (bnk=0; bnk<banks_num; bnk++)
+ for (bnk = 0; bnk<banks_num; bnk++)
/* allocate sectors */
t_bank->sectors = malloc(num_sectors * sizeof(flash_sector_t));
/* allocate sectors */
t_bank->sectors = malloc(num_sectors * sizeof(flash_sector_t));
- for (sec=0; sec<num_sectors; sec++)
+ for (sec = 0; sec<num_sectors; sec++)
{
t_bank->sectors[sec].offset = sec * pages_per_sector * page_size;
t_bank->sectors[sec].size = pages_per_sector * page_size;
{
t_bank->sectors[sec].offset = sec * pages_per_sector * page_size;
t_bank->sectors[sec].size = pages_per_sector * page_size;
/* allocate and clean buffer */
nbytes = (last - first + 1) * bank->sectors[first].size;
buffer = malloc(nbytes * sizeof(uint8_t));
/* allocate and clean buffer */
nbytes = (last - first + 1) * bank->sectors[first].size;
buffer = malloc(nbytes * sizeof(uint8_t));
- for (pos=0; pos<nbytes; pos++)
+ for (pos = 0; pos<nbytes; pos++)
}
/* mark erased sectors */
}
/* mark erased sectors */
- for (sec=first; sec <= last; sec++)
+ for (sec = first; sec <= last; sec++)
{
bank->sectors[sec].is_erased = 1;
}
{
bank->sectors[sec].is_erased = 1;
}
at91sam7_read_clock_info(bank);
at91sam7_set_flash_mode(bank, FMR_TIMING_NVBITS);
at91sam7_read_clock_info(bank);
at91sam7_set_flash_mode(bank, FMR_TIMING_NVBITS);
- for (sector=first; sector <= last; sector++)
+ for (sector = first; sector <= last; sector++)
at91sam7_read_clock_info(bank);
at91sam7_set_flash_mode(bank, FMR_TIMING_FLASH);
at91sam7_read_clock_info(bank);
at91sam7_set_flash_mode(bank, FMR_TIMING_FLASH);
- for (pagen=first_page; pagen<last_page; pagen++)
+ for (pagen = first_page; pagen<last_page; pagen++)
{
if (bytes_remaining<dst_min_alignment)
count = bytes_remaining;
{
if (bytes_remaining<dst_min_alignment)
count = bytes_remaining;
if (cfi_info->x16_as_x8)
{
uint8_t i;
if (cfi_info->x16_as_x8)
{
uint8_t i;
target_read_memory(target, flash_address(bank, sector, offset+i), bank->bus_width, 1,
&data[i*bank->bus_width] );
}
target_read_memory(target, flash_address(bank, sector, offset+i), bank->bus_width, 1,
&data[i*bank->bus_width] );
}
if (cfi_info->x16_as_x8)
{
uint8_t i;
if (cfi_info->x16_as_x8)
{
uint8_t i;
target_read_memory(target, flash_address(bank, sector, offset+i), bank->bus_width, 1,
&data[i*bank->bus_width] );
}
target_read_memory(target, flash_address(bank, sector, offset+i), bank->bus_width, 1,
&data[i*bank->bus_width] );
}
static void cfi_fix_code_endian(target_t *target, uint8_t *dest, const uint32_t *src, uint32_t count)
{
uint32_t i;
static void cfi_fix_code_endian(target_t *target, uint8_t *dest, const uint32_t *src, uint32_t count)
{
uint32_t i;
- for (i=0; i< count; i++)
+ for (i = 0; i< count; i++)
{
target_buffer_set_u32(target, dest, *src);
dest += 4;
{
target_buffer_set_u32(target, dest, *src);
dest += 4;
cfi_fix_code_endian(target, target_code, src, target_code_size / 4);
/* allocate working area */
cfi_fix_code_endian(target, target_code, src, target_code_size / 4);
/* allocate working area */
- retval=target_alloc_working_area(target, target_code_size,
+ retval = target_alloc_working_area(target, target_code_size,
&cfi_info->write_algorithm);
if (retval != ERROR_OK)
{
&cfi_info->write_algorithm);
if (retval != ERROR_OK)
{
buffer += buffersize;
write_p += buffersize;
count -= buffersize;
buffer += buffersize;
write_p += buffersize;
count -= buffersize;
}
}
/* try the slow way? */
}
}
/* try the slow way? */
uint32_t start_address;
} ecosflash_flash_bank_t;
uint32_t start_address;
} ecosflash_flash_bank_t;
-static const int sectorSize=0x10000;
+static const int sectorSize = 0x10000;
char *
flash_errmsg(int err);
char *
flash_errmsg(int err);
exit(-1);
}
bank->driver_priv = info;
exit(-1);
}
bank->driver_priv = info;
- info->driverPath=strdup(args[6]);
+ info->driverPath = strdup(args[6]);
/* eCos flash sector sizes are not exposed to OpenOCD, use 0x10000 as
* a way to improve impeadance matach between OpenOCD and eCos flash
/* eCos flash sector sizes are not exposed to OpenOCD, use 0x10000 as
* a way to improve impeadance matach between OpenOCD and eCos flash
*/
int i = 0;
uint32_t offset = 0;
*/
int i = 0;
uint32_t offset = 0;
- bank->num_sectors=bank->size/sectorSize;
+ bank->num_sectors = bank->size/sectorSize;
bank->sectors = malloc(sizeof(flash_sector_t) * bank->num_sectors);
for (i = 0; i < bank->num_sectors; i++)
{
bank->sectors = malloc(sizeof(flash_sector_t) * bank->num_sectors);
for (i = 0; i < bank->num_sectors; i++)
{
image.base_address_set = 0;
image.start_address_set = 0;
image.base_address_set = 0;
image.start_address_set = 0;
- target_t *target=info->target;
+ target_t *target = info->target;
- if ((retval=image_open(&image, info->driverPath, NULL)) != ERROR_OK)
+ if ((retval = image_open(&image, info->driverPath, NULL)) != ERROR_OK)
- info->start_address=image.start_address;
+ info->start_address = image.start_address;
-static int const OFFSET_ERASE=0x0;
-static int const OFFSET_ERASE_SIZE=0x8;
-static int const OFFSET_FLASH=0xc;
-static int const OFFSET_FLASH_SIZE=0x8;
-static int const OFFSET_GET_WORKAREA=0x18;
-static int const OFFSET_GET_WORKAREA_SIZE=0x4;
+static int const OFFSET_ERASE = 0x0;
+static int const OFFSET_ERASE_SIZE = 0x8;
+static int const OFFSET_FLASH = 0xc;
+static int const OFFSET_FLASH_SIZE = 0x8;
+static int const OFFSET_GET_WORKAREA = 0x18;
+static int const OFFSET_GET_WORKAREA_SIZE = 0x4;
static int runCode(ecosflash_flash_bank_t *info,
uint32_t codeStart, uint32_t codeStop, uint32_t r0, uint32_t r1, uint32_t r2,
static int runCode(ecosflash_flash_bank_t *info,
uint32_t codeStart, uint32_t codeStop, uint32_t r0, uint32_t r1, uint32_t r2,
/* timeout in ms */
int timeout)
{
/* timeout in ms */
int timeout)
{
- target_t *target=info->target;
+ target_t *target = info->target;
reg_param_t reg_params[3];
armv4_5_algorithm_t armv4_5_info;
reg_param_t reg_params[3];
armv4_5_algorithm_t armv4_5_info;
- *result=buf_get_u32(reg_params[0].value, 0, 32);
+ *result = buf_get_u32(reg_params[0].value, 0, 32);
destroy_reg_param(®_params[0]);
destroy_reg_param(®_params[1]);
destroy_reg_param(®_params[0]);
destroy_reg_param(®_params[1]);
int retval;
int timeout = (len / 20480 + 1) * 1000; /*asume 20 KB/s*/
int retval;
int timeout = (len / 20480 + 1) * 1000; /*asume 20 KB/s*/
- retval=loadDriver(info);
+ retval = loadDriver(info);
if (retval != ERROR_OK)
return retval;
uint32_t flashErr;
if (retval != ERROR_OK)
return retval;
uint32_t flashErr;
info->start_address+OFFSET_ERASE,
info->start_address+OFFSET_ERASE+OFFSET_ERASE_SIZE,
address,
info->start_address+OFFSET_ERASE,
info->start_address+OFFSET_ERASE+OFFSET_ERASE_SIZE,
address,
static int eCosBoard_flash(ecosflash_flash_bank_t *info, void *data, uint32_t address, uint32_t len)
{
static int eCosBoard_flash(ecosflash_flash_bank_t *info, void *data, uint32_t address, uint32_t len)
{
- target_t *target=info->target;
- const int chunk=8192;
- int retval=ERROR_OK;
+ target_t *target = info->target;
+ const int chunk = 8192;
+ int retval = ERROR_OK;
int timeout = (chunk / 20480 + 1) * 1000; /*asume 20 KB/s + 1 second*/
int timeout = (chunk / 20480 + 1) * 1000; /*asume 20 KB/s + 1 second*/
- retval=loadDriver(info);
+ retval = loadDriver(info);
if (retval != ERROR_OK)
return retval;
uint32_t buffer;
if (retval != ERROR_OK)
return retval;
uint32_t buffer;
info->start_address+OFFSET_GET_WORKAREA,
info->start_address+OFFSET_GET_WORKAREA+OFFSET_GET_WORKAREA_SIZE,
0,
info->start_address+OFFSET_GET_WORKAREA,
info->start_address+OFFSET_GET_WORKAREA+OFFSET_GET_WORKAREA_SIZE,
0,
- for (i=0; i<len; i += chunk)
+ for (i = 0; i<len; i += chunk)
- retval=target_write_buffer(target, buffer, t, ((uint8_t *)data)+i);
+ retval = target_write_buffer(target, buffer, t, ((uint8_t *)data)+i);
if (retval != ERROR_OK)
return retval;
uint32_t flashErr;
if (retval != ERROR_OK)
return retval;
uint32_t flashErr;
info->start_address+OFFSET_FLASH,
info->start_address+OFFSET_FLASH+OFFSET_FLASH_SIZE,
buffer,
info->start_address+OFFSET_FLASH,
info->start_address+OFFSET_FLASH+OFFSET_FLASH_SIZE,
buffer,
static int ecosflash_erase(struct flash_bank_s *bank, int first, int last)
{
static int ecosflash_erase(struct flash_bank_s *bank, int first, int last)
{
- struct flash_bank_s *c=bank;
+ struct flash_bank_s *c = bank;
ecosflash_flash_bank_t *info = bank->driver_priv;
return eCosBoard_erase(info, c->base+first*sectorSize, sectorSize*(last-first+1));
}
ecosflash_flash_bank_t *info = bank->driver_priv;
return eCosBoard_erase(info, c->base+first*sectorSize, sectorSize*(last-first+1));
}
static int ecosflash_write(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
{
ecosflash_flash_bank_t *info = bank->driver_priv;
static int ecosflash_write(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
{
ecosflash_flash_bank_t *info = bank->driver_priv;
- struct flash_bank_s *c=bank;
+ struct flash_bank_s *c = bank;
return eCosBoard_flash(info, buffer, c->base+offset, count);
}
return eCosBoard_flash(info, buffer, c->base+offset, count);
}
- retval=bank->driver->write(bank, buffer, offset, count);
+ retval = bank->driver->write(bank, buffer, offset, count);
if (retval != ERROR_OK)
{
LOG_ERROR("error writing to flash at address 0x%08" PRIx32 " at offset 0x%8.8" PRIx32 " (%d)",
if (retval != ERROR_OK)
{
LOG_ERROR("error writing to flash at address 0x%08" PRIx32 " at offset 0x%8.8" PRIx32 " (%d)",
- retval=bank->driver->erase(bank, first, last);
+ retval = bank->driver->erase(bank, first, last);
if (retval != ERROR_OK)
{
LOG_ERROR("failed erasing sectors %d to %d (%d)", first, last, retval);
if (retval != ERROR_OK)
{
LOG_ERROR("failed erasing sectors %d to %d (%d)", first, last, retval);
- retval=bank->driver->protect(bank, set, first, last);
+ retval = bank->driver->protect(bank, set, first, last);
if (retval != ERROR_OK)
{
LOG_ERROR("failed setting protection for areas %d to %d (%d)", first, last, retval);
if (retval != ERROR_OK)
{
LOG_ERROR("failed setting protection for areas %d to %d (%d)", first, last, retval);
- Jim_Obj *list=Jim_NewListObj(interp, NULL, 0);
+ Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
for (p = flash_banks; p; p = p->next)
{
for (p = flash_banks; p; p = p->next)
{
- Jim_Obj *elem=Jim_NewListObj(interp, NULL, 0);
+ Jim_Obj *elem = Jim_NewListObj(interp, NULL, 0);
Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "name", -1));
Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, p->driver->name, -1));
Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "name", -1));
Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, p->driver->name, -1));
c->sectors = NULL;
c->next = NULL;
c->sectors = NULL;
c->next = NULL;
- if ((retval=flash_drivers[i]->flash_bank_command(cmd_ctx, cmd, args, argc, c)) != ERROR_OK)
+ if ((retval = flash_drivers[i]->flash_bank_command(cmd_ctx, cmd, args, argc, c)) != ERROR_OK)
{
LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32 , args[0], c->base);
free(c);
{
LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32 , args[0], c->base);
free(c);
switch (cmd[4])
{
case 'w':
switch (cmd[4])
{
case 'w':
break;
default:
return ERROR_COMMAND_SYNTAX_ERROR;
break;
default:
return ERROR_COMMAND_SYNTAX_ERROR;
duration_start_measure(&duration);
duration_start_measure(&duration);
- for (wrote=0; wrote<(count*wordsize); wrote += cur_size)
+ for (wrote = 0; wrote<(count*wordsize); wrote += cur_size)
{
cur_size = MIN( (count*wordsize - wrote), sizeof(chunk) );
flash_bank_t *bank;
{
cur_size = MIN( (count*wordsize - wrote), sizeof(chunk) );
flash_bank_t *bank;
- for (i=0; i<cur_size; i++)
+ for (i = 0; i<cur_size; i++)
{
if (readback[i]!=chunk[i])
{
{
if (readback[i]!=chunk[i])
{
if (err == ERROR_OK)
{
float speed;
if (err == ERROR_OK)
{
float speed;
+ speed = wrote / 1024.0;
speed/=((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0));
command_print(cmd_ctx,
"wrote %" PRId32 " bytes to 0x%8.8" PRIx32 " in %s (%f kb/s)",
speed/=((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0));
command_print(cmd_ctx,
"wrote %" PRId32 " bytes to 0x%8.8" PRIx32 " in %s (%f kb/s)",
/* write (optional verify) an image to flash memory of the given target */
int flash_write(target_t *target, image_t *image, uint32_t *written, int erase)
{
/* write (optional verify) an image to flash memory of the given target */
int flash_write(target_t *target, image_t *image, uint32_t *written, int erase)
{
int section;
uint32_t section_offset;
int section;
uint32_t section_offset;
/// Number of bytes in this flash sector.
uint32_t size;
/**
/// Number of bytes in this flash sector.
uint32_t size;
/**
- * Indication of erasure status: 0=not erased, 1=erased,
- * other=unknown. Set by @c flash_driver_s::erase_check.
+ * Indication of erasure status: 0 = not erased, 1 = erased,
+ * other = unknown. Set by @c flash_driver_s::erase_check.
- * Indication of protection status: 0=unprotected/unlocked,
- * 1=protected/locked, other=unknown. Set by
+ * Indication of protection status: 0 = unprotected/unlocked,
+ * 1 = protected/locked, other = unknown. Set by
* @c flash_driver_s::protect_check.
*/
int is_protected;
* @c flash_driver_s::protect_check.
*/
int is_protected;
checksum = 0 - checksum;
LOG_DEBUG("checksum: 0x%8.8" PRIx32, checksum);
checksum = 0 - checksum;
LOG_DEBUG("checksum: 0x%8.8" PRIx32, checksum);
- uint32_t original_value=buf_get_u32(buffer + (5 * 4), 0, 32);
+ uint32_t original_value = buf_get_u32(buffer + (5 * 4), 0, 32);
if (original_value != checksum)
{
LOG_WARNING("Verification will fail since checksum in image(0x%8.8" PRIx32 ") written to flash was different from calculated vector checksum(0x%8.8" PRIx32 ").",
if (original_value != checksum)
{
LOG_WARNING("Verification will fail since checksum in image(0x%8.8" PRIx32 ") written to flash was different from calculated vector checksum(0x%8.8" PRIx32 ").",
uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET;
duration_t duration;
int ret;
uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET;
duration_t duration;
int ret;
duration_start_measure(&duration);
duration_start_measure(&duration);
duration_stop_measure(&duration, NULL);
duration_stop_measure(&duration, NULL);
- t=duration.duration.tv_usec/1000;
+ t = duration.duration.tv_usec/1000;
t += duration.duration.tv_sec*1000;
if (t > time)
t += duration.duration.tv_sec*1000;
if (t > time)
- for (i = 1, M=0; i < 512; i <<= 1, feedback_div >>= 1)
+ for (i = 1, M = 0; i < 512; i <<= 1, feedback_div >>= 1)
M += (feedback_div & 1) * i;
return M + 2;
M += (feedback_div & 1) * i;
return M + 2;
chksum = OCL_CHKS_INIT;
/* copy data to DCC buffer in proper byte order and properly aligned */
chksum = OCL_CHKS_INIT;
/* copy data to DCC buffer in proper byte order and properly aligned */
- for (i=0; i<runlen; i++)
+ for (i = 0; i<runlen; i++)
return ERROR_FLASH_BANK_INVALID;
}
sectsize = bank->size / bank->num_sectors;
return ERROR_FLASH_BANK_INVALID;
}
sectsize = bank->size / bank->num_sectors;
- for (i=0; i<bank->num_sectors; i++)
+ for (i = 0; i<bank->num_sectors; i++)
{
bank->sectors[i].offset = i * sectsize;
bank->sectors[i].size = sectsize;
{
bank->sectors[i].offset = i * sectsize;
bank->sectors[i].size = sectsize;
- adr=dcc_rd();
- len=cmd&0xffff;
- ofs=adr%flash_page_size;
- bi_start=ofs/4;
- bi_end=(ofs+len+3)/4;
+ adr = dcc_rd();
+ len = cmd&0xffff;
+ ofs = adr%flash_page_size;
+ bi_start = ofs/4;
+ bi_end = (ofs+len+3)/4;
if (bi_end>BUFSIZE) {
dcc_wr(OCL_BUFF_OVER);
return;
}
if (bi_end>BUFSIZE) {
dcc_wr(OCL_BUFF_OVER);
return;
}
- chksum=OCL_CHKS_INIT;
- for (bi=0; bi<bi_end; bi++) chksum^=buffer[bi]=dcc_rd();
+ chksum = OCL_CHKS_INIT;
+ for (bi = 0; bi<bi_end; bi++) chksum^=buffer[bi]=dcc_rd();
if (dcc_rd() != chksum) {
dcc_wr(OCL_CHKS_FAIL);
if (dcc_rd() != chksum) {
dcc_wr(OCL_CHKS_FAIL);
}
/* fill in unused positions with unprogrammed values */
}
/* fill in unused positions with unprogrammed values */
- for (bi=0; bi<bi_start; bi++) buffer[bi]=0xffffffff;
- for (bi=bi_end; bi%flash_page_size; bi++) buffer[bi]=0xffffffff;
+ for (bi = 0; bi<bi_start; bi++) buffer[bi]=0xffffffff;
+ for (bi = bi_end; bi%flash_page_size; bi++) buffer[bi]=0xffffffff;
- result=0;
- pagenum=adr/flash_page_size;
- for (bi=0; bi<bi_end; bi += flash_page_size/4) {
- result=flash_page_program(buffer+bi, pagenum++);
+ result = 0;
+ pagenum = adr/flash_page_size;
+ for (bi = 0; bi<bi_end; bi += flash_page_size/4) {
+ result = flash_page_program(buffer+bi, pagenum++);
if (result) break;
}
/* verify written data */
if (result) break;
}
/* verify written data */
- if (!result) result=flash_verify(adr, len, ((uint8 *)buffer)+ofs);
+ if (!result) result = flash_verify(adr, len, ((uint8 *)buffer)+ofs);
dcc_wr(OCL_CMD_DONE|result);
}
dcc_wr(OCL_CMD_DONE|result);
}
switch (cmd&OCL_CMD_MASK) {
case OCL_PROBE:
dcc_wr(OCL_CMD_DONE|flash_init());
switch (cmd&OCL_CMD_MASK) {
case OCL_PROBE:
dcc_wr(OCL_CMD_DONE|flash_init());
-unsigned int flash_page_count=1024;
-unsigned int flash_page_size=256;
+unsigned int flash_page_count = 1024;
+unsigned int flash_page_size = 256;
-unsigned int flash_lock_pages=1024/16;
+unsigned int flash_lock_pages = 1024/16;
/* detect chip and set loader parameters */
/* detect chip and set loader parameters */
- nvpsiz=(inr(DBGU_CIDR) >> 8)&0xf;
+ nvpsiz = (inr(DBGU_CIDR) >> 8)&0xf;
switch (nvpsiz) {
case 3:
/* AT91SAM7x32 */
switch (nvpsiz) {
case 3:
/* AT91SAM7x32 */
- flash_page_count=256;
- flash_page_size=128;
- flash_lock_pages=256/8;
+ flash_page_count = 256;
+ flash_page_size = 128;
+ flash_lock_pages = 256/8;
break;
case 5:
/* AT91SAM7x64 */
break;
case 5:
/* AT91SAM7x64 */
- flash_page_count=512;
- flash_page_size=128;
- flash_lock_pages=512/16;
+ flash_page_count = 512;
+ flash_page_size = 128;
+ flash_lock_pages = 512/16;
break;
case 7:
/* AT91SAM7x128*/
break;
case 7:
/* AT91SAM7x128*/
- flash_page_count=512;
- flash_page_size=256;
- flash_lock_pages=512/8;
+ flash_page_count = 512;
+ flash_page_size = 256;
+ flash_lock_pages = 512/8;
break;
case 9:
/* AT91SAM7x256 */
break;
case 9:
/* AT91SAM7x256 */
- flash_page_count=1024;
- flash_page_size=256;
- flash_lock_pages=1024/16;
+ flash_page_count = 1024;
+ flash_page_size = 256;
+ flash_lock_pages = 1024/16;
break;
case 10:
/* AT91SAM7x512 */
break;
case 10:
/* AT91SAM7x512 */
- flash_page_count=2048;
- flash_page_size=256;
- flash_lock_pages=2048/32;
+ flash_page_count = 2048;
+ flash_page_size = 256;
+ flash_lock_pages = 2048/32;
break;
default:
return FLASH_STAT_INITE;
break;
default:
return FLASH_STAT_INITE;
uint32 *data_ptr;
/* select proper controller */
uint32 *data_ptr;
/* select proper controller */
- if (page_num >= 1024) efc_ofs=0x10;
- else efc_ofs=0;
+ if (page_num >= 1024) efc_ofs = 0x10;
+ else efc_ofs = 0;
/* wait until FLASH is ready, just for sure */
while ((inr(MC_FSR+efc_ofs)&MC_FRDY) == 0);
/* calculate page address, only lower 8 bits are used to address the latch,
but the upper part of address is needed for writing to proper EFC */
/* wait until FLASH is ready, just for sure */
while ((inr(MC_FSR+efc_ofs)&MC_FRDY) == 0);
/* calculate page address, only lower 8 bits are used to address the latch,
but the upper part of address is needed for writing to proper EFC */
- flash_ptr=(uint32 *)(FLASH_AREA_ADDR+(page_num*flash_page_size));
- data_ptr=data;
+ flash_ptr = (uint32 *)(FLASH_AREA_ADDR+(page_num*flash_page_size));
+ data_ptr = data;
- for (i=flash_page_size/4; i; i--) {
+ for (i = flash_page_size/4; i; i--) {
/* we do not use memcpy to be sure that only 32 bit access is used */
*(flash_ptr++)=*(data_ptr++);
}
/* we do not use memcpy to be sure that only 32 bit access is used */
*(flash_ptr++)=*(data_ptr++);
}
#if 0
/* verify written data */
#if 0
/* verify written data */
- flash_ptr=(uint32 *)(FLASH_AREA_ADDR+(page_num*flash_page_size));
- data_ptr=data;
+ flash_ptr = (uint32 *)(FLASH_AREA_ADDR+(page_num*flash_page_size));
+ data_ptr = data;
- for (i=flash_page_size/4; i; i--) {
+ for (i = flash_page_size/4; i; i--) {
if (*(flash_ptr++)!=*(data_ptr++)) return FLASH_STAT_VERIFE;
}
#endif
if (*(flash_ptr++)!=*(data_ptr++)) return FLASH_STAT_VERIFE;
}
#endif
unsigned int lockbits;
int page_num;
unsigned int lockbits;
int page_num;
- page_num=0;
- lockbits=inr(MC_FSR+efc_ofs) >> 16;
+ page_num = 0;
+ lockbits = inr(MC_FSR+efc_ofs) >> 16;
while (lockbits) {
if (lockbits&1) {
while (lockbits) {
if (lockbits&1) {
- if ((result=flash_erase_plane(0)) != FLASH_STAT_OK) return result;
+ if ((result = flash_erase_plane(0)) != FLASH_STAT_OK) return result;
/* the second flash controller, if any */
/* the second flash controller, if any */
- if (flash_page_count>1024) result=flash_erase_plane(0x10);
+ if (flash_page_count>1024) result = flash_erase_plane(0x10);
{
unsigned char *flash_ptr;
{
unsigned char *flash_ptr;
- flash_ptr=(uint8 *)FLASH_AREA_ADDR+adr;
+ flash_ptr = (uint8 *)FLASH_AREA_ADDR+adr;
for ( ;len; len--) {
if (*(flash_ptr++)!=*(src++)) return FLASH_STAT_VERIFE;
}
for ( ;len; len--) {
if (*(flash_ptr++)!=*(src++)) return FLASH_STAT_VERIFE;
}
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
};
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
};
- if ((retval=target_write_buffer(target, pic32mx_info->write_algorithm->address, sizeof(pic32mx_flash_write_code), pic32mx_flash_write_code)) != ERROR_OK)
+ if ((retval = target_write_buffer(target, pic32mx_info->write_algorithm->address, sizeof(pic32mx_flash_write_code), pic32mx_flash_write_code)) != ERROR_OK)
#endif
status = pic32mx_write_row(bank, address, source->address);
if ( status & NVMCON_NVMERR ) {
#endif
status = pic32mx_write_row(bank, address, source->address);
if ( status & NVMCON_NVMERR ) {
- LOG_ERROR("Flash write error NVMERR (status=0x%08" PRIx32 ")", status);
+ LOG_ERROR("Flash write error NVMERR (status = 0x%08" PRIx32 ")", status);
retval = ERROR_FLASH_OPERATION_FAILED;
break;
}
if ( status & NVMCON_LVDERR ) {
retval = ERROR_FLASH_OPERATION_FAILED;
break;
}
if ( status & NVMCON_LVDERR ) {
- LOG_ERROR("Flash write error LVDERR (status=0x%08" PRIx32 ")", status);
+ LOG_ERROR("Flash write error LVDERR (status = 0x%08" PRIx32 ")", status);
retval = ERROR_FLASH_OPERATION_FAILED;
break;
}
retval = ERROR_FLASH_OPERATION_FAILED;
break;
}
uint32_t status = pic32mx_write_word(bank, address, value);
if ( status & NVMCON_NVMERR ) {
uint32_t status = pic32mx_write_word(bank, address, value);
if ( status & NVMCON_NVMERR ) {
- LOG_ERROR("Flash write error NVMERR (status=0x%08" PRIx32 ")", status);
+ LOG_ERROR("Flash write error NVMERR (status = 0x%08" PRIx32 ")", status);
retval = ERROR_FLASH_OPERATION_FAILED;
break;
}
if ( status & NVMCON_LVDERR ) {
retval = ERROR_FLASH_OPERATION_FAILED;
break;
}
if ( status & NVMCON_LVDERR ) {
- LOG_ERROR("Flash write error LVDERR (status=0x%08" PRIx32 ")", status);
+ LOG_ERROR("Flash write error LVDERR (status = 0x%08" PRIx32 ")", status);
retval = ERROR_FLASH_OPERATION_FAILED;
break;
}
retval = ERROR_FLASH_OPERATION_FAILED;
break;
}
num_pages = 12;
} else {
/* 0xBD000000: Program flash size varies with device */
num_pages = 12;
} else {
/* 0xBD000000: Program flash size varies with device */
- for (i=0; pic32mx_devs[i].name != NULL; i++)
+ for (i = 0; pic32mx_devs[i].name != NULL; i++)
if (pic32mx_devs[i].devid == ((device_id >> 12) & 0xff)) {
num_pages = pic32mx_devs[i].pfm_size;
break;
if (pic32mx_devs[i].devid == ((device_id >> 12) & 0xff)) {
num_pages = pic32mx_devs[i].pfm_size;
break;
PIC32MX_MANUF_ID);
return ERROR_FLASH_OPERATION_FAILED;
}
PIC32MX_MANUF_ID);
return ERROR_FLASH_OPERATION_FAILED;
}
- for (i=0; pic32mx_devs[i].name != NULL; i++)
+ for (i = 0; pic32mx_devs[i].name != NULL; i++)
if (pic32mx_devs[i].devid == ((device_id >> 12) & 0xff)) {
printed = snprintf(buf, buf_size, "PIC32MX%s", pic32mx_devs[i].name);
break;
if (pic32mx_devs[i].devid == ((device_id >> 12) & 0xff)) {
printed = snprintf(buf, buf_size, "PIC32MX%s", pic32mx_devs[i].name);
break;
if (res == ERROR_OK)
command_print(cmd_ctx, "pic32mx pgm word complete");
else
if (res == ERROR_OK)
command_print(cmd_ctx, "pic32mx pgm word complete");
else
- command_print(cmd_ctx, "pic32mx pgm word failed (status=0x%x)", status);
+ command_print(cmd_ctx, "pic32mx pgm word failed (status = 0x%x)", status);
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
};
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
};
- if ((retval=target_write_buffer(target, stm32x_info->write_algorithm->address, sizeof(stm32x_flash_write_code), stm32x_flash_write_code)) != ERROR_OK)
+ if ((retval = target_write_buffer(target, stm32x_info->write_algorithm->address, sizeof(stm32x_flash_write_code), stm32x_flash_write_code)) != ERROR_OK)
return retval;
/* memory buffer */
return retval;
/* memory buffer */
if (str9x_info->bank1)
{
adr = bank1start + 0x18;
if (str9x_info->bank1)
{
adr = bank1start + 0x18;
- if ((retval=target_write_u16(target, adr, 0x90)) != ERROR_OK)
+ if ((retval = target_write_u16(target, adr, 0x90)) != ERROR_OK)
- if ((retval=target_read_u16(target, adr, &hstatus)) != ERROR_OK)
+ if ((retval = target_read_u16(target, adr, &hstatus)) != ERROR_OK)
else
{
adr = bank1start + 0x14;
else
{
adr = bank1start + 0x14;
- if ((retval=target_write_u16(target, adr, 0x90)) != ERROR_OK)
+ if ((retval = target_write_u16(target, adr, 0x90)) != ERROR_OK)
- if ((retval=target_read_u32(target, adr, &status)) != ERROR_OK)
+ if ((retval = target_read_u32(target, adr, &status)) != ERROR_OK)
else
{
adr = bank1start + 0x10;
else
{
adr = bank1start + 0x10;
- if ((retval=target_write_u16(target, adr, 0x90)) != ERROR_OK)
+ if ((retval = target_write_u16(target, adr, 0x90)) != ERROR_OK)
- if ((retval=target_read_u16(target, adr, &hstatus)) != ERROR_OK)
+ if ((retval = target_read_u16(target, adr, &hstatus)) != ERROR_OK)
}
/* read array command */
}
/* read array command */
- if ((retval=target_write_u16(target, adr, 0xFF)) != ERROR_OK)
+ if ((retval = target_write_u16(target, adr, 0xFF)) != ERROR_OK)
adr = bank->base + bank->sectors[i].offset;
/* erase sectors */
adr = bank->base + bank->sectors[i].offset;
/* erase sectors */
- if ((retval=target_write_u16(target, adr, erase_cmd)) != ERROR_OK)
+ if ((retval = target_write_u16(target, adr, erase_cmd)) != ERROR_OK)
- if ((retval=target_write_u16(target, adr, 0xD0)) != ERROR_OK)
+ if ((retval = target_write_u16(target, adr, 0xD0)) != ERROR_OK)
{
return retval;
}
/* get status */
{
return retval;
}
/* get status */
- if ((retval=target_write_u16(target, adr, 0x70)) != ERROR_OK)
+ if ((retval = target_write_u16(target, adr, 0x70)) != ERROR_OK)
{
return retval;
}
int timeout;
{
return retval;
}
int timeout;
- for (timeout=0; timeout<1000; timeout++) {
- if ((retval=target_read_u8(target, adr, &status)) != ERROR_OK)
+ for (timeout = 0; timeout<1000; timeout++) {
+ if ((retval = target_read_u8(target, adr, &status)) != ERROR_OK)
}
/* clear status, also clear read array */
}
/* clear status, also clear read array */
- if ((retval=target_write_u16(target, adr, 0x50)) != ERROR_OK)
+ if ((retval = target_write_u16(target, adr, 0x50)) != ERROR_OK)
{
return retval;
}
/* read array command */
{
return retval;
}
/* read array command */
- if ((retval=target_write_u16(target, adr, 0xFF)) != ERROR_OK)
+ if ((retval = target_write_u16(target, adr, 0xFF)) != ERROR_OK)
target_write_u16(target, bank_adr, 0x70);
int timeout;
target_write_u16(target, bank_adr, 0x70);
int timeout;
- for (timeout=0; timeout<1000; timeout++)
+ for (timeout = 0; timeout<1000; timeout++)
{
target_read_u8(target, bank_adr, &status);
if ( status & 0x80 )
{
target_read_u8(target, bank_adr, &status);
if ( status & 0x80 )
target_write_u16(target, bank_adr, 0x70);
int timeout;
target_write_u16(target, bank_adr, 0x70);
int timeout;
- for (timeout=0; timeout<1000; timeout++)
+ for (timeout = 0; timeout<1000; timeout++)
{
target_read_u8(target, bank_adr, &status);
if ( status & 0x80 )
{
target_read_u8(target, bank_adr, &status);
if ( status & 0x80 )
/* read and parse the device identification register */
target_read_u32(target, 0xFFFFFFF0, &device_ident_reg);
/* read and parse the device identification register */
target_read_u32(target, 0xFFFFFFF0, &device_ident_reg);
- LOG_INFO("device_ident_reg=0x%08" PRIx32 "", device_ident_reg);
+ LOG_INFO("device_ident_reg = 0x%08" PRIx32 "", device_ident_reg);
if ((device_ident_reg & 7) == 0)
{
if ((device_ident_reg & 7) == 0)
{
uint32_t fmbbusy;
target_read_u32(target, 0xFFE89C08, &fmbbusy);
uint32_t fmbbusy;
target_read_u32(target, 0xFFE89C08, &fmbbusy);
- LOG_INFO("tms470 fmbbusy=0x%08" PRIx32 " -> %s", fmbbusy, fmbbusy & 0x8000 ? "unlocked" : "LOCKED");
+ LOG_INFO("tms470 fmbbusy = 0x%08" PRIx32 " -> %s", fmbbusy, fmbbusy & 0x8000 ? "unlocked" : "LOCKED");
return fmbbusy & 0x8000 ? ERROR_OK : ERROR_FLASH_OPERATION_FAILED;
}
return fmbbusy & 0x8000 ? ERROR_OK : ERROR_FLASH_OPERATION_FAILED;
}
*/
target_read_u32(target, 0x00001FF0 + 4 * i, &tmp);
*/
target_read_u32(target, 0x00001FF0 + 4 * i, &tmp);
- LOG_INFO("tms470 writing fmpkey=0x%08" PRIx32 "", key_set[i]);
+ LOG_INFO("tms470 writing fmpkey = 0x%08" PRIx32 "", key_set[i]);
target_write_u32(target, 0xFFE89C0C, key_set[i]);
}
target_write_u32(target, 0xFFE89C0C, key_set[i]);
}
fmmac2 &= ~0x0007;
fmmac2 |= (tms470_info->ordinal & 7);
target_write_u32(target, 0xFFE8BC04, fmmac2);
fmmac2 &= ~0x0007;
fmmac2 |= (tms470_info->ordinal & 7);
target_write_u32(target, 0xFFE8BC04, fmmac2);
- LOG_DEBUG("set fmmac2=0x%04" PRIx32 "", fmmac2);
+ LOG_DEBUG("set fmmac2 = 0x%04" PRIx32 "", fmmac2);
/*
* Disable level 1 sector protection by setting bit 15 of FMMAC1.
/*
* Disable level 1 sector protection by setting bit 15 of FMMAC1.
target_read_u32(target, 0xFFE8BC00, &fmmac1);
fmmac1 |= 0x8000;
target_write_u32(target, 0xFFE8BC00, fmmac1);
target_read_u32(target, 0xFFE8BC00, &fmmac1);
fmmac1 |= 0x8000;
target_write_u32(target, 0xFFE8BC00, fmmac1);
- LOG_DEBUG("set fmmac1=0x%04" PRIx32 "", fmmac1);
+ LOG_DEBUG("set fmmac1 = 0x%04" PRIx32 "", fmmac1);
*/
target_write_u32(target, 0xFFE8BC10, 0x2fc0);
*/
target_write_u32(target, 0xFFE8BC10, 0x2fc0);
- LOG_DEBUG("set fmtcreg=0x2fc0");
+ LOG_DEBUG("set fmtcreg = 0x2fc0");
*/
target_write_u32(target, 0xFFE8A07C, 50);
*/
target_write_u32(target, 0xFFE8A07C, 50);
- LOG_DEBUG("set fmmaxpp=50");
+ LOG_DEBUG("set fmmaxpp = 50");
*/
target_write_u32(target, 0xFFE8A084, 0xf000 + 2000);
*/
target_write_u32(target, 0xFFE8A084, 0xf000 + 2000);
- LOG_DEBUG("set fmmaxcp=0x%04x", 0xf000 + 2000);
+ LOG_DEBUG("set fmmaxcp = 0x%04x", 0xf000 + 2000);
{
fmmaxep = 0xf000 + 4095;
target_write_u32(target, 0xFFE8A80C, 0x9964);
{
fmmaxep = 0xf000 + 4095;
target_write_u32(target, 0xFFE8A80C, 0x9964);
- LOG_DEBUG("set fmptr3=0x9964");
+ LOG_DEBUG("set fmptr3 = 0x9964");
}
else
{
fmmaxep = 0xa000 + 4095;
target_write_u32(target, 0xFFE8A80C, 0x9b64);
}
else
{
fmmaxep = 0xa000 + 4095;
target_write_u32(target, 0xFFE8A80C, 0x9b64);
- LOG_DEBUG("set fmptr3=0x9b64");
+ LOG_DEBUG("set fmptr3 = 0x9b64");
}
target_write_u32(target, 0xFFE8A080, fmmaxep);
}
target_write_u32(target, 0xFFE8A080, fmmaxep);
- LOG_DEBUG("set fmmaxep=0x%04" PRIx32 "", fmmaxep);
+ LOG_DEBUG("set fmmaxep = 0x%04" PRIx32 "", fmmaxep);
*/
target_write_u32(target, 0xFFE8A810, 0xa000);
*/
target_write_u32(target, 0xFFE8A810, 0xa000);
- LOG_DEBUG("set fmptr4=0xa000");
+ LOG_DEBUG("set fmptr4 = 0xa000");
/*
* FMPESETUP, delay parameter selected based on clock frequency.
/*
* FMPESETUP, delay parameter selected based on clock frequency.
sysclk = (plldis ? 1 : (glbctrl & 0x08) ? 4 : 8) * oscMHz / (1 + (glbctrl & 7));
delay = (sysclk > 10) ? (sysclk + 1) / 2 : 5;
target_write_u32(target, 0xFFE8A018, (delay << 4) | (delay << 8));
sysclk = (plldis ? 1 : (glbctrl & 0x08) ? 4 : 8) * oscMHz / (1 + (glbctrl & 7));
delay = (sysclk > 10) ? (sysclk + 1) / 2 : 5;
target_write_u32(target, 0xFFE8A018, (delay << 4) | (delay << 8));
- LOG_DEBUG("set fmpsetup=0x%04" PRIx32 "", (delay << 4) | (delay << 8));
+ LOG_DEBUG("set fmpsetup = 0x%04" PRIx32 "", (delay << 4) | (delay << 8));
/*
* FMPVEVACCESS, based on delay.
*/
k = delay | (delay << 8);
target_write_u32(target, 0xFFE8A05C, k);
/*
* FMPVEVACCESS, based on delay.
*/
k = delay | (delay << 8);
target_write_u32(target, 0xFFE8A05C, k);
- LOG_DEBUG("set fmpvevaccess=0x%04" PRIx32 "", k);
+ LOG_DEBUG("set fmpvevaccess = 0x%04" PRIx32 "", k);
/*
* FMPCHOLD, FMPVEVHOLD, FMPVEVSETUP, based on delay.
*/
k <<= 1;
target_write_u32(target, 0xFFE8A034, k);
/*
* FMPCHOLD, FMPVEVHOLD, FMPVEVSETUP, based on delay.
*/
k <<= 1;
target_write_u32(target, 0xFFE8A034, k);
- LOG_DEBUG("set fmpchold=0x%04" PRIx32 "", k);
+ LOG_DEBUG("set fmpchold = 0x%04" PRIx32 "", k);
target_write_u32(target, 0xFFE8A040, k);
target_write_u32(target, 0xFFE8A040, k);
- LOG_DEBUG("set fmpvevhold=0x%04" PRIx32 "", k);
+ LOG_DEBUG("set fmpvevhold = 0x%04" PRIx32 "", k);
target_write_u32(target, 0xFFE8A024, k);
target_write_u32(target, 0xFFE8A024, k);
- LOG_DEBUG("set fmpvevsetup=0x%04" PRIx32 "", k);
+ LOG_DEBUG("set fmpvevsetup = 0x%04" PRIx32 "", k);
/*
* FMCVACCESS, based on delay.
*/
k = delay * 16;
target_write_u32(target, 0xFFE8A060, k);
/*
* FMCVACCESS, based on delay.
*/
k = delay * 16;
target_write_u32(target, 0xFFE8A060, k);
- LOG_DEBUG("set fmcvaccess=0x%04" PRIx32 "", k);
+ LOG_DEBUG("set fmcvaccess = 0x%04" PRIx32 "", k);
/*
* FMCSETUP, based on delay.
*/
k = 0x3000 | delay * 20;
target_write_u32(target, 0xFFE8A020, k);
/*
* FMCSETUP, based on delay.
*/
k = 0x3000 | delay * 20;
target_write_u32(target, 0xFFE8A020, k);
- LOG_DEBUG("set fmcsetup=0x%04" PRIx32 "", k);
+ LOG_DEBUG("set fmcsetup = 0x%04" PRIx32 "", k);
/*
* FMEHOLD, based on delay.
*/
k = (delay * 20) << 2;
target_write_u32(target, 0xFFE8A038, k);
/*
* FMEHOLD, based on delay.
*/
k = (delay * 20) << 2;
target_write_u32(target, 0xFFE8A038, k);
- LOG_DEBUG("set fmehold=0x%04" PRIx32 "", k);
+ LOG_DEBUG("set fmehold = 0x%04" PRIx32 "", k);
/*
* PWIDTH, CWIDTH, EWIDTH, based on delay.
*/
target_write_u32(target, 0xFFE8A050, delay * 8);
/*
* PWIDTH, CWIDTH, EWIDTH, based on delay.
*/
target_write_u32(target, 0xFFE8A050, delay * 8);
- LOG_DEBUG("set fmpwidth=0x%04" PRIx32 "", delay * 8);
+ LOG_DEBUG("set fmpwidth = 0x%04" PRIx32 "", delay * 8);
target_write_u32(target, 0xFFE8A058, delay * 1000);
target_write_u32(target, 0xFFE8A058, delay * 1000);
- LOG_DEBUG("set fmcwidth=0x%04" PRIx32 "", delay * 1000);
+ LOG_DEBUG("set fmcwidth = 0x%04" PRIx32 "", delay * 1000);
target_write_u32(target, 0xFFE8A054, delay * 5400);
target_write_u32(target, 0xFFE8A054, delay * 5400);
- LOG_DEBUG("set fmewidth=0x%04" PRIx32 "", delay * 5400);
+ LOG_DEBUG("set fmewidth = 0x%04" PRIx32 "", delay * 5400);
uint32_t fmmstat;
target_read_u32(target, 0xFFE8BC0C, &fmmstat);
uint32_t fmmstat;
target_read_u32(target, 0xFFE8BC0C, &fmmstat);
- LOG_DEBUG("set fmmstat=0x%04" PRIx32 "", fmmstat);
+ LOG_DEBUG("set fmmstat = 0x%04" PRIx32 "", fmmstat);
*/
target_read_u32(target, 0xFFFFFFDC, &glbctrl);
target_write_u32(target, 0xFFFFFFDC, glbctrl | 0x10);
*/
target_read_u32(target, 0xFFFFFFDC, &glbctrl);
target_write_u32(target, 0xFFFFFFDC, glbctrl | 0x10);
- LOG_DEBUG("set glbctrl=0x%08" PRIx32 "", glbctrl | 0x10);
+ LOG_DEBUG("set glbctrl = 0x%08" PRIx32 "", glbctrl | 0x10);
/* Force normal read mode. */
target_read_u32(target, 0xFFE89C00, &orig_fmregopt);
target_write_u32(target, 0xFFE89C00, 0);
/* Force normal read mode. */
target_read_u32(target, 0xFFE89C00, &orig_fmregopt);
target_write_u32(target, 0xFFE89C00, 0);
- LOG_DEBUG("set fmregopt=0x%08x", 0);
+ LOG_DEBUG("set fmregopt = 0x%08x", 0);
(void)tms470_flash_initialize_internal_state_machine(bank);
(void)tms470_flash_initialize_internal_state_machine(bank);
{
target_read_u32(target, 0xFFE88008, &fmbsea);
target_write_u32(target, 0xFFE88008, fmbsea | (1 << sector));
{
target_read_u32(target, 0xFFE88008, &fmbsea);
target_write_u32(target, 0xFFE88008, fmbsea | (1 << sector));
- LOG_DEBUG("set fmbsea=0x%04" PRIx32 "", fmbsea | (1 << sector));
+ LOG_DEBUG("set fmbsea = 0x%04" PRIx32 "", fmbsea | (1 << sector));
}
else
{
target_read_u32(target, 0xFFE8800C, &fmbseb);
target_write_u32(target, 0xFFE8800C, fmbseb | (1 << (sector - 16)));
}
else
{
target_read_u32(target, 0xFFE8800C, &fmbseb);
target_write_u32(target, 0xFFE8800C, fmbseb | (1 << (sector - 16)));
- LOG_DEBUG("set fmbseb=0x%04" PRIx32 "", fmbseb | (1 << (sector - 16)));
+ LOG_DEBUG("set fmbseb = 0x%04" PRIx32 "", fmbseb | (1 << (sector - 16)));
}
bank->sectors[sector].is_protected = 0;
}
bank->sectors[sector].is_protected = 0;
if (sector < 16)
{
target_write_u32(target, 0xFFE88008, fmbsea);
if (sector < 16)
{
target_write_u32(target, 0xFFE88008, fmbsea);
- LOG_DEBUG("set fmbsea=0x%04" PRIx32 "", fmbsea);
+ LOG_DEBUG("set fmbsea = 0x%04" PRIx32 "", fmbsea);
bank->sectors[sector].is_protected = fmbsea & (1 << sector) ? 0 : 1;
}
else
{
target_write_u32(target, 0xFFE8800C, fmbseb);
bank->sectors[sector].is_protected = fmbsea & (1 << sector) ? 0 : 1;
}
else
{
target_write_u32(target, 0xFFE8800C, fmbseb);
- LOG_DEBUG("set fmbseb=0x%04" PRIx32 "", fmbseb);
+ LOG_DEBUG("set fmbseb = 0x%04" PRIx32 "", fmbseb);
bank->sectors[sector].is_protected = fmbseb & (1 << (sector - 16)) ? 0 : 1;
}
target_write_u32(target, 0xFFE89C00, orig_fmregopt);
bank->sectors[sector].is_protected = fmbseb & (1 << (sector - 16)) ? 0 : 1;
}
target_write_u32(target, 0xFFE89C00, orig_fmregopt);
- LOG_DEBUG("set fmregopt=0x%08" PRIx32 "", orig_fmregopt);
+ LOG_DEBUG("set fmregopt = 0x%08" PRIx32 "", orig_fmregopt);
target_write_u32(target, 0xFFFFFFDC, glbctrl);
target_write_u32(target, 0xFFFFFFDC, glbctrl);
- LOG_DEBUG("set glbctrl=0x%08" PRIx32 "", glbctrl);
+ LOG_DEBUG("set glbctrl = 0x%08" PRIx32 "", glbctrl);
if (result == ERROR_OK)
{
if (result == ERROR_OK)
{
- LOG_ERROR("fmstat=0x%04" PRIx32 "", fmmstat);
+ LOG_ERROR("fmstat = 0x%04" PRIx32 "", fmmstat);
LOG_ERROR("Could not program word 0x%04x at address 0x%08" PRIx32 ".", word, addr);
result = ERROR_FLASH_OPERATION_FAILED;
break;
LOG_ERROR("Could not program word 0x%04x at address 0x%08" PRIx32 ".", word, addr);
result = ERROR_FLASH_OPERATION_FAILED;
break;
target_read_u32(target, 0xFFE8BC04, &fmmac2);
target_write_u32(target, 0xFFE8BC04, (fmmac2 & ~7) | tms470_info->ordinal);
target_read_u32(target, 0xFFE8BC04, &fmmac2);
target_write_u32(target, 0xFFE8BC04, (fmmac2 & ~7) | tms470_info->ordinal);
target_write_u32(target, 0xFFE8BC10, 0x2fc0);
/* clear TEZ in fmbrdy */
target_write_u32(target, 0xFFE8BC10, 0x2fc0);
/* clear TEZ in fmbrdy */
- for (i=first; i<first+num; i++)
+ for (i = first; i<first+num; i++)
{
if (((value >> (i-first))&1) == 1)
buffer[i/8] |= 1 << (i%8);
{
if (((value >> (i-first))&1) == 1)
buffer[i/8] |= 1 << (i%8);
uint32_t result = 0;
unsigned int i;
uint32_t result = 0;
unsigned int i;
- for (i=first; i<first+num; i++)
+ for (i = first; i<first+num; i++)
{
if (((buffer[i/8]>>(i%8))&1) == 1)
result |= 1 << (i-first);
{
if (((buffer[i/8]>>(i%8))&1) == 1)
result |= 1 << (i-first);
static void tcl_output(void *privData, const char *file, int line, const char *function, const char *string)
{
static void tcl_output(void *privData, const char *file, int line, const char *function, const char *string)
{
- Jim_Obj *tclOutput=(Jim_Obj *)privData;
+ Jim_Obj *tclOutput = (Jim_Obj *)privData;
Jim_AppendString(interp, tclOutput, string, strlen(string));
}
Jim_AppendString(interp, tclOutput, string, strlen(string));
}
for (i = 0; i < argc; i++)
{
int len;
for (i = 0; i < argc; i++)
{
int len;
- const char *w=Jim_GetString(argv[i], &len);
+ const char *w = Jim_GetString(argv[i], &len);
if (*w=='#')
{
/* hit an end of line comment */
if (*w=='#')
{
/* hit an end of line comment */
/* maximum of two levels :-) */
if (c->parent != NULL)
{
/* maximum of two levels :-) */
if (c->parent != NULL)
{
- t3=c->name;
- const char *full_name=alloc_printf("ocd_%s%s%s", t1, t2, t3);
+ t3 = c->name;
+ const char *full_name = alloc_printf("ocd_%s%s%s", t1, t2, t3);
Jim_CreateCommand(interp, full_name, script_command, c, NULL);
free((void *)full_name);
/* we now need to add an overrideable proc */
Jim_CreateCommand(interp, full_name, script_command, c, NULL);
free((void *)full_name);
/* we now need to add an overrideable proc */
- const char *override_name=alloc_printf("proc %s%s%s {args} {if {[catch {eval ocd_%s%s%s $args}]==0} {return \"\"} else { return -code error }", t1, t2, t3, t1, t2, t3);
+ const char *override_name = alloc_printf("proc %s%s%s {args} {if {[catch {eval ocd_%s%s%s $args}]==0} {return \"\"} else { return -code error }", t1, t2, t3, t1, t2, t3);
Jim_Eval_Named(interp, override_name, __THIS__FILE__, __LINE__ );
free((void *)override_name);
/* accumulate help text in Tcl helptext list. */
Jim_Eval_Named(interp, override_name, __THIS__FILE__, __LINE__ );
free((void *)override_name);
/* accumulate help text in Tcl helptext list. */
- Jim_Obj *helptext=Jim_GetGlobalVariableStr(interp, "ocd_helptext", JIM_ERRMSG);
+ Jim_Obj *helptext = Jim_GetGlobalVariableStr(interp, "ocd_helptext", JIM_ERRMSG);
if (Jim_IsShared(helptext))
helptext = Jim_DuplicateObj(interp, helptext);
if (Jim_IsShared(helptext))
helptext = Jim_DuplicateObj(interp, helptext);
- Jim_Obj *cmd_entry=Jim_NewListObj(interp, NULL, 0);
+ Jim_Obj *cmd_entry = Jim_NewListObj(interp, NULL, 0);
- Jim_Obj *cmd_list=Jim_NewListObj(interp, NULL, 0);
+ Jim_Obj *cmd_list = Jim_NewListObj(interp, NULL, 0);
/* maximum of two levels :-) */
if (c->parent != NULL)
/* maximum of two levels :-) */
if (c->parent != NULL)
int run_command(command_context_t *context, command_t *c, char *words[], int num_words)
{
int run_command(command_context_t *context, command_t *c, char *words[], int num_words)
{
if (!((context->mode == COMMAND_CONFIG) || (c->mode == COMMAND_ANY) || (c->mode == context->mode) ))
{
/* Config commands can not run after the config stage */
if (!((context->mode == COMMAND_CONFIG) || (c->mode == COMMAND_ANY) || (c->mode == context->mode) ))
{
/* Config commands can not run after the config stage */
/* maximum of two levels :-) */
if (c->parent != NULL)
{
/* maximum of two levels :-) */
if (c->parent != NULL)
{
command_run_linef(context, "help {%s%s%s}", t1, t2, t3);
}
else if (retval == ERROR_COMMAND_CLOSE_CONNECTION)
command_run_linef(context, "help {%s%s%s}", t1, t2, t3);
}
else if (retval == ERROR_COMMAND_CLOSE_CONNECTION)
* results
*/
/* run the line thru a script engine */
* results
*/
/* run the line thru a script engine */
+ int retval = ERROR_FAIL;
int retcode;
/* Beware! This code needs to be reentrant. It is also possible
* for OpenOCD commands to be invoked directly from Tcl. This would
int retcode;
/* Beware! This code needs to be reentrant. It is also possible
* for OpenOCD commands to be invoked directly from Tcl. This would
}
LOG_USER_N("%s", "\n");
}
}
LOG_USER_N("%s", "\n");
}
}
return retval;
}
int command_run_linef(command_context_t *context, const char *format, ...)
{
}
return retval;
}
int command_run_linef(command_context_t *context, const char *format, ...)
{
+ int retval = ERROR_FAIL;
char *string;
va_list ap;
va_start(ap, format);
string = alloc_vprintf(format, ap);
if (string != NULL)
{
char *string;
va_list ap;
va_start(ap, format);
string = alloc_vprintf(format, ap);
if (string != NULL)
{
- retval=command_run_line(context, string);
+ retval = command_run_line(context, string);
}
va_end(ap);
return retval;
}
va_end(ap);
return retval;
/* FIX!!! it would be prettier to invoke add_help_text...
* accumulate help text in Tcl helptext list. */
/* FIX!!! it would be prettier to invoke add_help_text...
* accumulate help text in Tcl helptext list. */
- Jim_Obj *helptext=Jim_GetGlobalVariableStr(interp, "ocd_helptext", JIM_ERRMSG);
+ Jim_Obj *helptext = Jim_GetGlobalVariableStr(interp, "ocd_helptext", JIM_ERRMSG);
if (Jim_IsShared(helptext))
helptext = Jim_DuplicateObj(interp, helptext);
if (Jim_IsShared(helptext))
helptext = Jim_DuplicateObj(interp, helptext);
- Jim_Obj *cmd_entry=Jim_NewListObj(interp, NULL, 0);
+ Jim_Obj *cmd_entry = Jim_NewListObj(interp, NULL, 0);
- Jim_Obj *cmd_list=Jim_NewListObj(interp, NULL, 0);
+ Jim_Obj *cmd_list = Jim_NewListObj(interp, NULL, 0);
Jim_ListAppendElement(interp, cmd_list, Jim_NewStringObj(interp, name, -1));
Jim_ListAppendElement(interp, cmd_entry, cmd_list);
Jim_ListAppendElement(interp, cmd_list, Jim_NewStringObj(interp, name, -1));
Jim_ListAppendElement(interp, cmd_entry, cmd_list);
/* return global variable long value or 0 upon failure */
long jim_global_long(const char *variable)
{
/* return global variable long value or 0 upon failure */
long jim_global_long(const char *variable)
{
- Jim_Obj *objPtr=Jim_GetGlobalVariableStr(interp, variable, JIM_ERRMSG);
+ Jim_Obj *objPtr = Jim_GetGlobalVariableStr(interp, variable, JIM_ERRMSG);
long t;
if (Jim_GetLong(interp, objPtr, &t) == JIM_OK)
{
long t;
if (Jim_GetLong(interp, objPtr, &t) == JIM_OK)
{
return fopen(file, mode);
} else
{
return fopen(file, mode);
} else
{
- char *full_path=find_file(file);
+ char *full_path = find_file(file);
if (full_path == NULL)
return NULL;
FILE *fp = NULL;
if (full_path == NULL)
return NULL;
FILE *fp = NULL;
- retval=command_run_line(cmd_ctx, *cfg);
+ retval = command_run_line(cmd_ctx, *cfg);
if (retval != ERROR_OK)
return retval;
cfg++;
if (retval != ERROR_OK)
return retval;
cfg++;
return ERROR_INVALID_ARGUMENTS;
}
return ERROR_INVALID_ARGUMENTS;
}
+ int retval = ERROR_FAIL;
FILE *config_file = NULL;
config_file = fopen(args[0], "a");
if (config_file != NULL)
FILE *config_file = NULL;
config_file = fopen(args[0], "a");
if (config_file != NULL)
}
if ((i == argc) && (fwrite("\n", 1, 1, config_file) == 1))
{
}
if ((i == argc) && (fwrite("\n", 1, 1, config_file) == 1))
{
{
jim_wide i, res = 1;
if ((b == 0 && e != 0) || (e<0)) return 0;
{
jim_wide i, res = 1;
if ((b == 0 && e != 0) || (e<0)) return 0;
- for (i=0; i<e; i++) {res *= b;}
+ for (i = 0; i<e; i++) {res *= b;}
{
/* We allocate zero length arrayes, etc. to use a single orthogonal codepath */
if (size == 0)
{
/* We allocate zero length arrayes, etc. to use a single orthogonal codepath */
if (size == 0)
void *p = malloc(size);
if (p == NULL)
Jim_Panic(NULL,"malloc: Out of memory");
void *p = malloc(size);
if (p == NULL)
Jim_Panic(NULL,"malloc: Out of memory");
{
/* We allocate zero length arrayes, etc. to use a single orthogonal codepath */
if (size == 0)
{
/* We allocate zero length arrayes, etc. to use a single orthogonal codepath */
if (size == 0)
void *p = realloc(ptr, size);
if (p == NULL)
Jim_Panic(NULL,"realloc: Out of memory");
void *p = realloc(ptr, size);
if (p == NULL)
Jim_Panic(NULL,"realloc: Out of memory");
Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr,
int objc, Jim_Obj *const *objv)
{
Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr,
int objc, Jim_Obj *const *objv)
{
- char *sprintf_buf=malloc(JIM_MAX_FMT);
- Jim_Obj *t=Jim_FormatString_Inner(interp, fmtObjPtr, objc, objv, sprintf_buf);
+ char *sprintf_buf = malloc(JIM_MAX_FMT);
+ Jim_Obj *t = Jim_FormatString_Inner(interp, fmtObjPtr, objc, objv, sprintf_buf);
free(sprintf_buf);
return t;
}
free(sprintf_buf);
return t;
}
}
point = listPtr->internalRep.listValue.ele + index;
memmove(point+elemc, point, (currentLen-index) * sizeof(Jim_Obj*));
}
point = listPtr->internalRep.listValue.ele + index;
memmove(point+elemc, point, (currentLen-index) * sizeof(Jim_Obj*));
- for (i=0; i < elemc; ++i) {
+ for (i = 0; i < elemc; ++i) {
point[i] = elemVec[i];
Jim_IncrRefCount(point[i]);
}
point[i] = elemVec[i];
Jim_IncrRefCount(point[i]);
}
Jim_FreeIntRep(interp, objPtr);
/* Count how many conversions could take place maximally */
Jim_FreeIntRep(interp, objPtr);
/* Count how many conversions could take place maximally */
- for (i=0, maxCount=0; i < maxFmtLen; ++i)
+ for (i = 0, maxCount = 0; i < maxFmtLen; ++i)
if (fmt[i] == '%')
++maxCount;
/* Calculate an approximation of the memory necessary */
if (fmt[i] == '%')
++maxCount;
/* Calculate an approximation of the memory necessary */
buffer = fmtObj->stringRep + maxFmtLen + 1;
objPtr->internalRep.ptr = fmtObj;
objPtr->typePtr = &scanFmtStringObjType;
buffer = fmtObj->stringRep + maxFmtLen + 1;
objPtr->internalRep.ptr = fmtObj;
objPtr->typePtr = &scanFmtStringObjType;
- for (i=0, curr=0; fmt < fmtEnd; ++fmt) {
- int width=0, skip;
+ for (i = 0, curr = 0; fmt < fmtEnd; ++fmt) {
+ int width = 0, skip;
ScanFmtPartDescr *descr = &fmtObj->descr[curr];
fmtObj->count++;
descr->width = 0; /* Assume width unspecified */
ScanFmtPartDescr *descr = &fmtObj->descr[curr];
fmtObj->count++;
descr->width = 0; /* Assume width unspecified */
return JIM_ERR;
}
/* Look if this position was already used */
return JIM_ERR;
}
/* Look if this position was already used */
- for (prev=0; prev < curr; ++prev) {
+ for (prev = 0; prev < curr; ++prev) {
if (fmtObj->descr[prev].pos == -1) continue;
if (fmtObj->descr[prev].pos == descr->pos) {
fmtObj->error = "same \"%n$\" conversion specifier "
if (fmtObj->descr[prev].pos == -1) continue;
if (fmtObj->descr[prev].pos == descr->pos) {
fmtObj->error = "same \"%n$\" conversion specifier "
/* In case a range fence was given "backwards", swap it */
while (swapped) {
swapped = 0;
/* In case a range fence was given "backwards", swap it */
while (swapped) {
swapped = 0;
- for (j=beg+1; j < end-1; ++j) {
+ for (j = beg+1; j < end-1; ++j) {
if (buffer[j] == '-' && buffer[j-1] > buffer[j+1]) {
char tmp = buffer[j-1];
buffer[j-1] = buffer[j+1];
if (buffer[j] == '-' && buffer[j-1] > buffer[j+1]) {
char tmp = buffer[j-1];
buffer[j-1] = buffer[j+1];
if (sdescr[1] == '-' && sdescr[2] != 0) {
/* Handle range definitions */
int i;
if (sdescr[1] == '-' && sdescr[2] != 0) {
/* Handle range definitions */
int i;
- for (i=sdescr[0]; i <= sdescr[2]; ++i)
+ for (i = sdescr[0]; i <= sdescr[2]; ++i)
JimSetBit(charset, (char)i);
sdescr += 3;
} else {
JimSetBit(charset, (char)i);
sdescr += 3;
} else {
}
}
/* Negate the charset if there was a NOT given */
}
}
/* Negate the charset if there was a NOT given */
- for (i=0; notFlag && i < sizeof(charset); ++i)
+ for (i = 0; notFlag && i < sizeof(charset); ++i)
charset[i] = ~charset[i];
}
/* And after all the mess above, the real work begin ... */
charset[i] = ~charset[i];
}
/* And after all the mess above, the real work begin ... */
if (descr->prefix) {
/* There was a prefix given before the conversion, skip it and adjust
* the string-to-be-parsed accordingly */
if (descr->prefix) {
/* There was a prefix given before the conversion, skip it and adjust
* the string-to-be-parsed accordingly */
- for (i=0; str[pos] && descr->prefix[i]; ++i) {
+ for (i = 0; str[pos] && descr->prefix[i]; ++i) {
/* If prefix require, skip WS */
if (isspace((int)descr->prefix[i]))
while (str[pos] && isspace((int)str[pos])) ++pos;
/* If prefix require, skip WS */
if (isspace((int)descr->prefix[i]))
while (str[pos] && isspace((int)str[pos])) ++pos;
/* Create a list and fill it with empty strings up to max specified XPG3 */
resultList = Jim_NewListObj(interp, 0, 0);
if (fmtObj->maxPos > 0) {
/* Create a list and fill it with empty strings up to max specified XPG3 */
resultList = Jim_NewListObj(interp, 0, 0);
if (fmtObj->maxPos > 0) {
- for (i=0; i < fmtObj->maxPos; ++i)
+ for (i = 0; i < fmtObj->maxPos; ++i)
Jim_ListAppendElement(interp, resultList, emptyStr);
JimListGetElements(interp, resultList, &resultc, &resultVec);
}
/* Now handle every partial format description */
Jim_ListAppendElement(interp, resultList, emptyStr);
JimListGetElements(interp, resultList, &resultc, &resultVec);
}
/* Now handle every partial format description */
- for (i=0, pos=0; i < fmtObj->count; ++i) {
+ for (i = 0, pos = 0; i < fmtObj->count; ++i) {
ScanFmtPartDescr *descr = &(fmtObj->descr[i]);
Jim_Obj *value = 0;
/* Only last type may be "literal" w/o conversion - skip it! */
ScanFmtPartDescr *descr = &(fmtObj->descr[i]);
Jim_Obj *value = 0;
/* Only last type may be "literal" w/o conversion - skip it! */
Jim_Obj *scriptObjPtr;
if ((fp = fopen(filename, "r")) == NULL) {
Jim_Obj *scriptObjPtr;
if ((fp = fopen(filename, "r")) == NULL) {
- const int cwd_len=2048;
- char *cwd=malloc(cwd_len);
+ const int cwd_len = 2048;
+ char *cwd = malloc(cwd_len);
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
if (!getcwd( cwd, cwd_len )) strcpy(cwd, "unknown");
Jim_AppendStrings(interp, Jim_GetResult(interp),
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
if (!getcwd( cwd, cwd_len )) strcpy(cwd, "unknown");
Jim_AppendStrings(interp, Jim_GetResult(interp),
/* Initialize iterators and remember max nbr elements each list */
memset(listsIdx, 0, nbrOfLists * sizeof(int));
/* Remember lengths of all lists and calculate how much rounds to loop */
/* Initialize iterators and remember max nbr elements each list */
memset(listsIdx, 0, nbrOfLists * sizeof(int));
/* Remember lengths of all lists and calculate how much rounds to loop */
- for (i=0; i < nbrOfLists*2; i += 2) {
+ for (i = 0; i < nbrOfLists*2; i += 2) {
div_t cnt;
int count;
Jim_ListLength(interp, argv[i+1], &listsEnd[i]);
div_t cnt;
int count;
Jim_ListLength(interp, argv[i+1], &listsEnd[i]);
nbrOfLoops = count;
}
for (; nbrOfLoops-- > 0; ) {
nbrOfLoops = count;
}
for (; nbrOfLoops-- > 0; ) {
- for (i=0; i < nbrOfLists; ++i) {
+ for (i = 0; i < nbrOfLists; ++i) {
int varIdx = 0, var = i * 2;
while (varIdx < listsEnd[var]) {
Jim_Obj *varName, *ele;
int varIdx = 0, var = i * 2;
while (varIdx < listsEnd[var]) {
Jim_Obj *varName, *ele;
static int Jim_SwitchCoreCommand(Jim_Interp *interp, int argc,
Jim_Obj *const *argv)
{
static int Jim_SwitchCoreCommand(Jim_Interp *interp, int argc,
Jim_Obj *const *argv)
{
- int retcode = JIM_ERR, matchOpt = SWITCH_EXACT, opt=1, patCount, i;
+ int retcode = JIM_ERR, matchOpt = SWITCH_EXACT, opt = 1, patCount, i;
Jim_Obj *command = 0, *const *caseList = 0, *strObj;
Jim_Obj *script = 0;
if (argc < 3) goto wrongnumargs;
Jim_Obj *command = 0, *const *caseList = 0, *strObj;
Jim_Obj *script = 0;
if (argc < 3) goto wrongnumargs;
- for (opt=1; opt < argc; ++opt) {
+ for (opt = 1; opt < argc; ++opt) {
const char *option = Jim_GetString(argv[opt], 0);
if (*option != '-') break;
else if (strncmp(option, "--", 2) == 0) { ++opt; break; }
const char *option = Jim_GetString(argv[opt], 0);
if (*option != '-') break;
else if (strncmp(option, "--", 2) == 0) { ++opt; break; }
} else
caseList = &argv[opt];
if (patCount == 0 || patCount % 2 != 0) goto wrongnumargs;
} else
caseList = &argv[opt];
if (patCount == 0 || patCount % 2 != 0) goto wrongnumargs;
- for (i=0; script == 0 && i < patCount; i += 2) {
+ for (i = 0; script == 0 && i < patCount; i += 2) {
Jim_Obj *patObj = caseList[i];
if (!Jim_CompareStringImmediate(interp, patObj, "default")
|| i < (patCount-2)) {
Jim_Obj *patObj = caseList[i];
if (!Jim_CompareStringImmediate(interp, patObj, "default")
|| i < (patCount-2)) {
* known string, or there may be multiple strings (aliases) that mean then same
* thing.
*
* known string, or there may be multiple strings (aliases) that mean then same
* thing.
*
- * An NVP Table is terminated with ".name=NULL".
+ * An NVP Table is terminated with ".name = NULL".
*
* During the 'name2value' operation, if no matching string is found
* the pointer to the terminal element (with p->name == NULL) is returned.
*
* During the 'name2value' operation, if no matching string is found
* the pointer to the terminal element (with p->name == NULL) is returned.
* Usefull when dealing with command options.
* that may come in any order...
*
* Usefull when dealing with command options.
* that may come in any order...
*
- * Does not support "-foo=123" type options.
+ * Does not support "-foo = 123" type options.
* Only supports tcl type options, like "-foo 123"
*/
* Only supports tcl type options, like "-foo 123"
*/
*
* This function assumes the previous option argv[-1] is the unknown string.
*
*
* This function assumes the previous option argv[-1] is the unknown string.
*
- * If this option had some prefix, then pass "hadprefix=1" else pass "hadprefix=0"
+ * If this option had some prefix, then pass "hadprefix = 1" else pass "hadprefix = 0"
* e = Jim_GetOpt_Nvp( &goi, cmd_options, &n );
* if ( e != JIM_OK ){
* // option was not recognized
* e = Jim_GetOpt_Nvp( &goi, cmd_options, &n );
* if ( e != JIM_OK ){
* // option was not recognized
- * // pass 'hadprefix=0' because there is no prefix
+ * // pass 'hadprefix = 0' because there is no prefix
* Jim_GetOpt_NvpUnknown( &goi, cmd_options, 0 );
* return e;
* }
* Jim_GetOpt_NvpUnknown( &goi, cmd_options, 0 );
* return e;
* }
if (debug_level >= LOG_LVL_DEBUG)
{
/* print with count and time information */
if (debug_level >= LOG_LVL_DEBUG)
{
/* print with count and time information */
- int t=(int)(timeval_ms()-start);
+ int t = (int)(timeval_ms()-start);
#ifdef _DEBUG_FREE_SPACE_
struct mallinfo info;
info = mallinfo();
#ifdef _DEBUG_FREE_SPACE_
struct mallinfo info;
info = mallinfo();
/* DANGER!!!! the log callback can remove itself!!!! */
while (cb)
{
/* DANGER!!!! the log callback can remove itself!!!! */
while (cb)
{
cb->fn(cb->priv, file, line, function, string);
cb->fn(cb->priv, file, line, function, string);
- start=last_time=timeval_ms();
+ start = last_time = timeval_ms();
- current_time=timeval_ms();
+ current_time = timeval_ms();
if (current_time-last_time>1000)
{
extern int gdb_actual_connections;
if (current_time-last_time>1000)
{
extern int gdb_actual_connections;
* These functions should be invoked at a well defined spot in server.c
*/
* These functions should be invoked at a well defined spot in server.c
*/
- last_time=current_time;
+ last_time = current_time;
}
}
/* reset keep alive timer without sending message */
void kept_alive()
{
}
}
/* reset keep alive timer without sending message */
void kept_alive()
{
- current_time=timeval_ms();
- last_time=current_time;
+ current_time = timeval_ms();
+ last_time = current_time;
}
/* if we sleep for extended periods of time, we must invoke keep_alive() intermittantly */
void alive_sleep(int ms)
{
int i;
}
/* if we sleep for extended periods of time, we must invoke keep_alive() intermittantly */
void alive_sleep(int ms)
{
int i;
- int napTime=10;
- for (i=0; i<ms; i += napTime)
+ int napTime = 10;
+ for (i = 0; i<ms; i += napTime)
+ int sleep_a_bit = ms-i;
if (sleep_a_bit>napTime)
{
if (sleep_a_bit>napTime)
{
}
usleep(sleep_a_bit*1000);
keep_alive();
}
usleep(sleep_a_bit*1000);
keep_alive();
void busy_sleep(int ms)
{
long long then;
void busy_sleep(int ms)
{
long long then;
while ((timeval_ms()-then)<ms)
{
/* busy wait */
while ((timeval_ms()-then)<ms)
{
/* busy wait */
/* Either this code will *always* work or it will SEGFAULT giving
* excellent information on the culprit.
*/
/* Either this code will *always* work or it will SEGFAULT giving
* excellent information on the culprit.
*/
- *strrchr(strExePath, '\\')=0;
+ *strrchr(strExePath, '\\') = 0;
strcat(strExePath, "\\..");
add_script_search_dir(strExePath);
}
strcat(strExePath, "\\..");
add_script_search_dir(strExePath);
}
char strExePath [MAX_PATH];
char *p;
GetModuleFileName (NULL, strExePath, MAX_PATH);
char strExePath [MAX_PATH];
char *p;
GetModuleFileName (NULL, strExePath, MAX_PATH);
- *strrchr(strExePath, '\\')=0;
+ *strrchr(strExePath, '\\') = 0;
strcat(strExePath, "/../lib/"PACKAGE);
strcat(strExePath, "/../lib/"PACKAGE);
- for (p=strExePath; *p; p++) {
+ for (p = strExePath; *p; p++) {
if (*p == '\\')
*p = '/';
}
if (*p == '\\')
*p = '/';
}
- t=duration->duration.tv_sec;
+ t = duration->duration.tv_sec;
t += (float)duration->duration.tv_usec/1000000.0;
*text = malloc(100);
snprintf(*text, 100, "%fs", t);
t += (float)duration->duration.tv_usec/1000000.0;
*text = malloc(100);
snprintf(*text, 100, "%fs", t);
long long timeval_ms()
{
struct timeval now;
long long timeval_ms()
{
struct timeval now;
gettimeofday(&now, NULL);
t += now.tv_usec/1000;
gettimeofday(&now, NULL);
t += now.tv_usec/1000;
*
* If someone can submit a patch with an explanation it will be greatly
* appreciated, but as far as I can tell (ØH) DCLK is generated upon
*
* If someone can submit a patch with an explanation it will be greatly
* appreciated, but as far as I can tell (ØH) DCLK is generated upon
- * clk=0 in TAP_IDLE. Good luck deducing that from the ARM documentation!
+ * clk = 0 in TAP_IDLE. Good luck deducing that from the ARM documentation!
* The ARM documentation uses the term "DCLK is asserted while in the TAP_IDLE
* state". With hardware there is no such thing as *while* in a state. There
* are only edges. So clk => 0 is in fact a very subtle state transition that
* The ARM documentation uses the term "DCLK is asserted while in the TAP_IDLE
* state". With hardware there is no such thing as *while* in a state. There
* are only edges. So clk => 0 is in fact a very subtle state transition that
static void bitbang_state_move(int skip)
{
static void bitbang_state_move(int skip)
{
uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
for (bit_cnt = 0; bit_cnt < scan_size; bit_cnt++)
{
for (bit_cnt = 0; bit_cnt < scan_size; bit_cnt++)
{
- int val=0;
- int tms=(bit_cnt == scan_size-1) ? 1 : 0;
+ int val = 0;
+ int tms = (bit_cnt == scan_size-1) ? 1 : 0;
- int bytec=bit_cnt/8;
- int bcval=1 << (bit_cnt % 8);
+ int bytec = bit_cnt/8;
+ int bcval = 1 << (bit_cnt % 8);
/* if we're just reading the scan, but don't care about the output
* default to outputting 'low', this also makes valgrind traces more readable,
* as it removes the dependency on an uninitialised value
*/
/* if we're just reading the scan, but don't care about the output
* default to outputting 'low', this also makes valgrind traces more readable,
* as it removes the dependency on an uninitialised value
*/
if ((type != SCAN_IN) && (buffer[bytec] & bcval))
if ((type != SCAN_IN) && (buffer[bytec] & bcval))
bitbang_interface->write(0, tms, tdi);
if (type != SCAN_OUT)
bitbang_interface->write(0, tms, tdi);
if (type != SCAN_OUT)
- val=bitbang_interface->read();
+ val = bitbang_interface->read();
bitbang_interface->write(1, tms, tdi);
bitbang_interface->write(1, tms, tdi);
offset = (*p_page)->used;
(*p_page)->used += size;
offset = (*p_page)->used;
(*p_page)->used += size;
- t=(uint8_t *)((*p_page)->address);
+ t = (uint8_t *)((*p_page)->address);
typedef struct reset_command_s
{
typedef struct reset_command_s
{
- /// Set TRST output: 0=deassert, 1=assert, -1=no change
+ /// Set TRST output: 0 = deassert, 1 = assert, -1 = no change
- /// Set SRST output: 0=deassert, 1=assert, -1=no change
+ /// Set SRST output: 0 = deassert, 1 = assert, -1 = no change
int srst;
} reset_command_t;
int srst;
} reset_command_t;
/* if we are to run a verification of the ir scan, we need to get the input back.
* We may have to allocate space if the caller didn't ask for the input back.
*/
/* if we are to run a verification of the ir scan, we need to get the input back.
* We may have to allocate space if the caller didn't ask for the input back.
*/
- in_fields[j].check_value=in_fields[j].tap->expected;
- in_fields[j].check_mask=in_fields[j].tap->expected_mask;
+ in_fields[j].check_value = in_fields[j].tap->expected;
+ in_fields[j].check_mask = in_fields[j].tap->expected_mask;
}
jtag_add_scan_check(jtag_add_ir_scan_noverify, in_num_fields, in_fields, state);
} else
}
jtag_add_scan_check(jtag_add_ir_scan_noverify, in_num_fields, in_fields, state);
} else
jtag_execute_queue_noclear();
jtag_execute_queue_noclear();
- int retval=jtag_check_value_inner(field->in_value, value, mask, field->num_bits);
+ int retval = jtag_check_value_inner(field->in_value, value, mask, field->num_bits);
jtag_set_error(retval);
}
jtag_set_error(retval);
}
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
return retval;
/* examine chain first, as this could discover the real chain layout */
return retval;
/* examine chain first, as this could discover the real chain layout */
- if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
+ if ((retval = jtag_interface_init(cmd_ctx)) != ERROR_OK)
return retval;
LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
return retval;
LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
int jtag_init(struct command_context_s *cmd_ctx)
{
int retval;
int jtag_init(struct command_context_s *cmd_ctx)
{
int retval;
- if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
+ if ((retval = jtag_interface_init(cmd_ctx)) != ERROR_OK)
return retval;
if (jtag_init_inner(cmd_ctx) == ERROR_OK)
{
return retval;
if (jtag_init_inner(cmd_ctx) == ERROR_OK)
{
/* add callback to end of queue */
void interface_jtag_add_callback4(jtag_callback_t callback, jtag_callback_data_t data0, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
{
/* add callback to end of queue */
void interface_jtag_add_callback4(jtag_callback_t callback, jtag_callback_data_t data0, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
{
- struct jtag_callback_entry *entry=cmd_queue_alloc(sizeof(struct jtag_callback_entry));
+ struct jtag_callback_entry *entry = cmd_queue_alloc(sizeof(struct jtag_callback_entry));
- entry->next=NULL;
- entry->callback=callback;
- entry->data0=data0;
- entry->data1=data1;
- entry->data2=data2;
- entry->data3=data3;
+ entry->next = NULL;
+ entry->callback = callback;
+ entry->data0 = data0;
+ entry->data1 = data1;
+ entry->data2 = data2;
+ entry->data3 = data3;
if (jtag_callback_queue_head == NULL)
{
if (jtag_callback_queue_head == NULL)
{
- jtag_callback_queue_head=entry;
- jtag_callback_queue_tail=entry;
+ jtag_callback_queue_head = entry;
+ jtag_callback_queue_tail = entry;
- jtag_callback_queue_tail->next=entry;
- jtag_callback_queue_tail=entry;
+ jtag_callback_queue_tail->next = entry;
+ jtag_callback_queue_tail = entry;
if (retval == ERROR_OK)
{
struct jtag_callback_entry *entry;
if (retval == ERROR_OK)
{
struct jtag_callback_entry *entry;
- for (entry=jtag_callback_queue_head; entry != NULL; entry=entry->next)
+ for (entry = jtag_callback_queue_head; entry != NULL; entry = entry->next)
- retval=entry->callback(entry->data0, entry->data1, entry->data2, entry->data3);
+ retval = entry->callback(entry->data0, entry->data1, entry->data2, entry->data3);
if (retval != ERROR_OK)
break;
}
if (retval != ERROR_OK)
break;
}
+ *jtag_speed = 64000/khz;
-// LOG_DEBUG("mpsse cmd=%02x, tms_bits=0x%08x, bit_count=%d", mpsse_cmd, tms_bits, tms_count);
+// LOG_DEBUG("mpsse cmd=%02x, tms_bits = 0x%08x, bit_count=%d", mpsse_cmd, tms_bits, tms_count);
for (tms_byte = tms_ndx = i = 0; i < tms_count; ++i, tms_bits>>=1)
{
for (tms_byte = tms_ndx = i = 0; i < tms_count; ++i, tms_bits>>=1)
{
ft2232_adaptive_clocking(speed);
buf[0] = 0x86; /* command "set divisor" */
ft2232_adaptive_clocking(speed);
buf[0] = 0x86; /* command "set divisor" */
- buf[1] = speed & 0xff; /* valueL (0=6MHz, 1=3MHz, 2=2.0MHz, ...*/
+ buf[1] = speed & 0xff; /* valueL (0 = 6MHz, 1 = 3MHz, 2 = 2.0MHz, ...*/
buf[2] = (speed >> 8) & 0xff; /* valueH */
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
buf[2] = (speed >> 8) & 0xff; /* valueH */
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
int scan_size;
enum scan_type type;
int retval;
int scan_size;
enum scan_type type;
int retval;
- uint32_t bytes_written=0;
- uint32_t bytes_read=0;
+ uint32_t bytes_written = 0;
+ uint32_t bytes_read = 0;
#ifdef _DEBUG_USB_IO_
struct timeval start, inter, inter2, end;
#ifdef _DEBUG_USB_IO_
struct timeval start, inter, inter2, end;
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
- buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
- buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
+ buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, xRST high) */
+ buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
- buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
- buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
+ buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
+ buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
- buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
- buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
+ buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
+ buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
- buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
- buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
+ buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
+ buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
- buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
- buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
+ buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
+ buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE[12]=out, n[ST]srst = out */
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
- buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
- buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
+ buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
+ buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
- buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
- buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
+ buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
+ buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
- buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
- buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
+ buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
+ buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
- buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
- buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
+ buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
+ buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
/* initialize low byte for jtag */
buf[0] = 0x80; /* command "set data bits low byte" */
- buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
- buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
+ buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
+ buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
static void gw16012_state_move(void)
{
static void gw16012_state_move(void)
{
uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
- * Returns JTAG maxium speed for KHz. 0=RTCK. The function returns
+ * Returns JTAG maxium speed for KHz. 0 = RTCK. The function returns
* a failure if it can't support the KHz/RTCK.
*
* WARNING!!!! if RTCK is *slow* then think carefully about
* a failure if it can't support the KHz/RTCK.
*
* WARNING!!!! if RTCK is *slow* then think carefully about
/* J-Link tap functions */
/* J-Link tap functions */
-static unsigned tap_length=0;
+static unsigned tap_length = 0;
static uint8_t tms_buffer[JLINK_TAP_BUFFER_SIZE];
static uint8_t tdi_buffer[JLINK_TAP_BUFFER_SIZE];
static uint8_t tdo_buffer[JLINK_TAP_BUFFER_SIZE];
static uint8_t tms_buffer[JLINK_TAP_BUFFER_SIZE];
static uint8_t tdi_buffer[JLINK_TAP_BUFFER_SIZE];
static uint8_t tdo_buffer[JLINK_TAP_BUFFER_SIZE];
result2 = jlink_usb_read_emu_result(jlink_jtag);
if (1 != result2)
{
result2 = jlink_usb_read_emu_result(jlink_jtag);
if (1 != result2)
{
- LOG_ERROR("jlink_usb_read_emu_result retried requested=1, result=%d, in_length=%i", result2,in_length);
+ LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, result=%d, in_length=%i", result2,in_length);
/* Try again once, should only happen if (in_length%64 == 0) */
result2 = jlink_usb_read_emu_result(jlink_jtag);
if (1 != result2)
{
LOG_ERROR("jlink_usb_read_emu_result failed "
/* Try again once, should only happen if (in_length%64 == 0) */
result2 = jlink_usb_read_emu_result(jlink_jtag);
if (1 != result2)
{
LOG_ERROR("jlink_usb_read_emu_result failed "
- "(requested=1, result=%d)", result2);
+ "(requested = 1, result=%d)", result2);
return ERROR_JTAG_DEVICE_ERROR;
}
}
return ERROR_JTAG_DEVICE_ERROR;
}
}
- tap_state_t cur_state=cmd_queue_cur_state;
+ tap_state_t cur_state = cmd_queue_cur_state;
LOG_DEBUG("...open");
#if !defined(__FreeBSD__) && !defined(__FreeBSD_kernel__)
LOG_DEBUG("...open");
#if !defined(__FreeBSD__) && !defined(__FreeBSD_kernel__)
- i=ioctl(device_handle, PPCLAIM);
+ i = ioctl(device_handle, PPCLAIM);
if (i<0)
{
LOG_ERROR("cannot claim device");
if (i<0)
{
LOG_ERROR("cannot claim device");
presto_data = 0;
for (i = 0; i < 4 * 62; i++)
presto_data = 0;
for (i = 0; i < 4 * 62; i++)
- if ((presto->status=FT_Write(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
+ if ((presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
usleep(100000);
return ERROR_JTAG_DEVICE_ERROR;
usleep(100000);
static int presto_open(char *req_serial)
{
static int presto_open(char *req_serial)
{
- presto->buff_out_pos=0;
- presto->buff_in_pos=0;
- presto->buff_in_len=0;
- presto->buff_in_exp=0;
+ presto->buff_out_pos = 0;
+ presto->buff_in_pos = 0;
+ presto->buff_in_len = 0;
+ presto->buff_in_exp = 0;
- presto->total_out=0;
- presto->total_in=0;
+ presto->total_out = 0;
+ presto->total_in = 0;
- presto->jtag_tms=0;
- presto->jtag_tck=0;
- presto->jtag_rst=0;
- presto->jtag_tdi_data=0;
- presto->jtag_tdi_count=0;
+ presto->jtag_tms = 0;
+ presto->jtag_tck = 0;
+ presto->jtag_rst = 0;
+ presto->jtag_tdi_data = 0;
+ presto->jtag_tdi_count = 0;
+ presto->jtag_speed = 0;
#if BUILD_PRESTO_FTD2XX == 1
return presto_open_ftd2xx(req_serial);
#if BUILD_PRESTO_FTD2XX == 1
return presto_open_ftd2xx(req_serial);
}
/* delay with TCK low */
}
/* delay with TCK low */
- for (i=presto->jtag_speed; i>1; i--)
+ for (i = presto->jtag_speed; i>1; i--)
presto_sendbyte(cmd);
cmd |= 0x04;
presto_sendbyte(cmd | (tdo_req ? 0x10 : 0));
/* delay with TCK high */
presto_sendbyte(cmd);
cmd |= 0x04;
presto_sendbyte(cmd | (tdo_req ? 0x10 : 0));
/* delay with TCK high */
- for (i=presto->jtag_speed; i>1; i--)
+ for (i = presto->jtag_speed; i>1; i--)
presto_sendbyte(cmd);
presto->jtag_tck = 1;
presto_sendbyte(cmd);
presto->jtag_tck = 1;
return ERROR_INVALID_ARGUMENTS;
}
return ERROR_INVALID_ARGUMENTS;
}
{
if ((speed < 0) || (speed > 1000))
{
{
if ((speed < 0) || (speed > 1000))
{
return ERROR_INVALID_ARGUMENTS;
}
return ERROR_INVALID_ARGUMENTS;
}
static
void rlink_state_move(void) {
static
void rlink_state_move(void) {
uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
- printf("scan_size = %d, type=0x%x\n", scan_size, type);
+ printf("scan_size = %d, type = 0x%x\n", scan_size, type);
struct usb_bus *busses;
struct usb_bus *bus;
int i, j, retries;
struct usb_bus *busses;
struct usb_bus *bus;
int i, j, retries;
- int found=0;
- int success=0;
+ int found = 0;
+ int success = 0;
uint8_t reply_buffer[USB_EP1IN_SIZE];
usb_init();
uint8_t reply_buffer[USB_EP1IN_SIZE];
usb_init();
if ( !pHDev )
LOG_ERROR ("Failed to open device.\n");
else
if ( !pHDev )
LOG_ERROR ("Failed to open device.\n");
else
static int default_power_dropout(int *dropout)
{
static int default_power_dropout(int *dropout)
{
- *dropout=0; /* by default we can't detect power dropout */
+ *dropout = 0; /* by default we can't detect power dropout */
return ERROR_OK;
}
static int default_srst_asserted(int *srst_asserted)
{
return ERROR_OK;
}
static int default_srst_asserted(int *srst_asserted)
{
- *srst_asserted=0; /* by default we can't detect srst asserted */
+ *srst_asserted = 0; /* by default we can't detect srst asserted */
+ num_fields = (argc-2)/2;
fields = malloc(sizeof(scan_field_t) * num_fields);
for (i = 2; i < argc; i += 2)
{
fields = malloc(sizeof(scan_field_t) * num_fields);
for (i = 2; i < argc; i += 2)
{
Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
for (i = 2; i < argc; i += 2)
{
Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
for (i = 2; i < argc; i += 2)
{
script_debug(interp, "pathmove", argc, args);
int i;
script_debug(interp, "pathmove", argc, args);
int i;
- for (i=0; i<argc-1; i++)
+ for (i = 0; i<argc-1; i++)
{
const char *cp;
cp = Jim_GetString( args[i+1], NULL );
{
const char *cp;
cp = Jim_GetString( args[i+1], NULL );
static void usbprog_write(int tck, int tms, int tdi)
{
static void usbprog_write(int tck, int tms, int tdi)
{
- unsigned char output_value=0x00;
+ unsigned char output_value = 0x00;
if (tms)
output_value |= (1 << TMS_BIT);
if (tms)
output_value |= (1 << TMS_BIT);
#if 0
int diag_printf( const char *fmt, ... );
#define ZY1000_POKE(a, b) HAL_WRITE_UINT32(a, b); diag_printf("poke 0x%08x,0x%08x\n", a, b)
#if 0
int diag_printf( const char *fmt, ... );
#define ZY1000_POKE(a, b) HAL_WRITE_UINT32(a, b); diag_printf("poke 0x%08x,0x%08x\n", a, b)
-#define ZY1000_PEEK(a, b) HAL_READ_UINT32(a, b); diag_printf("peek 0x%08x=0x%08x\n", a, b)
+#define ZY1000_PEEK(a, b) HAL_READ_UINT32(a, b); diag_printf("peek 0x%08x = 0x%08x\n", a, b)
#else
#define ZY1000_POKE(a, b) HAL_WRITE_UINT32(a, b)
#define ZY1000_PEEK(a, b) HAL_READ_UINT32(a, b)
#else
#define ZY1000_POKE(a, b) HAL_WRITE_UINT32(a, b)
#define ZY1000_PEEK(a, b) HAL_READ_UINT32(a, b)
static void setCurrentState(enum tap_state state)
{
cyg_uint32 a;
static void setCurrentState(enum tap_state state)
{
cyg_uint32 a;
- a=state;
- int repeat=0;
+ a = state;
+ int repeat = 0;
if (state == TAP_RESET)
{
// The FPGA nor we know the current state of the CPU TAP
// controller. This will move it to TAP for sure.
//
// 5 should be enough here, 7 is what OpenOCD uses
if (state == TAP_RESET)
{
// The FPGA nor we know the current state of the CPU TAP
// controller. This will move it to TAP for sure.
//
// 5 should be enough here, 7 is what OpenOCD uses
}
waitQueue();
sampleShiftRegister();
}
waitQueue();
sampleShiftRegister();
static __inline__ void shiftValueInner(const enum tap_state state, const enum tap_state endState, int repeat, cyg_uint32 value)
{
cyg_uint32 a,b;
static __inline__ void shiftValueInner(const enum tap_state state, const enum tap_state endState, int repeat, cyg_uint32 value)
{
cyg_uint32 a,b;
+ a = state;
+ b = endState;
waitQueue();
sampleShiftRegister();
ZY1000_POKE(ZY1000_JTAG_BASE+0xc, value);
waitQueue();
sampleShiftRegister();
ZY1000_POKE(ZY1000_JTAG_BASE+0xc, value);
{
int i;
setCurrentState(state);
{
int i;
setCurrentState(state);
- for (i=0; i<repeat; i++)
+ for (i = 0; i<repeat; i++)
if ((i == repeat-1) && (state != endState))
{
if ((i == repeat-1) && (state != endState))
{
}
/* shift out value */
waitIdle();
}
/* shift out value */
waitIdle();
{
int i;
/* sample shift register for every bit. */
{
int i;
/* sample shift register for every bit. */
- for (i=0; i<repeat-1; i++)
+ for (i = 0; i<repeat-1; i++)
{
sampleShiftRegister();
ZY1000_POKE(ZY1000_JTAG_BASE+0xc, value >> i);
{
sampleShiftRegister();
ZY1000_POKE(ZY1000_JTAG_BASE+0xc, value >> i);
enum tap_state pause_state = TAP_DRSHIFT;
jtag_tap_t *tap, *nextTap;
enum tap_state pause_state = TAP_DRSHIFT;
jtag_tap_t *tap, *nextTap;
- for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap=nextTap)
+ for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap = nextTap)
- nextTap=jtag_tap_next_enabled(tap);
+ nextTap = jtag_tap_next_enabled(tap);
if (nextTap == NULL)
{
pause_state = end_state;
if (nextTap == NULL)
{
pause_state = end_state;
if (tap == target_tap)
{
int j;
if (tap == target_tap)
{
int j;
- for (j=0; j<(num_fields-1); j++)
+ for (j = 0; j<(num_fields-1); j++)
{
shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, num_bits[j], value[j]);
}
{
shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, num_bits[j], value[j]);
}
enum tap_state end_state)
{
enum tap_state end_state)
{
- int singletap=(jtag_tap_next_enabled(jtag_tap_next_enabled(NULL)) == NULL);
+ int singletap = (jtag_tap_next_enabled(jtag_tap_next_enabled(NULL)) == NULL);
if ((singletap) && (num_fields == 3))
{
/* used by embeddedice_write_reg_inner() */
if ((singletap) && (num_fields == 3))
{
/* used by embeddedice_write_reg_inner() */
+ *jtag_speed = 64000/khz;
static int zy1000_srst_asserted(int *srst_asserted)
{
static int zy1000_srst_asserted(int *srst_asserted)
{
- *srst_asserted=readSRST();
+ *srst_asserted = readSRST();
return ERROR_OK;
}
static int zy1000_power_dropout(int *dropout)
{
return ERROR_OK;
}
static int zy1000_power_dropout(int *dropout)
{
- *dropout=readPowerDropout();
+ *dropout = readPowerDropout();
+ for (i = 0; i<1000; i++)
{
// We don't want to sense our own reset, so we clear here.
// There is of course a timing hole where we could loose
{
// We don't want to sense our own reset, so we clear here.
// There is of course a timing hole where we could loose
if ((argc < 1) || (argc > 2))
return JIM_ERR;
char buff[128];
if ((argc < 1) || (argc > 2))
return JIM_ERR;
char buff[128];
- const char *version_str=NULL;
+ const char *version_str = NULL;
- version_str=ZYLIN_OPENOCD_VERSION;
+ version_str = ZYLIN_OPENOCD_VERSION;
} else
{
const char *str = Jim_GetString(argv[1], NULL);
} else
{
const char *str = Jim_GetString(argv[1], NULL);
int revision;
revision = atol(ZYLIN_OPENOCD+strlen("XRevision: "));
sprintf(buff, "%d", revision);
int revision;
revision = atol(ZYLIN_OPENOCD+strlen("XRevision: "));
sprintf(buff, "%d", revision);
}
else if (strcmp("zy1000", str) == 0)
{
}
else if (strcmp("zy1000", str) == 0)
{
- version_str=ZYLIN_VERSION;
+ version_str = ZYLIN_VERSION;
}
else if (strcmp("date", str) == 0)
{
}
else if (strcmp("date", str) == 0)
{
- version_str=ZYLIN_DATE;
+ version_str = ZYLIN_DATE;
{
VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_name(state), tap_state_name(endState), repeat, value));
cyg_uint32 a,b;
{
VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_name(state), tap_state_name(endState), repeat, value));
cyg_uint32 a,b;
+ a = state;
+ b = endState;
ZY1000_POKE(ZY1000_JTAG_BASE+0xc, value);
ZY1000_POKE(ZY1000_JTAG_BASE+0x8, (1 << 15)|(repeat << 8)|(a << 4)|b);
VERBOSE(getShiftValueFlip());
ZY1000_POKE(ZY1000_JTAG_BASE+0xc, value);
ZY1000_POKE(ZY1000_JTAG_BASE+0x8, (1 << 15)|(repeat << 8)|(a << 4)|b);
VERBOSE(getShiftValueFlip());
- uint8_t *inBuffer=NULL;
+ uint8_t *inBuffer = NULL;
// figure out where to store the input data
// figure out where to store the input data
- int num_bits=fields[i].num_bits;
+ int num_bits = fields[i].num_bits;
if (fields[i].in_value != NULL)
{
if (fields[i].in_value != NULL)
{
- inBuffer=fields[i].in_value;
+ inBuffer = fields[i].in_value;
}
// here we shuffle N bits out/in
}
// here we shuffle N bits out/in
while (j<num_bits)
{
tap_state_t pause_state;
int l;
while (j<num_bits)
{
tap_state_t pause_state;
int l;
- k=num_bits-j;
- pause_state=(shiftState == TAP_DRSHIFT)?TAP_DRSHIFT:TAP_IRSHIFT;
+ k = num_bits-j;
+ pause_state = (shiftState == TAP_DRSHIFT)?TAP_DRSHIFT:TAP_IRSHIFT;
/* we have more to shift out */
} else if (i == num_fields-1)
{
/* this was the last to shift out this time */
/* we have more to shift out */
} else if (i == num_fields-1)
{
/* this was the last to shift out this time */
+ pause_state = end_state;
}
// we have (num_bits+7)/8 bytes of bits to toggle out.
// bits are pushed out LSB to MSB
}
// we have (num_bits+7)/8 bytes of bits to toggle out.
// bits are pushed out LSB to MSB
if (fields[i].out_value != NULL)
{
if (fields[i].out_value != NULL)
{
+ for (l = 0; l<k; l += 8)
{
value|=fields[i].out_value[(j+l)/8]<<l;
}
{
value|=fields[i].out_value[(j+l)/8]<<l;
}
if (inBuffer != NULL)
{
// data in, LSB to MSB
if (inBuffer != NULL)
{
// data in, LSB to MSB
+ value = getShiftValue();
// we're shifting in data to MSB, shift data to be aligned for returning the value
value >>= 32-k;
// we're shifting in data to MSB, shift data to be aligned for returning the value
value >>= 32-k;
+ for (l = 0; l<k; l += 8)
{
inBuffer[(j+l)/8]=(value >> l)&0xff;
}
{
inBuffer[(j+l)/8]=(value >> l)&0xff;
}
int j;
int scan_size = 0;
jtag_tap_t *tap, *nextTap;
int j;
int scan_size = 0;
jtag_tap_t *tap, *nextTap;
- for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap=nextTap)
+ for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap = nextTap)
- nextTap=jtag_tap_next_enabled(tap);
+ nextTap = jtag_tap_next_enabled(tap);
tap_state_t end_state;
if (nextTap == NULL)
{
tap_state_t end_state;
if (nextTap == NULL)
{
scan_size = tap->ir_length;
/* search the list */
scan_size = tap->ir_length;
/* search the list */
- for (j=0; j < num_fields; j++)
+ for (j = 0; j < num_fields; j++)
{
if (tap == fields[j].tap)
{
{
if (tap == fields[j].tap)
{
int j;
jtag_tap_t *tap, *nextTap;
int j;
jtag_tap_t *tap, *nextTap;
- for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap=nextTap)
+ for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap = nextTap)
- nextTap=jtag_tap_next_enabled(tap);
- int found=0;
+ nextTap = jtag_tap_next_enabled(tap);
+ int found = 0;
tap_state_t end_state;
if (nextTap == NULL)
{
tap_state_t end_state;
if (nextTap == NULL)
{
end_state = TAP_DRSHIFT;
}
end_state = TAP_DRSHIFT;
}
- for (j=0; j < num_fields; j++)
+ for (j = 0; j < num_fields; j++)
{
if (tap == fields[j].tap)
{
{
if (tap == fields[j].tap)
{
/* execute num_cycles, 32 at the time. */
int i;
/* execute num_cycles, 32 at the time. */
int i;
- for (i=0; i<num_cycles; i += 32)
+ for (i = 0; i<num_cycles; i += 32)
}
shiftValueInner(clockstate, clockstate, num, 0);
}
}
shiftValueInner(clockstate, clockstate, num, 0);
}
/* finish in end_state */
setCurrentState(state);
#else
/* finish in end_state */
setCurrentState(state);
#else
- tap_state_t t=TAP_IDLE;
+ tap_state_t t = TAP_IDLE;
/* test manual drive code on any target */
int tms;
uint8_t tms_scan = tap_get_tms_path(t, state);
/* test manual drive code on any target */
int tms;
uint8_t tms_scan = tap_get_tms_path(t, state);
- tap_state_t cur_state=cmd_queue_cur_state;
+ tap_state_t cur_state = cmd_queue_cur_state;
void embeddedice_write_dcc(jtag_tap_t *tap, int reg_addr, uint8_t *buffer, int little, int count)
{
void embeddedice_write_dcc(jtag_tap_t *tap, int reg_addr, uint8_t *buffer, int little, int count)
{
-// static int const reg_addr=0x5;
- tap_state_t end_state=jtag_get_end_state();
+// static int const reg_addr = 0x5;
+ tap_state_t end_state = jtag_get_end_state();
if (jtag_tap_next_enabled(jtag_tap_next_enabled(NULL)) == NULL)
{
/* better performance via code duplication */
if (jtag_tap_next_enabled(jtag_tap_next_enabled(NULL)) == NULL)
{
/* better performance via code duplication */
switch (event)
{
case TARGET_EVENT_GDB_START:
switch (event)
{
case TARGET_EVENT_GDB_START:
break;
case TARGET_EVENT_GDB_END:
break;
case TARGET_EVENT_GDB_END:
break;
case TARGET_EVENT_HALTED:
if (target->display)
break;
case TARGET_EVENT_HALTED:
if (target->display)
return ERROR_COMMAND_SYNTAX_ERROR;
int retval;
return ERROR_COMMAND_SYNTAX_ERROR;
int retval;
- static int initialized=0;
+ static int initialized = 0;
if (initialized)
return ERROR_OK;
if (initialized)
return ERROR_OK;
return ERROR_FAIL;
LOG_DEBUG("target init complete");
return ERROR_FAIL;
LOG_DEBUG("target init complete");
- if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
+ if ((retval = jtag_interface_init(cmd_ctx)) != ERROR_OK)
{
/* we must be able to set up the jtag interface */
return retval;
{
/* we must be able to set up the jtag interface */
return retval;
static __inline__ void virtexflip32(jtag_callback_data_t arg)
{
static __inline__ void virtexflip32(jtag_callback_data_t arg)
{
- uint8_t *in=(uint8_t *)arg;
+ uint8_t *in = (uint8_t *)arg;
*((uint32_t *)in) = flip_u32(le_to_h_u32(in), 32);
}
*((uint32_t *)in) = flip_u32(le_to_h_u32(in), 32);
}
int t;
if (got_data == NULL)
got_data=&t;
int t;
if (got_data == NULL)
got_data=&t;
if (gdb_con->buf_cnt>0)
{
if (gdb_con->buf_cnt>0)
{
- *got_data=FD_ISSET(connection->fd, &read_fds) != 0;
+ *got_data = FD_ISSET(connection->fd, &read_fds) != 0;
return ERROR_OK;
}
int gdb_get_char(connection_t *connection, int* next_char)
{
gdb_connection_t *gdb_con = connection->priv;
return ERROR_OK;
}
int gdb_get_char(connection_t *connection, int* next_char)
{
gdb_connection_t *gdb_con = connection->priv;
#ifdef _DEBUG_GDB_IO_
char *debug_buffer;
#ifdef _DEBUG_GDB_IO_
char *debug_buffer;
- if ((retval=check_pending(connection, 0, &gotdata)) != ERROR_OK)
+ if ((retval = check_pending(connection, 0, &gotdata)) != ERROR_OK)
return retval;
if (!gotdata)
break;
return retval;
if (!gotdata)
break;
} else {
LOG_ERROR("unknown character(1) 0x%2.2x in reply, dropping connection", reply);
} else {
LOG_ERROR("unknown character(1) 0x%2.2x in reply, dropping connection", reply);
return ERROR_SERVER_REMOTE_CLOSED;
}
}
return ERROR_SERVER_REMOTE_CLOSED;
}
}
else
{
LOG_ERROR("unknown character(2) 0x%2.2x in reply, dropping connection", reply);
else
{
LOG_ERROR("unknown character(2) 0x%2.2x in reply, dropping connection", reply);
return ERROR_SERVER_REMOTE_CLOSED;
}
}
return ERROR_SERVER_REMOTE_CLOSED;
}
}
- *checksum_ok=(my_checksum == strtoul(checksum, NULL, 16));
+ *checksum_ok = (my_checksum == strtoul(checksum, NULL, 16));
*/
if (gdb_con->noack_mode)
{
*/
if (gdb_con->noack_mode)
{
- if ((retval=fetch_packet(connection, &checksum_ok, 1, len, buffer)) != ERROR_OK)
+ if ((retval = fetch_packet(connection, &checksum_ok, 1, len, buffer)) != ERROR_OK)
- if ((retval=fetch_packet(connection, &checksum_ok, 0, len, buffer)) != ERROR_OK)
+ if ((retval = fetch_packet(connection, &checksum_ok, 0, len, buffer)) != ERROR_OK)
return ERROR_GDB_BUFFER_TOO_SMALL;
hex_buffer[0] = 'O';
return ERROR_GDB_BUFFER_TOO_SMALL;
hex_buffer[0] = 'O';
- for (i=0; i<bin_size; i++)
+ for (i = 0; i<bin_size; i++)
snprintf(hex_buffer + 1 + i*2, 3, "%2.2x", line[i]);
hex_buffer[bin_size*2+1] = 0;
snprintf(hex_buffer + 1 + i*2, 3, "%2.2x", line[i]);
hex_buffer[bin_size*2+1] = 0;
if (c>='A'&&c<='F')
{
return c-'A'+10;
if (c>='A'&&c<='F')
{
return c-'A'+10;
* gained by involving the user in this problem that hopefully will get resolved
* eventually
*
* gained by involving the user in this problem that hopefully will get resolved
* eventually
*
- * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gdb&pr=2395
+ * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd = view%20audit-trail&database = gdb&pr = 2395
*
* For now, the default is to fix up things to make current GDB versions work.
* This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
*
* For now, the default is to fix up things to make current GDB versions work.
* This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
LOG_DEBUG("addr: 0x%8.8" PRIx32 ", len: 0x%8.8" PRIx32 "", addr, len);
LOG_DEBUG("addr: 0x%8.8" PRIx32 ", len: 0x%8.8" PRIx32 "", addr, len);
+ for (i = 0; i<len; i++)
{
uint32_t tmp;
sscanf(separator + 2*i, "%2" SCNx32 , &tmp);
{
uint32_t tmp;
sscanf(separator + 2*i, "%2" SCNx32 , &tmp);
{
int current = 0;
uint32_t address = 0x0;
{
int current = 0;
uint32_t address = 0x0;
{
LOG_DEBUG("continue");
target_handle_event( target, TARGET_EVENT_OLD_pre_resume );
{
LOG_DEBUG("continue");
target_handle_event( target, TARGET_EVENT_OLD_pre_resume );
- retval=target_resume(target, current, address, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
+ retval = target_resume(target, current, address, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
}
else if (packet[0] == 's')
{
}
else if (packet[0] == 's')
{
if (gdb_breakpoint_override && ((bp_type == BKPT_SOFT)||(bp_type == BKPT_HARD)))
{
if (gdb_breakpoint_override && ((bp_type == BKPT_SOFT)||(bp_type == BKPT_HARD)))
{
- bp_type=gdb_breakpoint_override_type;
+ bp_type = gdb_breakpoint_override_type;
char *cmd;
int i;
cmd = malloc((packet_size - 6)/2 + 1);
char *cmd;
int i;
cmd = malloc((packet_size - 6)/2 + 1);
- for (i=0; i < (packet_size - 6)/2; i++)
+ for (i = 0; i < (packet_size - 6)/2; i++)
{
uint32_t tmp;
sscanf(packet + 6 + 2*i, "%2" SCNx32 , &tmp);
{
uint32_t tmp;
sscanf(packet + 6 + 2*i, "%2" SCNx32 , &tmp);
read/write) by default for GDB.
GDB does not have a concept of non-cacheable read/write memory.
*/
read/write) by default for GDB.
GDB does not have a concept of non-cacheable read/write memory.
*/
- flash_bank_t **banks=malloc(sizeof(flash_bank_t *)*flash_get_bank_count());
+ flash_bank_t **banks = malloc(sizeof(flash_bank_t *)*flash_get_bank_count());
- for (i=0; i<flash_get_bank_count(); i++)
+ for (i = 0; i<flash_get_bank_count(); i++)
{
p = get_flash_bank_by_num(i);
if (p == NULL)
{
p = get_flash_bank_by_num(i);
if (p == NULL)
qsort(banks, flash_get_bank_count(), sizeof(flash_bank_t *), compare_bank);
qsort(banks, flash_get_bank_count(), sizeof(flash_bank_t *), compare_bank);
- uint32_t ram_start=0;
- for (i=0; i<flash_get_bank_count(); i++)
+ uint32_t ram_start = 0;
+ for (i = 0; i<flash_get_bank_count(); i++)
"<property name=\"blocksize\">0x%x</property>\n" \
"</memory>\n", \
p->base, p->size, blocksize);
"<property name=\"blocksize\">0x%x</property>\n" \
"</memory>\n", \
p->base, p->size, blocksize);
- ram_start=p->base+p->size;
+ ram_start = p->base+p->size;
{
gdb_service_t *gdb_service = connection->service->priv;
target_t *target = gdb_service->target;
{
gdb_service_t *gdb_service = connection->service->priv;
target_t *target = gdb_service->target;
- char *packet=gdb_packet_buffer;
+ char *packet = gdb_packet_buffer;
int packet_size;
int retval;
gdb_connection_t *gdb_con = connection->priv;
int packet_size;
int retval;
gdb_connection_t *gdb_con = connection->priv;
gdb_con->frontend_state = TARGET_RUNNING;
log_add_callback(gdb_log_callback, connection);
target_call_event_callbacks(target, TARGET_EVENT_GDB_START);
gdb_con->frontend_state = TARGET_RUNNING;
log_add_callback(gdb_log_callback, connection);
target_call_event_callbacks(target, TARGET_EVENT_GDB_START);
- int retval=gdb_step_continue_packet(connection, target, packet, packet_size);
+ int retval = gdb_step_continue_packet(connection, target, packet, packet_size);
if (retval != ERROR_OK)
{
/* we'll never receive a halted condition... issue a false one.. */
if (retval != ERROR_OK)
{
/* we'll never receive a halted condition... issue a false one.. */
gdb_breakpoint_override = 1;
if (strcmp(args[0], "hard") == 0)
{
gdb_breakpoint_override = 1;
if (strcmp(args[0], "hard") == 0)
{
- gdb_breakpoint_override_type=BKPT_HARD;
+ gdb_breakpoint_override_type = BKPT_HARD;
} else if (strcmp(args[0], "soft") == 0)
{
} else if (strcmp(args[0], "soft") == 0)
{
- gdb_breakpoint_override_type=BKPT_SOFT;
+ gdb_breakpoint_override_type = BKPT_SOFT;
} else if (strcmp(args[0], "disable") == 0)
{
gdb_breakpoint_override = 0;
} else if (strcmp(args[0], "disable") == 0)
{
gdb_breakpoint_override = 0;
if (!*url)
url="index.tcl";
if (!*url)
url="index.tcl";
- const char *file_name=alloc_printf("%s/%s", httpd_dir, url);
+ const char *file_name = alloc_printf("%s/%s", httpd_dir, url);
int result = handle_request(connection, file_name);
free((void *)file_name);
return result;
int result = handle_request(connection, file_name);
free((void *)file_name);
return result;
socklen_t address_size;
connection_t *c, **p;
int retval;
socklen_t address_size;
connection_t *c, **p;
int retval;
c = malloc(sizeof(connection_t));
c->fd = -1;
c = malloc(sizeof(connection_t));
c->fd = -1;
/* This increases performance dramatically for e.g. GDB load which
* does not have a sliding window protocol. */
/* This increases performance dramatically for e.g. GDB load which
* does not have a sliding window protocol. */
- retval=setsockopt(c->fd, /* socket affected */
+ retval = setsockopt(c->fd, /* socket affected */
IPPROTO_TCP, /* set option at TCP level */
TCP_NODELAY, /* name of option */
(char *)&flag, /* the cast is historical cruft */
IPPROTO_TCP, /* set option at TCP level */
TCP_NODELAY, /* name of option */
(char *)&flag, /* the cast is historical cruft */
setsockopt(c->fd, IPPROTO_TCP, TCP_MAXSEG, &segsize, sizeof(int));
#endif
int window_size = 128 * 1024;
setsockopt(c->fd, IPPROTO_TCP, TCP_MAXSEG, &segsize, sizeof(int));
#endif
int window_size = 128 * 1024;
/* put the command line to its previous state */
telnet_prompt(connection);
telnet_write(connection, t_con->line, t_con->line_size);
/* put the command line to its previous state */
telnet_prompt(connection);
telnet_write(connection, t_con->line, t_con->line_size);
- for (i=t_con->line_size; i>t_con->line_cursor; i--)
+ for (i = t_con->line_size; i>t_con->line_cursor; i--)
telnet_write(connection, "\b", 1);
}
telnet_write(connection, "\b", 1);
}
- long long then=timeval_ms();
+ long long then = timeval_ms();
- while (!(timeout=((timeval_ms()-then)>1000)))
+ while (!(timeout = ((timeval_ms()-then)>1000)))
{
if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_DBGACK, 1) == 0)
{
{
if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_DBGACK, 1) == 0)
{
/* pick a breakpoint unit */
if (!arm7_9->wp0_used)
{
/* pick a breakpoint unit */
if (!arm7_9->wp0_used)
{
- arm7_9->sw_breakpoints_added=1;
+ arm7_9->sw_breakpoints_added = 1;
arm7_9->wp0_used = 3;
} else if (!arm7_9->wp1_used)
{
arm7_9->wp0_used = 3;
} else if (!arm7_9->wp1_used)
{
- arm7_9->sw_breakpoints_added=2;
+ arm7_9->sw_breakpoints_added = 2;
arm7_9->wp1_used = 3;
}
else
arm7_9->wp1_used = 3;
}
else
{
armv4_5_common_t *armv4_5 = target->arch_info;
arm7_9_common_t *arm7_9 = armv4_5->arch_info;
{
armv4_5_common_t *armv4_5 = target->arch_info;
arm7_9_common_t *arm7_9 = armv4_5->arch_info;
if (target->state != TARGET_HALTED)
{
if (target->state != TARGET_HALTED)
{
- retval=jtag_execute_queue();
+ retval = jtag_execute_queue();
}
else if (breakpoint->type == BKPT_SOFT)
{
}
else if (breakpoint->type == BKPT_SOFT)
{
- if ((retval=arm7_9_set_software_breakpoints(arm7_9)) != ERROR_OK)
+ if ((retval = arm7_9_set_software_breakpoints(arm7_9)) != ERROR_OK)
return retval;
/* did we already set this breakpoint? */
return retval;
/* did we already set this breakpoint? */
}
arm_jtag_set_instr(jtag_info, 0x4, NULL);
}
arm_jtag_set_instr(jtag_info, 0x4, NULL);
- long long then=timeval_ms();
+ long long then = timeval_ms();
- while (!(timeout=((timeval_ms()-then)>1000)))
+ while (!(timeout = ((timeval_ms()-then)>1000)))
{
/* read debug status register */
embeddedice_read_reg(dbg_stat);
{
/* read debug status register */
embeddedice_read_reg(dbg_stat);
*/
int arm7_9_execute_fast_sys_speed(struct target_s *target)
{
*/
int arm7_9_execute_fast_sys_speed(struct target_s *target)
{
static uint8_t check_value[4], check_mask[4];
armv4_5_common_t *armv4_5 = target->arch_info;
static uint8_t check_value[4], check_mask[4];
armv4_5_common_t *armv4_5 = target->arch_info;
* */
buf_set_u32(check_value, 0, 32, 0x9);
buf_set_u32(check_mask, 0, 32, 0x9);
* */
buf_set_u32(check_value, 0, 32, 0x9);
buf_set_u32(check_mask, 0, 32, 0x9);
}
/* read debug status register */
}
/* read debug status register */
}
if ((target->state == TARGET_RUNNING) || (target->state == TARGET_RESET))
{
}
if ((target->state == TARGET_RUNNING) || (target->state == TARGET_RESET))
{
if (target->state == TARGET_RESET)
{
if (target->reset_halt)
if (target->state == TARGET_RESET)
{
if (target->reset_halt)
*/
int arm7_9_deassert_reset(target_t *target)
{
*/
int arm7_9_deassert_reset(target_t *target)
{
LOG_DEBUG("target->state: %s",
Jim_Nvp_value2name_simple( nvp_target_state,target->state)->name);
LOG_DEBUG("target->state: %s",
Jim_Nvp_value2name_simple( nvp_target_state,target->state)->name);
if ((retval = target_examine_one(target)) != ERROR_OK)
return retval;
if ((retval = target_examine_one(target)) != ERROR_OK)
return retval;
- if ((retval=target_poll(target)) != ERROR_OK)
+ if ((retval = target_poll(target)) != ERROR_OK)
- if ((retval=target_halt(target)) != ERROR_OK)
+ if ((retval = target_halt(target)) != ERROR_OK)
- if ((retval=target_halt(target)) != ERROR_OK)
+ if ((retval = target_halt(target)) != ERROR_OK)
- long long then=timeval_ms();
+ long long then = timeval_ms();
- while (!(timeout=((timeval_ms()-then)>1000)))
+ while (!(timeout = ((timeval_ms()-then)>1000)))
{
if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_DBGACK, 1) != 0)
break;
embeddedice_read_reg(dbg_stat);
{
if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_DBGACK, 1) != 0)
break;
embeddedice_read_reg(dbg_stat);
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
return retval;
if (debug_level >= 3)
{
return retval;
if (debug_level >= 3)
{
if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
return ERROR_FAIL;
if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
return ERROR_FAIL;
- for (i=0; i <= 15; i++)
+ for (i = 0; i <= 15; i++)
{
LOG_DEBUG("r%i: 0x%8.8" PRIx32 "", i, context[i]);
buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).value, 0, 32, context[i]);
{
LOG_DEBUG("r%i: 0x%8.8" PRIx32 "", i, context[i]);
buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).value, 0, 32, context[i]);
reg[0] = address;
arm7_9->write_core_regs(target, 0x1, reg);
reg[0] = address;
arm7_9->write_core_regs(target, 0x1, reg);
if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
return ERROR_FAIL;
if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
return ERROR_FAIL;
- for (i=0; i <= last_reg; i++)
+ for (i = 0; i <= last_reg; i++)
ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).dirty = ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).valid;
arm7_9->read_xpsr(target, &cpsr, 0);
ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).dirty = ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).valid;
arm7_9->read_xpsr(target, &cpsr, 0);
if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
return ERROR_FAIL;
if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
return ERROR_FAIL;
- for (i=0; i <= last_reg; i++)
+ for (i = 0; i <= last_reg; i++)
ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).dirty = ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).valid;
arm7_9->read_xpsr(target, &cpsr, 0);
ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).dirty = ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).valid;
arm7_9->read_xpsr(target, &cpsr, 0);
armv4_5_common_t *armv4_5 = target->arch_info;
arm7_9_common_t *arm7_9 = armv4_5->arch_info;
armv4_5_common_t *armv4_5 = target->arch_info;
arm7_9_common_t *arm7_9 = armv4_5->arch_info;
- if ((retval=target_wait_state(target, TARGET_DEBUG_RUNNING, 500)) != ERROR_OK)
+ if ((retval = target_wait_state(target, TARGET_DEBUG_RUNNING, 500)) != ERROR_OK)
- int little=target->endianness == TARGET_LITTLE_ENDIAN;
- int count=dcc_count;
- uint8_t *buffer=dcc_buffer;
+ int little = target->endianness == TARGET_LITTLE_ENDIAN;
+ int count = dcc_count;
+ uint8_t *buffer = dcc_buffer;
if (count>2)
{
/* Handle first & last using standard embeddedice_write_reg and the middle ones w/the
if (count>2)
{
/* Handle first & last using standard embeddedice_write_reg and the middle ones w/the
buf_set_u32(reg_params[0].value, 0, 32, address);
buf_set_u32(reg_params[0].value, 0, 32, address);
- dcc_count=count;
- dcc_buffer=buffer;
+ dcc_count = count;
+ dcc_buffer = buffer;
retval = armv4_5_run_algorithm_inner(target, 0, NULL, 1, reg_params,
arm7_9->dcc_working_area->address, arm7_9->dcc_working_area->address+6*4, 20*1000, &armv4_5_info, arm7_9_dcc_completion);
if (retval == ERROR_OK)
{
retval = armv4_5_run_algorithm_inner(target, 0, NULL, 1, reg_params,
arm7_9->dcc_working_area->address, arm7_9->dcc_working_area->address+6*4, 20*1000, &armv4_5_info, arm7_9_dcc_completion);
if (retval == ERROR_OK)
{
- uint32_t endaddress=buf_get_u32(reg_params[0].value, 0, 32);
+ uint32_t endaddress = buf_get_u32(reg_params[0].value, 0, 32);
if (endaddress != (address+count*4))
{
LOG_ERROR("DCC write failed, expected end address 0x%08" PRIx32 " got 0x%0" PRIx32 "", (address+count*4), endaddress);
if (endaddress != (address+count*4))
{
LOG_ERROR("DCC write failed, expected end address 0x%08" PRIx32 " got 0x%0" PRIx32 "", (address+count*4), endaddress);
/* convert flash writing code into a buffer in target endianness */
for (i = 0; i < (sizeof(arm7_9_crc_code)/sizeof(uint32_t)); i++)
{
/* convert flash writing code into a buffer in target endianness */
for (i = 0; i < (sizeof(arm7_9_crc_code)/sizeof(uint32_t)); i++)
{
- if ((retval=target_write_u32(target, crc_algorithm->address + i*sizeof(uint32_t), arm7_9_crc_code[i])) != ERROR_OK)
+ if ((retval = target_write_u32(target, crc_algorithm->address + i*sizeof(uint32_t), arm7_9_crc_code[i])) != ERROR_OK)
void arm_endianness(uint8_t *tmp, void *in, int size, int be, int flip)
{
void arm_endianness(uint8_t *tmp, void *in, int size, int be, int flip)
{
- uint32_t readback=le_to_h_u32(tmp);
+ uint32_t readback = le_to_h_u32(tmp);
- readback=flip_u32(readback, 32);
+ readback = flip_u32(readback, 32);
static int arm7endianness(jtag_callback_data_t arg, jtag_callback_data_t size, jtag_callback_data_t be, jtag_callback_data_t captured)
{
static int arm7endianness(jtag_callback_data_t arg, jtag_callback_data_t size, jtag_callback_data_t be, jtag_callback_data_t captured)
{
- uint8_t *in=(uint8_t *)arg;
+ uint8_t *in = (uint8_t *)arg;
arm_endianness((uint8_t *)captured, in, (int)size, (int)be, 1);
return ERROR_OK;
}
arm_endianness((uint8_t *)captured, in, (int)size, (int)be, 1);
return ERROR_OK;
}
{
/* get pointers to arch-specific information */
reg_cache_t **cache_p = register_get_last_cache_p(&target->reg_cache);
{
/* get pointers to arch-specific information */
reg_cache_t **cache_p = register_get_last_cache_p(&target->reg_cache);
- reg_cache_t *t=embeddedice_build_reg_cache(target, arm7_9);
+ reg_cache_t *t = embeddedice_build_reg_cache(target, arm7_9);
if (t == NULL)
return ERROR_FAIL;
if (t == NULL)
return ERROR_FAIL;
}
target_set_examined(target);
}
}
target_set_examined(target);
}
- if ((retval=embeddedice_setup(target)) != ERROR_OK)
+ if ((retval = embeddedice_setup(target)) != ERROR_OK)
- if ((retval=arm7_9_setup(target)) != ERROR_OK)
+ if ((retval = arm7_9_setup(target)) != ERROR_OK)
return retval;
if (arm7_9->etm_ctx)
{
return retval;
if (arm7_9->etm_ctx)
{
- if ((retval=etm_setup(target)) != ERROR_OK)
+ if ((retval = etm_setup(target)) != ERROR_OK)
return retval;
}
return ERROR_OK;
return retval;
}
return ERROR_OK;
- long long then=timeval_ms();
+ long long then = timeval_ms();
- while (!(timeout=((timeval_ms()-then)>1000)))
+ while (!(timeout = ((timeval_ms()-then)>1000)))
{
if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_DBGACK, 1) == 0)
{
{
if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_DBGACK, 1) == 0)
{
* openocd development mailing list if you have hardware
* to donate to look into this problem....
*/
* openocd development mailing list if you have hardware
* to donate to look into this problem....
*/
- LOG_ERROR("mystery debug reason MOE=0xc. Try issuing a resume + halt.");
+ LOG_ERROR("mystery debug reason MOE = 0xc. Try issuing a resume + halt.");
target->debug_reason = DBG_REASON_DBGRQ;
retval = ERROR_TARGET_FAILURE;
break;
target->debug_reason = DBG_REASON_DBGRQ;
retval = ERROR_TARGET_FAILURE;
break;
- long long then=timeval_ms();
+ long long then = timeval_ms();
- while (!(timeout=((timeval_ms()-then)>1000)))
+ while (!(timeout = ((timeval_ms()-then)>1000)))
{
if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_DBGACK, 1) == 0)
{
{
if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_DBGACK, 1) == 0)
{
- fields[0].in_value=(uint8_t *)in;
+ fields[0].in_value = (uint8_t *)in;
jtag_add_dr_scan(3, fields, jtag_get_end_state());
jtag_add_callback(arm_le_to_h_u32, (jtag_callback_data_t)in);
jtag_add_dr_scan(3, fields, jtag_get_end_state());
jtag_add_callback(arm_le_to_h_u32, (jtag_callback_data_t)in);
static int arm9endianness(jtag_callback_data_t arg, jtag_callback_data_t size, jtag_callback_data_t be, jtag_callback_data_t captured)
{
static int arm9endianness(jtag_callback_data_t arg, jtag_callback_data_t size, jtag_callback_data_t be, jtag_callback_data_t captured)
{
- uint8_t *in=(uint8_t *)arg;
+ uint8_t *in = (uint8_t *)arg;
arm_endianness((uint8_t *)captured, in, (int)size, (int)be, 0);
return ERROR_OK;
}
arm_endianness((uint8_t *)captured, in, (int)size, (int)be, 0);
return ERROR_OK;
}
reg_cache_t **cache_p = register_get_last_cache_p(&target->reg_cache);
reg_cache_t *t;
/* one extra register (vector catch) */
reg_cache_t **cache_p = register_get_last_cache_p(&target->reg_cache);
reg_cache_t *t;
/* one extra register (vector catch) */
- t=embeddedice_build_reg_cache(target, arm7_9);
+ t = embeddedice_build_reg_cache(target, arm7_9);
if (t == NULL)
return ERROR_FAIL;
(*cache_p) = t;
if (t == NULL)
return ERROR_FAIL;
(*cache_p) = t;
}
target_set_examined(target);
}
}
target_set_examined(target);
}
- if ((retval=embeddedice_setup(target)) != ERROR_OK)
+ if ((retval = embeddedice_setup(target)) != ERROR_OK)
- if ((retval=arm7_9_setup(target)) != ERROR_OK)
+ if ((retval = arm7_9_setup(target)) != ERROR_OK)
return retval;
if (arm7_9->etm_ctx)
{
return retval;
if (arm7_9->etm_ctx)
{
- if ((retval=etm_setup(target)) != ERROR_OK)
+ if ((retval = etm_setup(target)) != ERROR_OK)
return retval;
}
return ERROR_OK;
return retval;
}
return ERROR_OK;
adi_jtag_dp_scan(swjdp, DAP_IR_DPACC, DP_RDBUFF, DPAP_READ, 0, invalue, &swjdp->ack);
}
adi_jtag_dp_scan(swjdp, DAP_IR_DPACC, DP_RDBUFF, DPAP_READ, 0, invalue, &swjdp->ack);
}
- /* In TRANS_MODE_ATOMIC all DAP_IR_APACC transactions wait for ack=OK/FAULT and the check CTRL_STAT */
+ /* In TRANS_MODE_ATOMIC all DAP_IR_APACC transactions wait for ack = OK/FAULT and the check CTRL_STAT */
if ((instr == DAP_IR_APACC) && (swjdp->trans_mode == TRANS_MODE_ATOMIC))
{
return swjdp_transaction_endcheck(swjdp);
if ((instr == DAP_IR_APACC) && (swjdp->trans_mode == TRANS_MODE_ATOMIC))
{
return swjdp_transaction_endcheck(swjdp);
adi_jtag_dp_scan_u32(swjdp, DAP_IR_DPACC, DP_RDBUFF, DPAP_READ, 0, invalue, &swjdp->ack);
}
adi_jtag_dp_scan_u32(swjdp, DAP_IR_DPACC, DP_RDBUFF, DPAP_READ, 0, invalue, &swjdp->ack);
}
- /* In TRANS_MODE_ATOMIC all DAP_IR_APACC transactions wait for ack=OK/FAULT and then check CTRL_STAT */
+ /* In TRANS_MODE_ATOMIC all DAP_IR_APACC transactions wait for ack = OK/FAULT and then check CTRL_STAT */
if ((instr == DAP_IR_APACC) && (swjdp->trans_mode == TRANS_MODE_ATOMIC))
{
return swjdp_transaction_endcheck(swjdp);
if ((instr == DAP_IR_APACC) && (swjdp->trans_mode == TRANS_MODE_ATOMIC))
{
return swjdp_transaction_endcheck(swjdp);
https://lists.berlios.de/pipermail/openocd-development/2008-September/003107.html
*/
https://lists.berlios.de/pipermail/openocd-development/2008-September/003107.html
*/
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
{
LOG_ERROR("BUG: Why does this fail the first time????");
}
{
LOG_ERROR("BUG: Why does this fail the first time????");
}
#endif
scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_READ, 0, &ctrlstat);
#endif
scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_READ, 0, &ctrlstat);
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
return retval;
swjdp->ack = swjdp->ack & 0x7;
if (swjdp->ack != 2)
{
return retval;
swjdp->ack = swjdp->ack & 0x7;
if (swjdp->ack != 2)
{
- long long then=timeval_ms();
+ long long then = timeval_ms();
while (swjdp->ack != 2)
{
if (swjdp->ack == 1)
while (swjdp->ack != 2)
{
if (swjdp->ack == 1)
}
scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_READ, 0, &ctrlstat);
}
scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_READ, 0, &ctrlstat);
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
return retval;
swjdp->ack = swjdp->ack & 0x7;
}
return retval;
swjdp->ack = swjdp->ack & 0x7;
}
/* Clear Sticky Error Bits */
scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_WRITE, swjdp->dp_ctrl_stat | SSTICKYORUN | SSTICKYERR, NULL);
scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_READ, 0, &ctrlstat);
/* Clear Sticky Error Bits */
scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_WRITE, swjdp->dp_ctrl_stat | SSTICKYORUN | SSTICKYERR, NULL);
scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_READ, 0, &ctrlstat);
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
return retval;
LOG_DEBUG("swjdp: status 0x%" PRIx32 "", ctrlstat);
dap_ap_read_reg_u32(swjdp, AP_REG_CSW, &mem_ap_csw);
dap_ap_read_reg_u32(swjdp, AP_REG_TAR, &mem_ap_tar);
return retval;
LOG_DEBUG("swjdp: status 0x%" PRIx32 "", ctrlstat);
dap_ap_read_reg_u32(swjdp, AP_REG_CSW, &mem_ap_csw);
dap_ap_read_reg_u32(swjdp, AP_REG_TAR, &mem_ap_tar);
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
return retval;
LOG_ERROR("Read MEM_AP_CSW 0x%" PRIx32 ", MEM_AP_TAR 0x%" PRIx32 "", mem_ap_csw, mem_ap_tar);
}
return retval;
LOG_ERROR("Read MEM_AP_CSW 0x%" PRIx32 ", MEM_AP_TAR 0x%" PRIx32 "", mem_ap_csw, mem_ap_tar);
}
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
return retval;
return ERROR_JTAG_DEVICE_ERROR;
}
return retval;
return ERROR_JTAG_DEVICE_ERROR;
}
dap_dp_write_reg(swjdp, swjdp->dp_ctrl_stat, DP_CTRL_STAT);
dap_dp_read_reg(swjdp, &ctrlstat, DP_CTRL_STAT);
dap_dp_write_reg(swjdp, swjdp->dp_ctrl_stat, DP_CTRL_STAT);
dap_dp_read_reg(swjdp, &ctrlstat, DP_CTRL_STAT);
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
return retval;
/* Check that we have debug power domains activated */
return retval;
/* Check that we have debug power domains activated */
{
LOG_DEBUG("swjdp: wait CDBGPWRUPACK");
dap_dp_read_reg(swjdp, &ctrlstat, DP_CTRL_STAT);
{
LOG_DEBUG("swjdp: wait CDBGPWRUPACK");
dap_dp_read_reg(swjdp, &ctrlstat, DP_CTRL_STAT);
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
return retval;
alive_sleep(10);
}
return retval;
alive_sleep(10);
}
{
LOG_DEBUG("swjdp: wait CSYSPWRUPACK");
dap_dp_read_reg(swjdp, &ctrlstat, DP_CTRL_STAT);
{
LOG_DEBUG("swjdp: wait CSYSPWRUPACK");
dap_dp_read_reg(swjdp, &ctrlstat, DP_CTRL_STAT);
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
return retval;
alive_sleep(10);
}
return retval;
alive_sleep(10);
}
/* use this as a static so we can inline it in -O3 and refer to it via a pointer */
static __inline__ void arm7flip32(jtag_callback_data_t arg)
{
/* use this as a static so we can inline it in -O3 and refer to it via a pointer */
static __inline__ void arm7flip32(jtag_callback_data_t arg)
{
- uint8_t *in=(uint8_t *)arg;
- *((uint32_t *)in)=flip_u32(le_to_h_u32(in), 32);
+ uint8_t *in = (uint8_t *)arg;
+ *((uint32_t *)in) = flip_u32(le_to_h_u32(in), 32);
}
static __inline__ void arm_le_to_h_u32(jtag_callback_data_t arg)
{
}
static __inline__ void arm_le_to_h_u32(jtag_callback_data_t arg)
{
- uint8_t *in=(uint8_t *)arg;
- *((uint32_t *)in)=le_to_h_u32(in);
+ uint8_t *in = (uint8_t *)arg;
+ *((uint32_t *)in) = le_to_h_u32(in);
}
if (target->state != TARGET_HALTED)
{
}
if (target->state != TARGET_HALTED)
{
- if ((retval=target_halt(target)) != ERROR_OK)
+ if ((retval = target_halt(target)) != ERROR_OK)
- if ((retval=target_wait_state(target, TARGET_HALTED, 500)) != ERROR_OK)
+ if ((retval = target_wait_state(target, TARGET_HALTED, 500)) != ERROR_OK)
return retval;
}
int retvaltemp;
return retval;
}
int retvaltemp;
- retval=run_it(target, exit_point, timeout_ms, arch_info);
+ retval = run_it(target, exit_point, timeout_ms, arch_info);
breakpoint_remove(target, exit_point);
breakpoint_remove(target, exit_point);
* Rn: base register
* List: for each bit in list: store register
* S: in priviledged mode: store user-mode registers
* Rn: base register
* List: for each bit in list: store register
* S: in priviledged mode: store user-mode registers
- * W=1: update the base register. W=0: leave the base register untouched
+ * W = 1: update the base register. W = 0: leave the base register untouched
*/
#define ARMV4_5_STMIA(Rn, List, S, W) (0xe8800000 | ((S) << 22) | ((W) << 21) | ((Rn) << 16) | (List))
*/
#define ARMV4_5_STMIA(Rn, List, S, W) (0xe8800000 | ((S) << 22) | ((W) << 21) | ((Rn) << 16) | (List))
* Rn: base register
* List: for each bit in list: store register
* S: in priviledged mode: store user-mode registers
* Rn: base register
* List: for each bit in list: store register
* S: in priviledged mode: store user-mode registers
- * W=1: update the base register. W=0: leave the base register untouched
+ * W = 1: update the base register. W = 0: leave the base register untouched
*/
#define ARMV4_5_LDMIA(Rn, List, S, W) (0xe8900000 | ((S) << 22) | ((W) << 21) | ((Rn) << 16) | (List))
*/
#define ARMV4_5_LDMIA(Rn, List, S, W) (0xe8900000 | ((S) << 22) | ((W) << 21) | ((Rn) << 16) | (List))
#define ARMV4_5_NOP (0xe1a08008)
/* Move PSR to general purpose register
#define ARMV4_5_NOP (0xe1a08008)
/* Move PSR to general purpose register
+ * R = 1: SPSR R = 0: CPSR
* Rn: target register
*/
#define ARMV4_5_MRS(Rn, R) (0xe10f0000 | ((R) << 22) | ((Rn) << 12))
* Rn: target register
*/
#define ARMV4_5_MRS(Rn, R) (0xe10f0000 | ((R) << 22) | ((Rn) << 12))
#define ARMV4_5_LDR(Rd, Rn) (0xe5900000 | ((Rd) << 12) | ((Rn) << 16))
/* Move general purpose register to PSR
#define ARMV4_5_LDR(Rd, Rn) (0xe5900000 | ((Rd) << 12) | ((Rn) << 16))
/* Move general purpose register to PSR
+ * R = 1: SPSR R = 0: CPSR
* Field: Field mask
* 1: control field 2: extension field 4: status field 8: flags field
* Rm: source register
* Field: Field mask
* 1: control field 2: extension field 4: status field 8: flags field
* Rm: source register
/* If the target fails to halt due to the breakpoint, force a halt */
if (retval != ERROR_OK || target->state != TARGET_HALTED)
{
/* If the target fails to halt due to the breakpoint, force a halt */
if (retval != ERROR_OK || target->state != TARGET_HALTED)
{
- if ((retval=target_halt(target)) != ERROR_OK)
+ if ((retval = target_halt(target)) != ERROR_OK)
- if ((retval=target_wait_state(target, TARGET_HALTED, 500)) != ERROR_OK)
+ if ((retval = target_wait_state(target, TARGET_HALTED, 500)) != ERROR_OK)
for (i = 0; i < num_mem_params; i++)
{
for (i = 0; i < num_mem_params; i++)
{
- if ((retval=target_write_buffer(target, mem_params[i].address, mem_params[i].size, mem_params[i].value)) != ERROR_OK)
+ if ((retval = target_write_buffer(target, mem_params[i].address, mem_params[i].size, mem_params[i].value)) != ERROR_OK)
-/* int irqstepcount=0; */
+/* int irqstepcount = 0; */
int cortex_m3_step(struct target_s *target, int current, uint32_t address, int handle_breakpoints)
{
/* get pointers to arch-specific information */
int cortex_m3_step(struct target_s *target, int current, uint32_t address, int handle_breakpoints)
{
/* get pointers to arch-specific information */
int cortex_m3_set_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
{
int retval;
int cortex_m3_set_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
{
int retval;
uint32_t hilo;
/* get pointers to arch-specific information */
uint32_t hilo;
/* get pointers to arch-specific information */
int cortex_m3_set_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
{
int cortex_m3_set_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
{
uint32_t mask, temp;
/* get pointers to arch-specific information */
uint32_t mask, temp;
/* get pointers to arch-specific information */
* in "thumb" mode, or an INVSTATE exception will occur. This is a
* hack to deal with the fact that gdb will sometimes "forge"
* return addresses, and doesn't set the LSB correctly (i.e., when
* in "thumb" mode, or an INVSTATE exception will occur. This is a
* hack to deal with the fact that gdb will sometimes "forge"
* return addresses, and doesn't set the LSB correctly (i.e., when
- * printing expressions containing function calls, it sets LR=0.) */
+ * printing expressions containing function calls, it sets LR = 0.) */
if (num == 14)
value |= 0x01;
if (num == 14)
value |= 0x01;
/* identify EmbeddedICE version by reading DCC control register */
embeddedice_read_reg(®_list[EICE_COMMS_CTRL]);
/* identify EmbeddedICE version by reading DCC control register */
embeddedice_read_reg(®_list[EICE_COMMS_CTRL]);
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
{
for (i = 0; i < num_regs; i++)
{
{
for (i = 0; i < num_regs; i++)
{
reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL];
embeddedice_read_reg(dbg_ctrl);
reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL];
embeddedice_read_reg(dbg_ctrl);
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
return retval;
buf_set_u32(dbg_ctrl->value, 4, 1, 0);
embeddedice_set_reg_w_exec(dbg_ctrl, dbg_ctrl->value);
return retval;
buf_set_u32(dbg_ctrl->value, 4, 1, 0);
embeddedice_set_reg_w_exec(dbg_ctrl, dbg_ctrl->value);
static void etb_getbuf(jtag_callback_data_t arg)
{
static void etb_getbuf(jtag_callback_data_t arg)
{
- uint8_t *in=(uint8_t *)arg;
- *((uint32_t *)in)=buf_get_u32(in, 0, 32);
+ uint8_t *in = (uint8_t *)arg;
+ *((uint32_t *)in) = buf_get_u32(in, 0, 32);
buf_set_u32(etm_ctrl_reg->value, 0, etm_ctrl_reg->size, etm_ctrl_value);
etm_store_reg(etm_ctrl_reg);
buf_set_u32(etm_ctrl_reg->value, 0, etm_ctrl_reg->size, etm_ctrl_value);
etm_store_reg(etm_ctrl_reg);
- if ((retval=jtag_execute_queue()) != ERROR_OK)
+ if ((retval = jtag_execute_queue()) != ERROR_OK)
- if ((retval=etm_ctx->capture_driver->init(etm_ctx)) != ERROR_OK)
+ if ((retval = etm_ctx->capture_driver->init(etm_ctx)) != ERROR_OK)
{
LOG_ERROR("ETM capture driver initialization failed");
return retval;
{
LOG_ERROR("ETM capture driver initialization failed");
return retval;
- for (i=0; etm_capture_drivers[i]; i++)
+ for (i = 0; etm_capture_drivers[i]; i++)
{
if (strcmp(args[4], etm_capture_drivers[i]->name) == 0)
{
int retval;
{
if (strcmp(args[4], etm_capture_drivers[i]->name) == 0)
{
int retval;
- if ((retval=etm_capture_drivers[i]->register_commands(cmd_ctx)) != ERROR_OK)
+ if ((retval = etm_capture_drivers[i]->register_commands(cmd_ctx)) != ERROR_OK)
{
free(etm_ctx);
return retval;
{
free(etm_ctx);
return retval;
- retval=ERROR_FILEIO_OPERATION_FAILED;
+ retval = ERROR_FILEIO_OPERATION_FAILED;
}
}
fileio_close(&fileio);
}
}
fileio_close(&fileio);
/* count useful segments (loadable), ignore BSS section */
image->num_sections = 0;
/* count useful segments (loadable), ignore BSS section */
image->num_sections = 0;
- for (i=0;i<elf->segment_count;i++)
+ for (i = 0;i<elf->segment_count;i++)
if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
image->num_sections++;
/* alloc and fill sections array with loadable segments */
image->sections = malloc(image->num_sections * sizeof(image_section_t));
if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
image->num_sections++;
/* alloc and fill sections array with loadable segments */
image->sections = malloc(image->num_sections * sizeof(image_section_t));
- for (i=0,j=0;i<elf->segment_count;i++)
+ for (i = 0,j = 0;i<elf->segment_count;i++)
{
if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
{
{
if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
{
- LOG_DEBUG("load segment %d at 0x%" PRIx32 " (sz=0x%" PRIx32 ")",section,offset,size);
+ LOG_DEBUG("load segment %d at 0x%" PRIx32 " (sz = 0x%" PRIx32 ")",section,offset,size);
/* read initialized data in current segment if any */
if (offset<field32(elf,segment->p_filesz))
/* read initialized data in current segment if any */
if (offset<field32(elf,segment->p_filesz))
{
/* relocate */
int section;
{
/* relocate */
int section;
- for (section=0; section < image->num_sections; section++)
+ for (section = 0; section < image->num_sections; section++)
{
image->sections[section].base_address += image->base_address;
}
/* we're done relocating. The two statements below are mainly
* for documenation purposes: stop anyone from empirically
* thinking they should use these values henceforth. */
{
image->sections[section].base_address += image->base_address;
}
/* we're done relocating. The two statements below are mainly
* for documenation purposes: stop anyone from empirically
* thinking they should use these values henceforth. */
- image->base_address=0;
- image->base_address_set=0;
+ image->base_address = 0;
+ image->base_address_set = 0;
}
nbytes -= run;
while (run--)
}
nbytes -= run;
while (run--)
- for (i=0; i<count; i++) {
+ for (i = 0; i<count; i++) {
if ((retval = ejtag_dma_read(ejtag_info, addr+i*sizeof(*buf), &buf[i])) != ERROR_OK)
return retval;
}
if ((retval = ejtag_dma_read(ejtag_info, addr+i*sizeof(*buf), &buf[i])) != ERROR_OK)
return retval;
}
- for (i=0; i<count; i++) {
+ for (i = 0; i<count; i++) {
if ((retval = ejtag_dma_read_h(ejtag_info, addr+i*sizeof(*buf), &buf[i])) != ERROR_OK)
return retval;
}
if ((retval = ejtag_dma_read_h(ejtag_info, addr+i*sizeof(*buf), &buf[i])) != ERROR_OK)
return retval;
}
- for (i=0; i<count; i++) {
+ for (i = 0; i<count; i++) {
if ((retval = ejtag_dma_read_b(ejtag_info, addr+i*sizeof(*buf), &buf[i])) != ERROR_OK)
return retval;
}
if ((retval = ejtag_dma_read_b(ejtag_info, addr+i*sizeof(*buf), &buf[i])) != ERROR_OK)
return retval;
}
- for (i=0; i<count; i++) {
+ for (i = 0; i<count; i++) {
if ((retval = ejtag_dma_write(ejtag_info, addr+i*sizeof(*buf), buf[i])) != ERROR_OK)
return retval;
}
if ((retval = ejtag_dma_write(ejtag_info, addr+i*sizeof(*buf), buf[i])) != ERROR_OK)
return retval;
}
- for (i=0; i<count; i++) {
+ for (i = 0; i<count; i++) {
if ((retval = ejtag_dma_write_h(ejtag_info, addr+i*sizeof(*buf), buf[i])) != ERROR_OK)
return retval;
}
if ((retval = ejtag_dma_write_h(ejtag_info, addr+i*sizeof(*buf), buf[i])) != ERROR_OK)
return retval;
}
- for (i=0; i<count; i++) {
+ for (i = 0; i<count; i++) {
if ((retval = ejtag_dma_write_b(ejtag_info, addr+i*sizeof(*buf), buf[i])) != ERROR_OK)
return retval;
}
if ((retval = ejtag_dma_write_b(ejtag_info, addr+i*sizeof(*buf), buf[i])) != ERROR_OK)
return retval;
}
MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)), /* $8 = MIPS32_PRACC_PARAM_IN */
MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)), /* $8 = MIPS32_PRACC_PARAM_IN */
MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
- MIPS32_LW(9,0,8), /* $9=mem[$8]; read addr */
- MIPS32_LW(10,4,8), /* $10=mem[$8+4]; read count */
- MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)), /* $11=MIPS32_PRACC_PARAM_OUT */
+ MIPS32_LW(9,0,8), /* $9 = mem[$8]; read addr */
+ MIPS32_LW(10,4,8), /* $10 = mem[$8+4]; read count */
+ MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)), /* $11 = MIPS32_PRACC_PARAM_OUT */
MIPS32_ORI(11,11,LOWER16(MIPS32_PRACC_PARAM_OUT)),
MIPS32_NOP,
/* loop: */
MIPS32_ORI(11,11,LOWER16(MIPS32_PRACC_PARAM_OUT)),
MIPS32_NOP,
/* loop: */
MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)), /* $8 = MIPS32_PRACC_PARAM_IN */
MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)), /* $8 = MIPS32_PRACC_PARAM_IN */
MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
- MIPS32_LW(9,0,8), /* $9=mem[$8]; read addr */
- MIPS32_LW(10,4,8), /* $10=mem[$8+4]; read count */
- MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)), /* $11=MIPS32_PRACC_PARAM_OUT */
+ MIPS32_LW(9,0,8), /* $9 = mem[$8]; read addr */
+ MIPS32_LW(10,4,8), /* $10 = mem[$8+4]; read count */
+ MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)), /* $11 = MIPS32_PRACC_PARAM_OUT */
MIPS32_ORI(11,11,LOWER16(MIPS32_PRACC_PARAM_OUT)),
MIPS32_NOP,
/* loop: */
MIPS32_ORI(11,11,LOWER16(MIPS32_PRACC_PARAM_OUT)),
MIPS32_NOP,
/* loop: */
MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)), /* $8 = MIPS32_PRACC_PARAM_IN */
MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)), /* $8 = MIPS32_PRACC_PARAM_IN */
MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
- MIPS32_LW(9,0,8), /* $9=mem[$8]; read addr */
- MIPS32_LW(10,4,8), /* $10=mem[$8+4]; read count */
- MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)), /* $11=MIPS32_PRACC_PARAM_OUT */
+ MIPS32_LW(9,0,8), /* $9 = mem[$8]; read addr */
+ MIPS32_LW(10,4,8), /* $10 = mem[$8+4]; read count */
+ MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)), /* $11 = MIPS32_PRACC_PARAM_OUT */
MIPS32_ORI(11,11,LOWER16(MIPS32_PRACC_PARAM_OUT)),
MIPS32_NOP,
/* loop: */
MIPS32_ORI(11,11,LOWER16(MIPS32_PRACC_PARAM_OUT)),
MIPS32_NOP,
/* loop: */
target->state = TARGET_RUNNING;
}
target->state = TARGET_RUNNING;
}
-// LOG_DEBUG("ctrl=0x%08X", ejtag_ctrl);
+// LOG_DEBUG("ctrl = 0x%08X", ejtag_ctrl);
if (target->state != TARGET_HALTED)
return ERROR_OK;
if (target->state != TARGET_HALTED)
return ERROR_OK;
- retval=target->type->arch_state(target);
+ retval = target->type->arch_state(target);
/* script procedures */
register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "profiling samples the CPU PC");
/* script procedures */
register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "profiling samples the CPU PC");
- register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array, "read memory and return as a TCL array for script processing <ARRAYNAME> <WIDTH=32/16/8> <ADDRESS> <COUNT>");
- register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values <ARRAYNAME> <WIDTH=32/16/8> <ADDRESS> <COUNT>");
+ register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array, "read memory and return as a TCL array for script processing <ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
+ register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values <ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
register_command(cmd_ctx, NULL, "fast_load_image", handle_fast_load_image_command, COMMAND_ANY,
"same args as load_image, image stored in memory - mainly for profiling purposes");
register_command(cmd_ctx, NULL, "fast_load_image", handle_fast_load_image_command, COMMAND_ANY,
"same args as load_image, image stored in memory - mainly for profiling purposes");
static int prevPowerdropout = 0;
int retval;
static int prevPowerdropout = 0;
int retval;
- if ((retval=jtag_power_dropout(&powerDropout)) != ERROR_OK)
+ if ((retval = jtag_power_dropout(&powerDropout)) != ERROR_OK)
return retval;
int powerRestored;
return retval;
int powerRestored;
- if ((retval=jtag_srst_asserted(&srstAsserted)) != ERROR_OK)
+ if ((retval = jtag_srst_asserted(&srstAsserted)) != ERROR_OK)
return retval;
int srstDeasserted;
return retval;
int srstDeasserted;
- runSrstAsserted=0;
- runSrstDeasserted=0;
- runPowerRestore=0;
- runPowerDropout=0;
+ runSrstAsserted = 0;
+ runSrstDeasserted = 0;
+ runPowerRestore = 0;
+ runPowerDropout = 0;
int target_wait_state(target_t *target, enum target_state state, int ms)
{
int retval;
int target_wait_state(target_t *target, enum target_state state, int ms)
{
int retval;
- long long then=0, cur;
- int once=1;
+ long long then = 0, cur;
+ int once = 1;
- if ((retval=target_poll(target)) != ERROR_OK)
+ if ((retval = target_poll(target)) != ERROR_OK)
return retval;
if (target->state == state)
{
return retval;
if (target->state == state)
{
cur = timeval_ms();
if (once)
{
cur = timeval_ms();
if (once)
{
then = timeval_ms();
LOG_DEBUG("waiting for target %s...",
Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
then = timeval_ms();
LOG_DEBUG("waiting for target %s...",
Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
(unsigned)(address + (i*size)));
}
(unsigned)(address + (i*size)));
}
const uint8_t *value_ptr = buffer + i * size;
switch (size) {
case 4: value = target_buffer_get_u32(target, value_ptr); break;
const uint8_t *value_ptr = buffer + i * size;
switch (size) {
case 4: value = target_buffer_get_u32(target, value_ptr); break;
- uint32_t offset=0;
- uint32_t length=buf_cnt;
+ uint32_t offset = 0;
+ uint32_t length = buf_cnt;
/* DANGER!!! beware of unsigned comparision here!!! */
/* DANGER!!! beware of unsigned comparision here!!! */
image.start_address_set = 0;
image.start_address_set = 0;
- if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
+ if ((retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
{
return retval;
}
image_size = 0x0;
{
return retval;
}
image_size = 0x0;
for (i = 0; i < image.num_sections; i++)
{
buffer = malloc(image.sections[i].size);
for (i = 0; i < image.num_sections; i++)
{
buffer = malloc(image.sections[i].size);
buffer[t]);
free(data);
free(buffer);
buffer[t]);
free(data);
free(buffer);
goto done;
}
if ((t%16384) == 0)
goto done;
}
if ((t%16384) == 0)
static void writeLong(FILE *f, int l)
{
int i;
static void writeLong(FILE *f, int l)
{
int i;
- char c=(l >> (i*8))&0xff;
+ char c = (l >> (i*8))&0xff;
static void writeGmon(uint32_t *samples, uint32_t sampleNum, char *filename)
{
uint32_t i;
static void writeGmon(uint32_t *samples, uint32_t sampleNum, char *filename)
{
uint32_t i;
- FILE *f=fopen(filename, "w");
+ FILE *f = fopen(filename, "w");
if (f == NULL)
return;
writeString(f, "gmon");
if (f == NULL)
return;
writeString(f, "gmon");
writeData(f, &zero, 1);
/* figure out bucket size */
writeData(f, &zero, 1);
/* figure out bucket size */
- uint32_t min=samples[0];
- uint32_t max=samples[0];
- for (i=0; i<sampleNum; i++)
+ uint32_t min = samples[0];
+ uint32_t max = samples[0];
+ for (i = 0; i<sampleNum; i++)
- int addressSpace=(max-min+1);
+ int addressSpace = (max-min+1);
static const uint32_t maxBuckets = 256 * 1024; /* maximum buckets. */
uint32_t length = addressSpace;
if (length > maxBuckets)
{
static const uint32_t maxBuckets = 256 * 1024; /* maximum buckets. */
uint32_t length = addressSpace;
if (length > maxBuckets)
{
- int *buckets=malloc(sizeof(int)*length);
+ int *buckets = malloc(sizeof(int)*length);
if (buckets == NULL)
{
fclose(f);
return;
}
memset(buckets, 0, sizeof(int)*length);
if (buckets == NULL)
{
fclose(f);
return;
}
memset(buckets, 0, sizeof(int)*length);
- for (i=0; i<sampleNum;i++)
+ for (i = 0; i<sampleNum;i++)
- uint32_t address=samples[i];
- long long a=address-min;
- long long b=length-1;
- long long c=addressSpace-1;
- int index=(a*b)/c; /* danger!!!! int32 overflows */
+ uint32_t address = samples[i];
+ long long a = address-min;
+ long long b = length-1;
+ long long c = addressSpace-1;
+ int index = (a*b)/c; /* danger!!!! int32 overflows */
writeLong(f, length); /* # of samples */
writeLong(f, 64000000); /* 64MHz */
writeString(f, "seconds");
writeLong(f, length); /* # of samples */
writeLong(f, 64000000); /* 64MHz */
writeString(f, "seconds");
- for (i=0; i<(15-strlen("seconds")); i++)
+ for (i = 0; i<(15-strlen("seconds")); i++)
writeData(f, &zero, 1);
writeString(f, "s");
/*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
writeData(f, &zero, 1);
writeString(f, "s");
/*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
- char *data=malloc(2*length);
+ char *data = malloc(2*length);
- for (i=0; i<length;i++)
+ for (i = 0; i<length;i++)
}
data[i*2]=val&0xff;
data[i*2+1]=(val >> 8)&0xff;
}
data[i*2]=val&0xff;
data[i*2+1]=(val >> 8)&0xff;
command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
- static const int maxSample=10000;
- uint32_t *samples=malloc(sizeof(uint32_t)*maxSample);
+ static const int maxSample = 10000;
+ uint32_t *samples = malloc(sizeof(uint32_t)*maxSample);
if (samples == NULL)
return ERROR_OK;
if (samples == NULL)
return ERROR_OK;
/* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
/* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
} else
{
command_print(cmd_ctx, "Target not halted or running");
} else
{
command_print(cmd_ctx, "Target not halted or running");
break;
}
if (retval != ERROR_OK)
break;
}
if (retval != ERROR_OK)
if (target->tap == NULL)
{
Jim_SetResultString( interp, "-chain-position required when creating target", -1);
if (target->tap == NULL)
{
Jim_SetResultString( interp, "-chain-position required when creating target", -1);
if (fastload != NULL)
{
int i;
if (fastload != NULL)
{
int i;
- for (i=0; i<fastload_num; i++)
+ for (i = 0; i<fastload_num; i++)
{
if (fastload[i].data)
free(fastload[i].data);
}
free(fastload);
{
if (fastload[i].data)
free(fastload[i].data);
}
free(fastload);
uint8_t *buffer;
uint32_t buf_cnt;
uint32_t image_size;
uint8_t *buffer;
uint32_t buf_cnt;
uint32_t image_size;
- uint32_t min_address=0;
- uint32_t max_address=0xffffffff;
+ uint32_t min_address = 0;
+ uint32_t max_address = 0xffffffff;
image_size = 0x0;
retval = ERROR_OK;
image_size = 0x0;
retval = ERROR_OK;
- fastload_num=image.num_sections;
- fastload=(struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
+ fastload_num = image.num_sections;
+ fastload = (struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
if (fastload == NULL)
{
image_close(&image);
if (fastload == NULL)
{
image_close(&image);
- uint32_t offset=0;
- uint32_t length=buf_cnt;
+ uint32_t offset = 0;
+ uint32_t length = buf_cnt;
/* DANGER!!! beware of unsigned comparision here!!! */
/* DANGER!!! beware of unsigned comparision here!!! */
length -= (image.sections[i].base_address+buf_cnt)-max_address;
}
length -= (image.sections[i].base_address+buf_cnt)-max_address;
}
- fastload[i].address=image.sections[i].base_address+offset;
- fastload[i].data=malloc(length);
+ fastload[i].address = image.sections[i].base_address+offset;
+ fastload[i].data = malloc(length);
if (fastload[i].data == NULL)
{
free(buffer);
break;
}
memcpy(fastload[i].data, buffer+offset, length);
if (fastload[i].data == NULL)
{
free(buffer);
break;
}
memcpy(fastload[i].data, buffer+offset, length);
- fastload[i].length=length;
+ fastload[i].length = length;
image_size += length;
command_print(cmd_ctx, "%u byte written at address 0x%8.8x",
image_size += length;
command_print(cmd_ctx, "%u byte written at address 0x%8.8x",
return ERROR_FAIL;
}
int i;
return ERROR_FAIL;
}
int i;
- int ms=timeval_ms();
- int size=0;
- int retval=ERROR_OK;
- for (i=0; i<fastload_num;i++)
+ int ms = timeval_ms();
+ int size = 0;
+ int retval = ERROR_OK;
+ for (i = 0; i<fastload_num;i++)
{
target_t *target = get_current_target(cmd_ctx);
command_print(cmd_ctx, "Write to 0x%08x, length 0x%08x",
{
target_t *target = get_current_target(cmd_ctx);
command_print(cmd_ctx, "Write to 0x%08x, length 0x%08x",
}
size += fastload[i].length;
}
}
size += fastload[i].length;
}
- int after=timeval_ms();
+ int after = timeval_ms();
command_print(cmd_ctx, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
return retval;
}
command_print(cmd_ctx, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
return retval;
}
- TARGET_ENDIAN_UNKNOWN=0,
+ TARGET_ENDIAN_UNKNOWN = 0,
TARGET_BIG_ENDIAN = 1, TARGET_LITTLE_ENDIAN = 2
};
TARGET_BIG_ENDIAN = 1, TARGET_LITTLE_ENDIAN = 2
};
static void xscale_getbuf(jtag_callback_data_t arg)
{
static void xscale_getbuf(jtag_callback_data_t arg)
{
- uint8_t *in=(uint8_t *)arg;
- *((uint32_t *)in)=buf_get_u32(in, 0, 32);
+ uint8_t *in = (uint8_t *)arg;
+ *((uint32_t *)in) = buf_get_u32(in, 0, 32);
}
int xscale_receive(target_t *target, uint32_t *buffer, int num_words)
}
int xscale_receive(target_t *target, uint32_t *buffer, int num_words)
if (num_words == 0)
return ERROR_INVALID_ARGUMENTS;
if (num_words == 0)
return ERROR_INVALID_ARGUMENTS;
armv4_5_common_t *armv4_5 = target->arch_info;
xscale_common_t *xscale = armv4_5->arch_info;
armv4_5_common_t *armv4_5 = target->arch_info;
xscale_common_t *xscale = armv4_5->arch_info;
jtag_add_runtest(1, jtag_get_end_state()); /* ensures that we're in the TAP_IDLE state as the above could be a no-op */
/* repeat until all words have been collected */
jtag_add_runtest(1, jtag_get_end_state()); /* ensures that we're in the TAP_IDLE state as the above could be a no-op */
/* repeat until all words have been collected */
while (words_done < num_words)
{
/* schedule reads */
while (words_done < num_words)
{
/* schedule reads */
if (attempts++==1000)
{
LOG_ERROR("Failed to receiving data from debug handler after 1000 attempts");
if (attempts++==1000)
{
LOG_ERROR("Failed to receiving data from debug handler after 1000 attempts");
- retval=ERROR_TARGET_TIMEOUT;
+ retval = ERROR_TARGET_TIMEOUT;
- retval=target_read_u32(target, 0xffff0000 + 4*i, &xscale->high_vectors[i]);
+ retval = target_read_u32(target, 0xffff0000 + 4*i, &xscale->high_vectors[i]);
if (retval == ERROR_TARGET_TIMEOUT)
return retval;
if (retval != ERROR_OK)
if (retval == ERROR_TARGET_TIMEOUT)
return retval;
if (retval != ERROR_OK)
- retval=target_read_u32(target, 0x0 + 4*i, &xscale->low_vectors[i]);
+ retval = target_read_u32(target, 0x0 + 4*i, &xscale->low_vectors[i]);
if (retval == ERROR_TARGET_TIMEOUT)
return retval;
if (retval != ERROR_OK)
if (retval == ERROR_TARGET_TIMEOUT)
return retval;
if (retval != ERROR_OK)
int xscale_poll(target_t *target)
{
int xscale_poll(target_t *target)
{
armv4_5_common_t *armv4_5 = target->arch_info;
xscale_common_t *xscale = armv4_5->arch_info;
armv4_5_common_t *armv4_5 = target->arch_info;
xscale_common_t *xscale = armv4_5->arch_info;
/* clear external dbg break (will be written on next DCSR read) */
xscale->external_debug_break = 0;
/* clear external dbg break (will be written on next DCSR read) */
xscale->external_debug_break = 0;
- if ((retval=xscale_read_dcsr(target)) != ERROR_OK)
+ if ((retval = xscale_read_dcsr(target)) != ERROR_OK)
return retval;
/* get r0, pc, r1 to r7 and cpsr */
return retval;
/* get r0, pc, r1 to r7 and cpsr */
- if ((retval=xscale_receive(target, buffer, 10)) != ERROR_OK)
+ if ((retval = xscale_receive(target, buffer, 10)) != ERROR_OK)
return retval;
/* move r0 from buffer to register cache */
return retval;
/* move r0 from buffer to register cache */
- if ((retval=xscale_set_reg_u32(ibcr0, next_pc | 0x1)) != ERROR_OK)
+ if ((retval = xscale_set_reg_u32(ibcr0, next_pc | 0x1)) != ERROR_OK)
return retval;
return ERROR_OK;
return retval;
return ERROR_OK;
reg_t *ibcr0 = &xscale->reg_cache->reg_list[XSCALE_IBCR0];
int retval;
reg_t *ibcr0 = &xscale->reg_cache->reg_list[XSCALE_IBCR0];
int retval;
- if ((retval=xscale_set_reg_u32(ibcr0, 0x0)) != ERROR_OK)
+ if ((retval = xscale_set_reg_u32(ibcr0, 0x0)) != ERROR_OK)
return retval;
return ERROR_OK;
return retval;
return ERROR_OK;
}
/* update vector tables */
}
/* update vector tables */
- if ((retval=xscale_update_vectors(target)) != ERROR_OK)
+ if ((retval = xscale_update_vectors(target)) != ERROR_OK)
return retval;
/* current = 1: continue on current pc, otherwise continue at <address> */
return retval;
/* current = 1: continue on current pc, otherwise continue at <address> */
}
LOG_DEBUG("enable single-step");
}
LOG_DEBUG("enable single-step");
- if ((retval=xscale_enable_single_step(target, next_pc)) != ERROR_OK)
+ if ((retval = xscale_enable_single_step(target, next_pc)) != ERROR_OK)
return retval;
/* restore banked registers */
return retval;
/* restore banked registers */
- if ((retval=xscale_restore_context(target)) != ERROR_OK)
+ if ((retval = xscale_restore_context(target)) != ERROR_OK)
return retval;
/* send resume request (command 0x30 or 0x31)
* clean the trace buffer if it is to be enabled (0x62) */
if (xscale->trace.buffer_enabled)
{
return retval;
/* send resume request (command 0x30 or 0x31)
* clean the trace buffer if it is to be enabled (0x62) */
if (xscale->trace.buffer_enabled)
{
- if ((retval=xscale_send_u32(target, 0x62)) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, 0x62)) != ERROR_OK)
- if ((retval=xscale_send_u32(target, 0x31)) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, 0x31)) != ERROR_OK)
- if ((retval=xscale_send_u32(target, 0x30)) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, 0x30)) != ERROR_OK)
return retval;
/* send CPSR */
return retval;
/* send CPSR */
- if ((retval=xscale_send_u32(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 32))) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 32))) != ERROR_OK)
return retval;
LOG_DEBUG("writing cpsr with value 0x%8.8" PRIx32 "", buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 32));
for (i = 7; i >= 0; i--)
{
/* send register */
return retval;
LOG_DEBUG("writing cpsr with value 0x%8.8" PRIx32 "", buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 32));
for (i = 7; i >= 0; i--)
{
/* send register */
- if ((retval=xscale_send_u32(target, buf_get_u32(armv4_5->core_cache->reg_list[i].value, 0, 32))) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, buf_get_u32(armv4_5->core_cache->reg_list[i].value, 0, 32))) != ERROR_OK)
return retval;
LOG_DEBUG("writing r%i with value 0x%8.8" PRIx32 "", i, buf_get_u32(armv4_5->core_cache->reg_list[i].value, 0, 32));
}
/* send PC */
return retval;
LOG_DEBUG("writing r%i with value 0x%8.8" PRIx32 "", i, buf_get_u32(armv4_5->core_cache->reg_list[i].value, 0, 32));
}
/* send PC */
- if ((retval=xscale_send_u32(target, buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32))) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32))) != ERROR_OK)
return retval;
LOG_DEBUG("writing PC with value 0x%8.8" PRIx32, buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32));
target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
/* registers are now invalid */
return retval;
LOG_DEBUG("writing PC with value 0x%8.8" PRIx32, buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32));
target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
/* registers are now invalid */
- if ((retval=armv4_5_invalidate_core_regs(target)) != ERROR_OK)
+ if ((retval = armv4_5_invalidate_core_regs(target)) != ERROR_OK)
return retval;
/* wait for and process debug entry */
return retval;
/* wait for and process debug entry */
- if ((retval=xscale_debug_entry(target)) != ERROR_OK)
+ if ((retval = xscale_debug_entry(target)) != ERROR_OK)
return retval;
LOG_DEBUG("disable single-step");
return retval;
LOG_DEBUG("disable single-step");
- if ((retval=xscale_disable_single_step(target)) != ERROR_OK)
+ if ((retval = xscale_disable_single_step(target)) != ERROR_OK)
return retval;
target_call_event_callbacks(target, TARGET_EVENT_HALTED);
return retval;
target_call_event_callbacks(target, TARGET_EVENT_HALTED);
/* if we're at the reset vector, we have to simulate the step */
if (current_pc == 0x0)
{
/* if we're at the reset vector, we have to simulate the step */
if (current_pc == 0x0)
{
- if ((retval=arm_simulate_step(target, NULL)) != ERROR_OK)
+ if ((retval = arm_simulate_step(target, NULL)) != ERROR_OK)
return retval;
current_pc = buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32);
return retval;
current_pc = buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32);
if (handle_breakpoints)
if ((breakpoint = breakpoint_find(target, buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32))))
{
if (handle_breakpoints)
if ((breakpoint = breakpoint_find(target, buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32))))
{
- if ((retval=xscale_unset_breakpoint(target, breakpoint)) != ERROR_OK)
+ if ((retval = xscale_unset_breakpoint(target, breakpoint)) != ERROR_OK)
return ERROR_TARGET_UNALIGNED_ACCESS;
/* send memory read request (command 0x1n, n: access size) */
return ERROR_TARGET_UNALIGNED_ACCESS;
/* send memory read request (command 0x1n, n: access size) */
- if ((retval=xscale_send_u32(target, 0x10 | size)) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, 0x10 | size)) != ERROR_OK)
return retval;
/* send base address for read request */
return retval;
/* send base address for read request */
- if ((retval=xscale_send_u32(target, address)) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, address)) != ERROR_OK)
return retval;
/* send number of requested data words */
return retval;
/* send number of requested data words */
- if ((retval=xscale_send_u32(target, count)) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, count)) != ERROR_OK)
return retval;
/* receive data from target (count times 32-bit words in host endianness) */
buf32 = malloc(4 * count);
return retval;
/* receive data from target (count times 32-bit words in host endianness) */
buf32 = malloc(4 * count);
- if ((retval=xscale_receive(target, buf32, count)) != ERROR_OK)
+ if ((retval = xscale_receive(target, buf32, count)) != ERROR_OK)
return retval;
/* extract data from host-endian buffer into byte stream */
return retval;
/* extract data from host-endian buffer into byte stream */
free(buf32);
/* examine DCSR, to see if Sticky Abort (SA) got set */
free(buf32);
/* examine DCSR, to see if Sticky Abort (SA) got set */
- if ((retval=xscale_read_dcsr(target)) != ERROR_OK)
+ if ((retval = xscale_read_dcsr(target)) != ERROR_OK)
return retval;
if (buf_get_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 5, 1) == 1)
{
/* clear SA bit */
return retval;
if (buf_get_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 5, 1) == 1)
{
/* clear SA bit */
- if ((retval=xscale_send_u32(target, 0x60)) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, 0x60)) != ERROR_OK)
return retval;
return ERROR_TARGET_DATA_ABORT;
return retval;
return ERROR_TARGET_DATA_ABORT;
return ERROR_TARGET_UNALIGNED_ACCESS;
/* send memory write request (command 0x2n, n: access size) */
return ERROR_TARGET_UNALIGNED_ACCESS;
/* send memory write request (command 0x2n, n: access size) */
- if ((retval=xscale_send_u32(target, 0x20 | size)) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, 0x20 | size)) != ERROR_OK)
return retval;
/* send base address for read request */
return retval;
/* send base address for read request */
- if ((retval=xscale_send_u32(target, address)) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, address)) != ERROR_OK)
return retval;
/* send number of requested data words to be written*/
return retval;
/* send number of requested data words to be written*/
- if ((retval=xscale_send_u32(target, count)) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, count)) != ERROR_OK)
return retval;
/* extract data from host-endian buffer into byte stream */
return retval;
/* extract data from host-endian buffer into byte stream */
- if ((retval=xscale_send(target, buffer, count, size)) != ERROR_OK)
+ if ((retval = xscale_send(target, buffer, count, size)) != ERROR_OK)
return retval;
/* examine DCSR, to see if Sticky Abort (SA) got set */
return retval;
/* examine DCSR, to see if Sticky Abort (SA) got set */
- if ((retval=xscale_read_dcsr(target)) != ERROR_OK)
+ if ((retval = xscale_read_dcsr(target)) != ERROR_OK)
return retval;
if (buf_get_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 5, 1) == 1)
{
/* clear SA bit */
return retval;
if (buf_get_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 5, 1) == 1)
{
/* clear SA bit */
- if ((retval=xscale_send_u32(target, 0x60)) != ERROR_OK)
+ if ((retval = xscale_send_u32(target, 0x60)) != ERROR_OK)
return retval;
return ERROR_TARGET_DATA_ABORT;
return retval;
return ERROR_TARGET_DATA_ABORT;
{
armv4_5_common_t *armv4_5 = target->arch_info;
xscale_common_t *xscale = armv4_5->arch_info;
{
armv4_5_common_t *armv4_5 = target->arch_info;
xscale_common_t *xscale = armv4_5->arch_info;
reg_t *dbcon = &xscale->reg_cache->reg_list[XSCALE_DBCON];
uint32_t dbcon_value = buf_get_u32(dbcon->value, 0, 32);
reg_t *dbcon = &xscale->reg_cache->reg_list[XSCALE_DBCON];
uint32_t dbcon_value = buf_get_u32(dbcon->value, 0, 32);
LOG_DEBUG("%s %d", op_name, xsdrsize);
LOG_DEBUG("%s %d", op_name, xsdrsize);
- for ( attempt=0; attempt<limit; ++attempt )
+ for ( attempt = 0; attempt<limit; ++attempt )
if (limit < 1)
limit = 1;
if (limit < 1)
limit = 1;
- for ( attempt=0; attempt<limit; ++attempt )
+ for ( attempt = 0; attempt<limit; ++attempt )
monitor reg pc 0x20002000
stepi
monitor reg pc 0x20002000
stepi
-arm-elf-gcc -mthumb -mcpu=cortex-m3 -nostdlib -Ttest.ld test.c
+arm-elf-gcc -mthumb -mcpu = cortex-m3 -nostdlib -Ttest.ld test.c
+ for (i = 0; i<1000; i++)
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)