struct avr32_ap7k_common *ap7k = calloc(1, sizeof(struct
avr32_ap7k_common));
- ap7k->common_magic = AP7k_COMMON_MAGIC;
+ ap7k->common_magic = AP7K_COMMON_MAGIC;
target->arch_info = ap7k;
return ERROR_OK;
struct target;
-#define AP7k_COMMON_MAGIC 0x4150374b
+#define AP7K_COMMON_MAGIC 0x4150374b
struct avr32_ap7k_common {
int common_magic;
struct avr32_jtag jtag;
/*
* OBCR Register bit definitions
*/
-#define OBCR_b0_and_b1 ((0x0) << 10)
-#define OBCR_b0_or_b1 ((0x1) << 10)
-#define OBCR_b1_after_b0 ((0x2) << 10)
-#define OBCR_b0_after_b1 ((0x3) << 10)
+#define OBCR_B0_AND_B1 ((0x0) << 10)
+#define OBCR_B0_OR_B1 ((0x1) << 10)
+#define OBCR_B1_AFTER_B0 ((0x2) << 10)
+#define OBCR_B0_AFTER_B1 ((0x3) << 10)
#define OBCR_BP_DISABLED (0x0)
#define OBCR_BP_MEM_P (0x1)
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
}
-static int dsp563xx_add_custom_watchpoint(struct target *target, uint32_t address, uint32_t memType,
+static int dsp563xx_add_custom_watchpoint(struct target *target, uint32_t address, uint32_t mem_type,
enum watchpoint_rw rw, enum watchpoint_condition cond)
{
int err = ERROR_OK;
struct dsp563xx_common *dsp563xx = target_to_dsp563xx(target);
- bool wasRunning = false;
+ bool was_running = false;
/* Only set breakpoint when halted */
if (target->state != TARGET_HALTED) {
dsp563xx_halt(target);
- wasRunning = true;
+ was_running = true;
}
if (dsp563xx->hardware_breakpoint[0].used) {
uint32_t obcr_value = 0;
if (err == ERROR_OK) {
- obcr_value |= OBCR_b0_or_b1;
- switch (memType) {
+ obcr_value |= OBCR_B0_OR_B1;
+ switch (mem_type) {
case MEM_X:
obcr_value |= OBCR_BP_MEM_X;
break;
obcr_value |= OBCR_BP_MEM_P;
break;
default:
- LOG_ERROR("Unknown memType parameter (%" PRIu32 ")", memType);
+ LOG_ERROR("Unknown mem_type parameter (%" PRIu32 ")", mem_type);
err = ERROR_TARGET_INVALID;
}
}
if (err == ERROR_OK)
dsp563xx->hardware_breakpoint[0].used = BPU_WATCHPOINT;
- if (err == ERROR_OK && wasRunning) {
+ if (err == ERROR_OK && was_running) {
/* Resume from current PC */
err = dsp563xx_resume(target, 1, 0x0, 0, 0);
}
return retval;
}
-static int eonce_load_TX_RX_to_r0(struct target *target)
+static int eonce_load_tx_rx_to_r0(struct target *target)
{
int retval;
return retval;
}
-static int core_load_TX_RX_high_addr_to_r0(struct target *target)
+static int core_load_tx_rx_high_addr_to_r0(struct target *target)
{
int retval = 0;
err_check_propagate(retval);
retval = core_move_r4_to_y(target);
err_check_propagate(retval);
- retval = eonce_load_TX_RX_to_r0(target);
+ retval = eonce_load_tx_rx_to_r0(target);
err_check_propagate(retval);
retval = core_move_y0_at_r0(target);
err_check_propagate(retval);
else
retval = core_move_at_r0_to_y0(target);
err_check_propagate(retval);
- retval = eonce_load_TX_RX_to_r0(target);
+ retval = eonce_load_tx_rx_to_r0(target);
err_check_propagate(retval);
retval = core_move_y0_at_r0(target);
err_check_propagate(retval);
err_check_propagate(retval);
}
/* Get lower part of data to TX/RX */
- retval = eonce_load_TX_RX_to_r0(target);
+ retval = eonce_load_tx_rx_to_r0(target);
err_check_propagate(retval);
retval = core_move_y0_at_r0_inc(target); /* This also load TX/RX high to r0 */
err_check_propagate(retval);
*
* @return
*/
-static int dsp5680xx_f_SIM_reset(struct target *target)
+static int dsp5680xx_f_sim_reset(struct target *target)
{
int retval = ERROR_OK;
retval = dsp5680xx_halt(target);
err_check_propagate(retval);
- retval = dsp5680xx_f_SIM_reset(target);
+ retval = dsp5680xx_f_sim_reset(target);
err_check_propagate(retval);
return retval;
}
uint32_t command = c;
int retval;
- retval = core_load_TX_RX_high_addr_to_r0(target);
+ retval = core_load_tx_rx_high_addr_to_r0(target);
err_check_propagate(retval);
retval = core_move_long_to_r2(target, HFM_BASE_ADDR);
err_check_propagate(retval);
retval = core_move_long_to_r2(target, HFM_BASE_ADDR);
err_check_propagate(retval);
- retval = core_load_TX_RX_high_addr_to_r0(target);
+ retval = core_load_tx_rx_high_addr_to_r0(target);
err_check_propagate(retval);
/* read HFM_CLKD */
retval = core_move_at_r2_to_y0(target);
* Reset SIM
*
*/
- retval = dsp5680xx_f_SIM_reset(target);
+ retval = dsp5680xx_f_sim_reset(target);
err_check_propagate(retval);
/*
* Set hfmdiv
retval = core_move_long_to_r3(target, address); /* Destination address to r3 */
err_check_propagate(retval);
- core_load_TX_RX_high_addr_to_r0(target); /* TX/RX reg address to r0 */
+ core_load_tx_rx_high_addr_to_r0(target); /* TX/RX reg address to r0 */
err_check_propagate(retval);
retval = core_move_long_to_r2(target, HFM_BASE_ADDR); /* FM base address to r2 */
err_check_propagate(retval);
* ----------------------------------------------------------------
*/
#define MC568013_SIM_BASE_ADDR 0xF140
-#define MC56803x_2x_SIM_BASE_ADDR 0xF100
+#define MC56803X_2X_SIM_BASE_ADDR 0xF100
#define SIM_CMD_RESET 0x10
/**
[EID_SYSTEM_CALL] = "SystemCall",
[EID_MEMORY_MANAGEMENT] = "MemoryManagement",
[EID_UNRECOVERABLE] = "Unrecoverable",
- [EID_INTERRUPTn+0] = "Interrupt0",
- [EID_INTERRUPTn+1] = "Interrupt1",
- [EID_INTERRUPTn+2] = "Interrupt2",
- [EID_INTERRUPTn+3] = "Interrupt3",
- [EID_INTERRUPTn+4] = "Interrupt4",
- [EID_INTERRUPTn+5] = "Interrupt5",
- [EID_INTERRUPTn+6] = "Interrupt6",
- [EID_INTERRUPTn+7] = "Interrupt7",
- [EID_INTERRUPTn+8] = "Interrupt8",
- [EID_INTERRUPTn+9] = "Interrupt9",
- [EID_INTERRUPTn+10] = "Interrupt10",
- [EID_INTERRUPTn+11] = "Interrupt11",
- [EID_INTERRUPTn+12] = "Interrupt12",
- [EID_INTERRUPTn+13] = "Interrupt13",
- [EID_INTERRUPTn+14] = "Interrupt14",
- [EID_INTERRUPTn+15] = "Interrupt15",
- [EID_INTERRUPTn+16] = "Interrupt16",
- [EID_INTERRUPTn+17] = "Interrupt17",
- [EID_INTERRUPTn+18] = "Interrupt18",
- [EID_INTERRUPTn+19] = "Interrupt19",
- [EID_INTERRUPTn+20] = "Interrupt20",
- [EID_INTERRUPTn+21] = "Interrupt21",
- [EID_INTERRUPTn+22] = "Interrupt22",
- [EID_INTERRUPTn+23] = "Interrupt23",
- [EID_INTERRUPTn+24] = "Interrupt24",
- [EID_INTERRUPTn+25] = "Interrupt25",
- [EID_INTERRUPTn+26] = "Interrupt26",
- [EID_INTERRUPTn+27] = "Interrupt27",
- [EID_INTERRUPTn+28] = "Interrupt28",
- [EID_INTERRUPTn+29] = "Interrupt29",
- [EID_INTERRUPTn+30] = "Interrupt30",
- [EID_INTERRUPTn+31] = "Interrupt31",
+ [EID_INTERRUPT_N+0] = "Interrupt0",
+ [EID_INTERRUPT_N+1] = "Interrupt1",
+ [EID_INTERRUPT_N+2] = "Interrupt2",
+ [EID_INTERRUPT_N+3] = "Interrupt3",
+ [EID_INTERRUPT_N+4] = "Interrupt4",
+ [EID_INTERRUPT_N+5] = "Interrupt5",
+ [EID_INTERRUPT_N+6] = "Interrupt6",
+ [EID_INTERRUPT_N+7] = "Interrupt7",
+ [EID_INTERRUPT_N+8] = "Interrupt8",
+ [EID_INTERRUPT_N+9] = "Interrupt9",
+ [EID_INTERRUPT_N+10] = "Interrupt10",
+ [EID_INTERRUPT_N+11] = "Interrupt11",
+ [EID_INTERRUPT_N+12] = "Interrupt12",
+ [EID_INTERRUPT_N+13] = "Interrupt13",
+ [EID_INTERRUPT_N+14] = "Interrupt14",
+ [EID_INTERRUPT_N+15] = "Interrupt15",
+ [EID_INTERRUPT_N+16] = "Interrupt16",
+ [EID_INTERRUPT_N+17] = "Interrupt17",
+ [EID_INTERRUPT_N+18] = "Interrupt18",
+ [EID_INTERRUPT_N+19] = "Interrupt19",
+ [EID_INTERRUPT_N+20] = "Interrupt20",
+ [EID_INTERRUPT_N+21] = "Interrupt21",
+ [EID_INTERRUPT_N+22] = "Interrupt22",
+ [EID_INTERRUPT_N+23] = "Interrupt23",
+ [EID_INTERRUPT_N+24] = "Interrupt24",
+ [EID_INTERRUPT_N+25] = "Interrupt25",
+ [EID_INTERRUPT_N+26] = "Interrupt26",
+ [EID_INTERRUPT_N+27] = "Interrupt27",
+ [EID_INTERRUPT_N+28] = "Interrupt28",
+ [EID_INTERRUPT_N+29] = "Interrupt29",
+ [EID_INTERRUPT_N+30] = "Interrupt30",
+ [EID_INTERRUPT_N+31] = "Interrupt31",
};
/*
esirisc->breakpoints_p[bp_index] = breakpoint;
/* specify instruction breakpoint address */
- retval = esirisc_jtag_write_csr(jtag_info, CSR_DEBUG, CSR_DEBUG_IBAn + bp_index,
+ retval = esirisc_jtag_write_csr(jtag_info, CSR_DEBUG, CSR_DEBUG_IBA_N + bp_index,
breakpoint->address);
if (retval != ERROR_OK) {
LOG_ERROR("%s: failed to write Debug CSR: IBA", target_name(target));
esirisc->watchpoints_p[wp_index] = watchpoint;
/* specify data breakpoint address */
- retval = esirisc_jtag_write_csr(jtag_info, CSR_DEBUG, CSR_DEBUG_DBAn + wp_index,
+ retval = esirisc_jtag_write_csr(jtag_info, CSR_DEBUG, CSR_DEBUG_DBA_N + wp_index,
watchpoint->address);
if (retval != ERROR_OK) {
LOG_ERROR("%s: failed to write Debug CSR: DBA", target_name(target));
#define EID_SYSTEM_CALL 0x0b
#define EID_MEMORY_MANAGEMENT 0x0c
#define EID_UNRECOVERABLE 0x0d
-#define EID_INTERRUPTn 0x20
+#define EID_INTERRUPT_N 0x20
/* Exception Entry Points */
#define ENTRY_RESET 0x00
#define ENTRY_SYSCALL 0x05
#define ENTRY_DEBUG 0x06
#define ENTRY_NMI 0x07
-#define ENTRY_INTERRUPTn 0x08
+#define ENTRY_INTERRUPT_N 0x08
/* Hardware Debug Control */
#define HWDC_R (1<<4) /* Reset & Hardware Failure */
#define CSR_DEBUG_HWDC 0x03 /* Hardware Debug Control */
#define CSR_DEBUG_DBS 0x04 /* Data Breakpoint Size */
#define CSR_DEBUG_DBR 0x05 /* Data Breakpoint Range */
-#define CSR_DEBUG_IBAn 0x08 /* Instruction Breakpoint Address [0..7] */
-#define CSR_DEBUG_DBAn 0x10 /* Data Breakpoint Address [0..7] */
+#define CSR_DEBUG_IBA_N 0x08 /* Instruction Breakpoint Address [0..7] */
+#define CSR_DEBUG_DBA_N 0x10 /* Data Breakpoint Address [0..7] */
/* Configuration CSRs */
#define CSR_CONFIG_ARCH0 0x00 /* Architectural Configuration 0 */
#define CSR_CONFIG_IC 0x05 /* Instruction Cache Configuration */
#define CSR_CONFIG_DC 0x06 /* Data Cache Configuration */
#define CSR_CONFIG_INT 0x07 /* Interrupt Configuration */
-#define CSR_CONFIG_ISAn 0x08 /* Instruction Set Configuration [0..6] */
+#define CSR_CONFIG_ISA_N 0x08 /* Instruction Set Configuration [0..6] */
#define CSR_CONFIG_DBG 0x0f /* Debug Configuration */
#define CSR_CONFIG_MID 0x10 /* Manufacturer ID */
#define CSR_CONFIG_REV 0x11 /* Revision Number */
#define CSR_CONFIG_MPID 0x12 /* Multiprocessor ID */
-#define CSR_CONFIG_FREQn 0x13 /* Frequency [0..2] */
+#define CSR_CONFIG_FREQ_N 0x13 /* Frequency [0..2] */
#define CSR_CONFIG_TRACE 0x16 /* Trace Configuration */
/* Trace CSRs */
}
static int image_ihex_buffer_complete_inner(struct image *image,
- char *lpszLine,
+ char *lpsz_line,
struct imagesection *section)
{
struct image_ihex *ihex = image->type_private;
section[image->num_sections].size = 0x0;
section[image->num_sections].flags = 0;
- while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK) {
+ while (fileio_fgets(fileio, 1023, lpsz_line) == ERROR_OK) {
uint32_t count;
uint32_t address;
uint32_t record_type;
size_t bytes_read = 0;
/* skip comments and blank lines */
- if ((lpszLine[0] == '#') || (strlen(lpszLine + strspn(lpszLine, "\n\t\r ")) == 0))
+ if ((lpsz_line[0] == '#') || (strlen(lpsz_line + strspn(lpsz_line, "\n\t\r ")) == 0))
continue;
- if (sscanf(&lpszLine[bytes_read], ":%2" SCNx32 "%4" SCNx32 "%2" SCNx32, &count,
+ if (sscanf(&lpsz_line[bytes_read], ":%2" SCNx32 "%4" SCNx32 "%2" SCNx32, &count,
&address, &record_type) != 3)
return ERROR_IMAGE_FORMAT_ERROR;
bytes_read += 9;
while (count-- > 0) {
unsigned value;
- sscanf(&lpszLine[bytes_read], "%2x", &value);
+ sscanf(&lpsz_line[bytes_read], "%2x", &value);
ihex->buffer[cooked_bytes] = (uint8_t)value;
cal_checksum += (uint8_t)ihex->buffer[cooked_bytes];
bytes_read += 2;
} else if (record_type == 2) { /* Linear Address Record */
uint16_t upper_address;
- sscanf(&lpszLine[bytes_read], "%4hx", &upper_address);
+ sscanf(&lpsz_line[bytes_read], "%4hx", &upper_address);
cal_checksum += (uint8_t)(upper_address >> 8);
cal_checksum += (uint8_t)upper_address;
bytes_read += 4;
/* "Start Segment Address Record" will not be supported
* but we must consume it, and do not create an error. */
while (count-- > 0) {
- sscanf(&lpszLine[bytes_read], "%2" SCNx32, &dummy);
+ sscanf(&lpsz_line[bytes_read], "%2" SCNx32, &dummy);
cal_checksum += (uint8_t)dummy;
bytes_read += 2;
}
} else if (record_type == 4) { /* Extended Linear Address Record */
uint16_t upper_address;
- sscanf(&lpszLine[bytes_read], "%4hx", &upper_address);
+ sscanf(&lpsz_line[bytes_read], "%4hx", &upper_address);
cal_checksum += (uint8_t)(upper_address >> 8);
cal_checksum += (uint8_t)upper_address;
bytes_read += 4;
} else if (record_type == 5) { /* Start Linear Address Record */
uint32_t start_address;
- sscanf(&lpszLine[bytes_read], "%8" SCNx32, &start_address);
+ sscanf(&lpsz_line[bytes_read], "%8" SCNx32, &start_address);
cal_checksum += (uint8_t)(start_address >> 24);
cal_checksum += (uint8_t)(start_address >> 16);
cal_checksum += (uint8_t)(start_address >> 8);
return ERROR_IMAGE_FORMAT_ERROR;
}
- sscanf(&lpszLine[bytes_read], "%2" SCNx32, &checksum);
+ sscanf(&lpsz_line[bytes_read], "%2" SCNx32, &checksum);
if ((uint8_t)checksum != (uint8_t)(~cal_checksum + 1)) {
/* checksum failed */
if (end_rec) {
end_rec = false;
- LOG_WARNING("continuing after end-of-file record: %.40s", lpszLine);
+ LOG_WARNING("continuing after end-of-file record: %.40s", lpsz_line);
}
}
}
*/
static int image_ihex_buffer_complete(struct image *image)
{
- char *lpszLine = malloc(1023);
- if (lpszLine == NULL) {
+ char *lpsz_line = malloc(1023);
+ if (lpsz_line == NULL) {
LOG_ERROR("Out of memory");
return ERROR_FAIL;
}
struct imagesection *section = malloc(sizeof(struct imagesection) * IMAGE_MAX_SECTIONS);
if (section == NULL) {
- free(lpszLine);
+ free(lpsz_line);
LOG_ERROR("Out of memory");
return ERROR_FAIL;
}
int retval;
- retval = image_ihex_buffer_complete_inner(image, lpszLine, section);
+ retval = image_ihex_buffer_complete_inner(image, lpsz_line, section);
free(section);
- free(lpszLine);
+ free(lpsz_line);
return retval;
}
}
static int image_mot_buffer_complete_inner(struct image *image,
- char *lpszLine,
+ char *lpsz_line,
struct imagesection *section)
{
struct image_mot *mot = image->type_private;
section[image->num_sections].size = 0x0;
section[image->num_sections].flags = 0;
- while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK) {
+ while (fileio_fgets(fileio, 1023, lpsz_line) == ERROR_OK) {
uint32_t count;
uint32_t address;
uint32_t record_type;
uint32_t bytes_read = 0;
/* skip comments and blank lines */
- if ((lpszLine[0] == '#') || (strlen(lpszLine + strspn(lpszLine, "\n\t\r ")) == 0))
+ if ((lpsz_line[0] == '#') || (strlen(lpsz_line + strspn(lpsz_line, "\n\t\r ")) == 0))
continue;
/* get record type and record length */
- if (sscanf(&lpszLine[bytes_read], "S%1" SCNx32 "%2" SCNx32, &record_type,
+ if (sscanf(&lpsz_line[bytes_read], "S%1" SCNx32 "%2" SCNx32, &record_type,
&count) != 2)
return ERROR_IMAGE_FORMAT_ERROR;
if (record_type == 0) {
/* S0 - starting record (optional) */
- int iValue;
+ int value;
while (count-- > 0) {
- sscanf(&lpszLine[bytes_read], "%2x", &iValue);
- cal_checksum += (uint8_t)iValue;
+ sscanf(&lpsz_line[bytes_read], "%2x", &value);
+ cal_checksum += (uint8_t)value;
bytes_read += 2;
}
} else if (record_type >= 1 && record_type <= 3) {
switch (record_type) {
case 1:
/* S1 - 16 bit address data record */
- sscanf(&lpszLine[bytes_read], "%4" SCNx32, &address);
+ sscanf(&lpsz_line[bytes_read], "%4" SCNx32, &address);
cal_checksum += (uint8_t)(address >> 8);
cal_checksum += (uint8_t)address;
bytes_read += 4;
case 2:
/* S2 - 24 bit address data record */
- sscanf(&lpszLine[bytes_read], "%6" SCNx32, &address);
+ sscanf(&lpsz_line[bytes_read], "%6" SCNx32, &address);
cal_checksum += (uint8_t)(address >> 16);
cal_checksum += (uint8_t)(address >> 8);
cal_checksum += (uint8_t)address;
case 3:
/* S3 - 32 bit address data record */
- sscanf(&lpszLine[bytes_read], "%8" SCNx32, &address);
+ sscanf(&lpsz_line[bytes_read], "%8" SCNx32, &address);
cal_checksum += (uint8_t)(address >> 24);
cal_checksum += (uint8_t)(address >> 16);
cal_checksum += (uint8_t)(address >> 8);
while (count-- > 0) {
unsigned value;
- sscanf(&lpszLine[bytes_read], "%2x", &value);
+ sscanf(&lpsz_line[bytes_read], "%2x", &value);
mot->buffer[cooked_bytes] = (uint8_t)value;
cal_checksum += (uint8_t)mot->buffer[cooked_bytes];
bytes_read += 2;
uint32_t dummy;
while (count-- > 0) {
- sscanf(&lpszLine[bytes_read], "%2" SCNx32, &dummy);
+ sscanf(&lpsz_line[bytes_read], "%2" SCNx32, &dummy);
cal_checksum += (uint8_t)dummy;
bytes_read += 2;
}
}
/* account for checksum, will always be 0xFF */
- sscanf(&lpszLine[bytes_read], "%2" SCNx32, &checksum);
+ sscanf(&lpsz_line[bytes_read], "%2" SCNx32, &checksum);
cal_checksum += (uint8_t)checksum;
if (cal_checksum != 0xFF) {
if (end_rec) {
end_rec = false;
- LOG_WARNING("continuing after end-of-file record: %.40s", lpszLine);
+ LOG_WARNING("continuing after end-of-file record: %.40s", lpsz_line);
}
}
}
*/
static int image_mot_buffer_complete(struct image *image)
{
- char *lpszLine = malloc(1023);
- if (lpszLine == NULL) {
+ char *lpsz_line = malloc(1023);
+ if (lpsz_line == NULL) {
LOG_ERROR("Out of memory");
return ERROR_FAIL;
}
struct imagesection *section = malloc(sizeof(struct imagesection) * IMAGE_MAX_SECTIONS);
if (section == NULL) {
- free(lpszLine);
+ free(lpsz_line);
LOG_ERROR("Out of memory");
return ERROR_FAIL;
}
int retval;
- retval = image_mot_buffer_complete_inner(image, lpszLine, section);
+ retval = image_mot_buffer_complete_inner(image, lpsz_line, section);
free(section);
- free(lpszLine);
+ free(lpsz_line);
return retval;
}
/* every 300ms we check for reset & powerdropout and issue a "reset halt" if so. */
-static int powerDropout;
-static int srstAsserted;
+static int power_dropout;
+static int srst_asserted;
-static int runPowerRestore;
-static int runPowerDropout;
-static int runSrstAsserted;
-static int runSrstDeasserted;
+static int run_power_restore;
+static int run_power_dropout;
+static int run_srst_asserted;
+static int run_srst_deasserted;
static int sense_handler(void)
{
- static int prevSrstAsserted;
- static int prevPowerdropout;
+ static int prev_srst_asserted;
+ static int prev_power_dropout;
- int retval = jtag_power_dropout(&powerDropout);
+ int retval = jtag_power_dropout(&power_dropout);
if (retval != ERROR_OK)
return retval;
- int powerRestored;
- powerRestored = prevPowerdropout && !powerDropout;
- if (powerRestored)
- runPowerRestore = 1;
+ int power_restored;
+ power_restored = prev_power_dropout && !power_dropout;
+ if (power_restored)
+ run_power_restore = 1;
int64_t current = timeval_ms();
- static int64_t lastPower;
- bool waitMore = lastPower + 2000 > current;
- if (powerDropout && !waitMore) {
- runPowerDropout = 1;
- lastPower = current;
+ static int64_t last_power;
+ bool wait_more = last_power + 2000 > current;
+ if (power_dropout && !wait_more) {
+ run_power_dropout = 1;
+ last_power = current;
}
- retval = jtag_srst_asserted(&srstAsserted);
+ retval = jtag_srst_asserted(&srst_asserted);
if (retval != ERROR_OK)
return retval;
- int srstDeasserted;
- srstDeasserted = prevSrstAsserted && !srstAsserted;
+ int srst_deasserted;
+ srst_deasserted = prev_srst_asserted && !srst_asserted;
- static int64_t lastSrst;
- waitMore = lastSrst + 2000 > current;
- if (srstDeasserted && !waitMore) {
- runSrstDeasserted = 1;
- lastSrst = current;
+ static int64_t last_srst;
+ wait_more = last_srst + 2000 > current;
+ if (srst_deasserted && !wait_more) {
+ run_srst_deasserted = 1;
+ last_srst = current;
}
- if (!prevSrstAsserted && srstAsserted)
- runSrstAsserted = 1;
+ if (!prev_srst_asserted && srst_asserted)
+ run_srst_asserted = 1;
- prevSrstAsserted = srstAsserted;
- prevPowerdropout = powerDropout;
+ prev_srst_asserted = srst_asserted;
+ prev_power_dropout = power_dropout;
- if (srstDeasserted || powerRestored) {
+ if (srst_deasserted || power_restored) {
/* Other than logging the event we can't do anything here.
* Issuing a reset is a particularly bad idea as we might
* be inside a reset already.
* clearing the flags after running these events.
*/
int did_something = 0;
- if (runSrstAsserted) {
+ if (run_srst_asserted) {
LOG_INFO("srst asserted detected, running srst_asserted proc.");
Jim_Eval(interp, "srst_asserted");
did_something = 1;
}
- if (runSrstDeasserted) {
+ if (run_srst_deasserted) {
Jim_Eval(interp, "srst_deasserted");
did_something = 1;
}
- if (runPowerDropout) {
+ if (run_power_dropout) {
LOG_INFO("Power dropout detected, running power_dropout proc.");
Jim_Eval(interp, "power_dropout");
did_something = 1;
}
- if (runPowerRestore) {
+ if (run_power_restore) {
Jim_Eval(interp, "power_restore");
did_something = 1;
}
/* clear action flags */
- runSrstAsserted = 0;
- runSrstDeasserted = 0;
- runPowerRestore = 0;
- runPowerDropout = 0;
+ run_srst_asserted = 0;
+ run_srst_deasserted = 0;
+ run_power_restore = 0;
+ run_power_dropout = 0;
recursive = 0;
}
target->backoff.count = 0;
/* only poll target if we've got power and srst isn't asserted */
- if (!powerDropout && !srstAsserted) {
+ if (!power_dropout && !srst_asserted) {
/* polling may fail silently until the target has been examined */
retval = target_poll(target);
if (retval != ERROR_OK) {
return target_fill_mem(target, address, fn, wordsize, value, count);
}
-static COMMAND_HELPER(parse_load_image_command_CMD_ARGV, struct image *image,
+static COMMAND_HELPER(parse_load_image_command, struct image *image,
target_addr_t *min_address, target_addr_t *max_address)
{
if (CMD_ARGC < 1 || CMD_ARGC > 5)
target_addr_t max_address = -1;
struct image image;
- int retval = CALL_COMMAND_HANDLER(parse_load_image_command_CMD_ARGV,
+ int retval = CALL_COMMAND_HANDLER(parse_load_image_command,
&image, &min_address, &max_address);
if (retval != ERROR_OK)
return retval;
return retval;
}
-static void writeData(FILE *f, const void *data, size_t len)
+static void write_data(FILE *f, const void *data, size_t len)
{
size_t written = fwrite(data, 1, len, f);
if (written != len)
LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
}
-static void writeLong(FILE *f, int l, struct target *target)
+static void write_long(FILE *f, int l, struct target *target)
{
uint8_t val[4];
target_buffer_set_u32(target, val, l);
- writeData(f, val, 4);
+ write_data(f, val, 4);
}
-static void writeString(FILE *f, char *s)
+static void write_string(FILE *f, char *s)
{
- writeData(f, s, strlen(s));
+ write_data(f, s, strlen(s));
}
typedef unsigned char UNIT[2]; /* unit of profiling */
/* Dump a gmon.out histogram file. */
-static void write_gmon(uint32_t *samples, uint32_t sampleNum, const char *filename, bool with_range,
+static void write_gmon(uint32_t *samples, uint32_t sample_num, const char *filename, bool with_range,
uint32_t start_address, uint32_t end_address, struct target *target, uint32_t duration_ms)
{
uint32_t i;
FILE *f = fopen(filename, "w");
if (f == NULL)
return;
- writeString(f, "gmon");
- writeLong(f, 0x00000001, target); /* Version */
- writeLong(f, 0, target); /* padding */
- writeLong(f, 0, target); /* padding */
- writeLong(f, 0, target); /* padding */
+ write_string(f, "gmon");
+ write_long(f, 0x00000001, target); /* Version */
+ write_long(f, 0, target); /* padding */
+ write_long(f, 0, target); /* padding */
+ write_long(f, 0, target); /* padding */
uint8_t zero = 0; /* GMON_TAG_TIME_HIST */
- writeData(f, &zero, 1);
+ write_data(f, &zero, 1);
/* figure out bucket size */
uint32_t min;
} else {
min = samples[0];
max = samples[0];
- for (i = 0; i < sampleNum; i++) {
+ for (i = 0; i < sample_num; i++) {
if (min > samples[i])
min = samples[i];
if (max < samples[i])
max++;
}
- int addressSpace = max - min;
- assert(addressSpace >= 2);
+ int address_space = max - min;
+ assert(address_space >= 2);
/* FIXME: What is the reasonable number of buckets?
* The profiling result will be more accurate if there are enough buckets. */
- static const uint32_t maxBuckets = 128 * 1024; /* maximum buckets. */
- uint32_t numBuckets = addressSpace / sizeof(UNIT);
- if (numBuckets > maxBuckets)
- numBuckets = maxBuckets;
- int *buckets = malloc(sizeof(int) * numBuckets);
+ static const uint32_t max_buckets = 128 * 1024; /* maximum buckets. */
+ uint32_t num_buckets = address_space / sizeof(UNIT);
+ if (num_buckets > max_buckets)
+ num_buckets = max_buckets;
+ int *buckets = malloc(sizeof(int) * num_buckets);
if (buckets == NULL) {
fclose(f);
return;
}
- memset(buckets, 0, sizeof(int) * numBuckets);
- for (i = 0; i < sampleNum; i++) {
+ memset(buckets, 0, sizeof(int) * num_buckets);
+ for (i = 0; i < sample_num; i++) {
uint32_t address = samples[i];
if ((address < min) || (max <= address))
continue;
long long a = address - min;
- long long b = numBuckets;
- long long c = addressSpace;
+ long long b = num_buckets;
+ long long c = address_space;
int index_t = (a * b) / c; /* danger!!!! int32 overflows */
buckets[index_t]++;
}
/* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
- writeLong(f, min, target); /* low_pc */
- writeLong(f, max, target); /* high_pc */
- writeLong(f, numBuckets, target); /* # of buckets */
- float sample_rate = sampleNum / (duration_ms / 1000.0);
- writeLong(f, sample_rate, target);
- writeString(f, "seconds");
+ write_long(f, min, target); /* low_pc */
+ write_long(f, max, target); /* high_pc */
+ write_long(f, num_buckets, target); /* # of buckets */
+ float sample_rate = sample_num / (duration_ms / 1000.0);
+ write_long(f, sample_rate, target);
+ write_string(f, "seconds");
for (i = 0; i < (15-strlen("seconds")); i++)
- writeData(f, &zero, 1);
- writeString(f, "s");
+ write_data(f, &zero, 1);
+ write_string(f, "s");
/*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
- char *data = malloc(2 * numBuckets);
+ char *data = malloc(2 * num_buckets);
if (data != NULL) {
- for (i = 0; i < numBuckets; i++) {
+ for (i = 0; i < num_buckets; i++) {
int val;
val = buckets[i];
if (val > 65535)
data[i * 2 + 1] = (val >> 8) & 0xff;
}
free(buckets);
- writeData(f, data, numBuckets * 2);
+ write_data(f, data, num_buckets * 2);
free(data);
} else
free(buckets);
static int new_u64_array_element(Jim_Interp *interp, const char *varname, int idx, uint64_t val)
{
char *namebuf;
- Jim_Obj *nameObjPtr, *valObjPtr;
+ Jim_Obj *obj_name, *obj_val;
int result;
namebuf = alloc_printf("%s(%d)", varname, idx);
if (!namebuf)
return JIM_ERR;
- nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
+ obj_name = Jim_NewStringObj(interp, namebuf, -1);
jim_wide wide_val = val;
- valObjPtr = Jim_NewWideObj(interp, wide_val);
- if (!nameObjPtr || !valObjPtr) {
+ obj_val = Jim_NewWideObj(interp, wide_val);
+ if (!obj_name || !obj_val) {
free(namebuf);
return JIM_ERR;
}
- Jim_IncrRefCount(nameObjPtr);
- Jim_IncrRefCount(valObjPtr);
- result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
- Jim_DecrRefCount(interp, nameObjPtr);
- Jim_DecrRefCount(interp, valObjPtr);
+ Jim_IncrRefCount(obj_name);
+ Jim_IncrRefCount(obj_val);
+ result = Jim_SetVariable(interp, obj_name, obj_val);
+ Jim_DecrRefCount(interp, obj_name);
+ Jim_DecrRefCount(interp, obj_val);
free(namebuf);
/* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
return result;
if (!namebuf)
return JIM_ERR;
- Jim_Obj *nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
- if (!nameObjPtr) {
+ Jim_Obj *obj_name = Jim_NewStringObj(interp, namebuf, -1);
+ if (!obj_name) {
free(namebuf);
return JIM_ERR;
}
- Jim_IncrRefCount(nameObjPtr);
- Jim_Obj *valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
- Jim_DecrRefCount(interp, nameObjPtr);
+ Jim_IncrRefCount(obj_name);
+ Jim_Obj *obj_val = Jim_GetVariable(interp, obj_name, JIM_ERRMSG);
+ Jim_DecrRefCount(interp, obj_name);
free(namebuf);
- if (valObjPtr == NULL)
+ if (obj_val == NULL)
return JIM_ERR;
jim_wide wide_val;
- int result = Jim_GetWide(interp, valObjPtr, &wide_val);
+ int result = Jim_GetWide(interp, obj_val, &wide_val);
*val = wide_val;
return result;
}
e = target_wait_state(target, n->value, a);
if (e != ERROR_OK) {
- Jim_Obj *eObj = Jim_NewIntObj(interp, e);
+ Jim_Obj *obj = Jim_NewIntObj(interp, e);
Jim_SetResultFormatted(goi.interp,
"target: %s wait %s fails (%#s) %s",
target_name(target), n->name,
- eObj, target_strerror_safe(e));
+ obj, target_strerror_safe(e));
return JIM_ERR;
}
return JIM_OK;
COMMAND_REGISTRATION_DONE
};
-struct FastLoad {
+struct fast_load {
target_addr_t address;
uint8_t *data;
int length;
};
static int fastload_num;
-static struct FastLoad *fastload;
+static struct fast_load *fastload;
static void free_fastload(void)
{
struct image image;
- int retval = CALL_COMMAND_HANDLER(parse_load_image_command_CMD_ARGV,
+ int retval = CALL_COMMAND_HANDLER(parse_load_image_command,
&image, &min_address, &max_address);
if (retval != ERROR_OK)
return retval;
image_size = 0x0;
retval = ERROR_OK;
fastload_num = image.num_sections;
- fastload = malloc(sizeof(struct FastLoad)*image.num_sections);
+ fastload = malloc(sizeof(struct fast_load)*image.num_sections);
if (fastload == NULL) {
command_print(CMD, "out of memory");
image_close(&image);
return ERROR_FAIL;
}
- memset(fastload, 0, sizeof(struct FastLoad)*image.num_sections);
+ memset(fastload, 0, sizeof(struct fast_load)*image.num_sections);
for (unsigned int i = 0; i < image.num_sections; i++) {
buffer = malloc(image.sections[i].size);
if (buffer == NULL) {
}
uint32_t cr4 = buf_get_u32(x86_32->cache->reg_list[CR4].value, 0, 32);
- bool isPAE = cr4 & 0x00000020; /* PAE - Physical Address Extension */
+ bool is_pae = cr4 & 0x00000020; /* PAE - Physical Address Extension */
uint32_t cr3 = buf_get_u32(x86_32->cache->reg_list[CR3].value, 0, 32);
- if (isPAE) {
+ if (is_pae) {
uint32_t pdpt_base = cr3 & 0xFFFFF000; /* lower 12 bits of CR3 must always be 0 */
uint32_t pdpt_index = (addr & 0xC0000000) >> 30; /* A[31:30] index to PDPT */
uint32_t pdpt_addr = pdpt_base + (8 * pdpt_index);
Code Review / openocd.git / commitdiff