- Replace '\([^_]\)u32' with '\1uint32_t'.
- Replace '^u32' with 'uint32_t'.
git-svn-id: svn://svn.berlios.de/openocd/trunk@2281
b42882b7-edfa-0310-969c-
e2dbd0fdcd60
28 files changed:
-u32 flip_u32(u32 value, unsigned int num)
+uint32_t flip_u32(uint32_t value, unsigned int num)
c = (bit_reverse_table256[value & 0xff] << 24) |
(bit_reverse_table256[(value >> 8) & 0xff] << 16) |
c = (bit_reverse_table256[value & 0xff] << 24) |
(bit_reverse_table256[(value >> 8) & 0xff] << 16) |
int ceil_f_to_u32(float x)
{
int ceil_f_to_u32(float x)
{
if (x < 0) /* return zero for negative numbers */
return 0;
if (x < 0) /* return zero for negative numbers */
return 0;
char *str;
int str_len;
int b256_len = CEIL(buf_len, 8);
char *str;
int str_len;
int b256_len = CEIL(buf_len, 8);
int j; /* base-256 digits */
int i; /* output digits (radix) */
int j; /* base-256 digits */
int i; /* output digits (radix) */
for (j = str_len; j > 0; j--)
{
for (j = str_len; j > 0; j--)
{
- tmp += (u32)str[j-1] * 256;
+ tmp += (uint32_t)str[j-1] * 256;
str[j-1] = (uint8_t)(tmp % radix);
tmp /= radix;
}
str[j-1] = (uint8_t)(tmp % radix);
tmp /= radix;
}
int str_to_buf(const char *str, int str_len, uint8_t *buf, int buf_len, int radix)
{
char *charbuf;
int str_to_buf(const char *str, int str_len, uint8_t *buf, int buf_len, int radix)
{
char *charbuf;
float factor;
uint8_t *b256_buf;
int b256_len;
float factor;
uint8_t *b256_buf;
int b256_len;
tmp = (tmp - 'A' + 10);
else continue; /* skip characters other than [0-9,a-f,A-F] */
tmp = (tmp - 'A' + 10);
else continue; /* skip characters other than [0-9,a-f,A-F] */
+ if (tmp >= (uint32_t)radix)
continue; /* skip digits invalid for the current radix */
for (j = 0; j < b256_len; j++)
{
continue; /* skip digits invalid for the current radix */
for (j = 0; j < b256_len; j++)
{
- tmp += (u32)b256_buf[j] * radix;
+ tmp += (uint32_t)b256_buf[j] * radix;
b256_buf[j] = (uint8_t)(tmp & 0xFF);
tmp >>= 8;
}
b256_buf[j] = (uint8_t)(tmp & 0xFF);
tmp >>= 8;
}
int buf_to_u32_handler(uint8_t *in_buf, void *priv, struct scan_field_s *field)
{
int buf_to_u32_handler(uint8_t *in_buf, void *priv, struct scan_field_s *field)
{
*dest = buf_get_u32(in_buf, 0, 32);
*dest = buf_get_u32(in_buf, 0, 32);
*/
/* inlining this will help show what fn that is taking time during profiling. */
*/
/* inlining this will help show what fn that is taking time during profiling. */
-static inline void buf_set_u32(uint8_t* buffer, unsigned int first, unsigned int num, u32 value)
+static inline void buf_set_u32(uint8_t* buffer, unsigned int first, unsigned int num, uint32_t value)
{
if ((num==32)&&(first==0))
{
{
if ((num==32)&&(first==0))
{
-static inline u32 buf_get_u32(const uint8_t* buffer, unsigned int first, unsigned int num)
+static inline uint32_t buf_get_u32(const uint8_t* buffer, unsigned int first, unsigned int num)
{
if ((num==32)&&(first==0))
{
{
if ((num==32)&&(first==0))
{
- return (((u32)buffer[3])<<24)|(((u32)buffer[2])<<16)|(((u32)buffer[1])<<8)|(((u32)buffer[0])<<0);
+ return (((uint32_t)buffer[3])<<24)|(((uint32_t)buffer[2])<<16)|(((uint32_t)buffer[1])<<8)|(((uint32_t)buffer[0])<<0);
unsigned int i;
for (i=first; i<first+num; i++)
unsigned int i;
for (i=first; i<first+num; i++)
-extern u32 flip_u32(u32 value, unsigned int num);
+extern uint32_t flip_u32(uint32_t value, unsigned int num);
extern int buf_cmp(const uint8_t *buf1, const uint8_t *buf2, int size);
extern int buf_cmp_mask(const uint8_t *buf1, const uint8_t *buf2, const uint8_t *mask, int size);
extern int buf_cmp(const uint8_t *buf1, const uint8_t *buf2, int size);
extern int buf_cmp_mask(const uint8_t *buf1, const uint8_t *buf2, const uint8_t *mask, int size);
#define CEIL(m, n) ((m + n - 1) / n)
#define CEIL(m, n) ((m + n - 1) / n)
-/* read a u32 from a buffer in target memory endianness */
-static inline u32 fast_target_buffer_get_u32(const uint8_t *buffer, int little)
+/* read a uint32_t from a buffer in target memory endianness */
+static inline uint32_t fast_target_buffer_get_u32(const uint8_t *buffer, int little)
{
if (little)
return le_to_h_u32(buffer);
{
if (little)
return le_to_h_u32(buffer);
-int fileio_seek(fileio_t *fileio, u32 position)
+int fileio_seek(fileio_t *fileio, uint32_t position)
{
int retval;
if ((retval = fseek(fileio->file, position, SEEK_SET)) != 0)
{
int retval;
if ((retval = fseek(fileio->file, position, SEEK_SET)) != 0)
-static inline int fileio_local_read(fileio_t *fileio, u32 size, uint8_t *buffer, u32 *size_read)
+static inline int fileio_local_read(fileio_t *fileio, uint32_t size, uint8_t *buffer, uint32_t *size_read)
{
*size_read = fread(buffer, 1, size, fileio->file);
return ERROR_OK;
}
{
*size_read = fread(buffer, 1, size, fileio->file);
return ERROR_OK;
}
-int fileio_read(fileio_t *fileio, u32 size, uint8_t *buffer, u32 *size_read)
+int fileio_read(fileio_t *fileio, uint32_t size, uint8_t *buffer, uint32_t *size_read)
{
return fileio_local_read(fileio, size, buffer, size_read);
}
{
return fileio_local_read(fileio, size, buffer, size_read);
}
-int fileio_read_u32(fileio_t *fileio, u32 *data)
+int fileio_read_u32(fileio_t *fileio, uint32_t *data)
int retval;
if ((retval = fileio_local_read(fileio, 4, buf, &size_read)) != ERROR_OK)
int retval;
if ((retval = fileio_local_read(fileio, 4, buf, &size_read)) != ERROR_OK)
-static inline int fileio_local_fgets(fileio_t *fileio, u32 size, char *buffer)
+static inline int fileio_local_fgets(fileio_t *fileio, uint32_t size, char *buffer)
{
if( fgets(buffer, size, fileio->file) == NULL)
return ERROR_FILEIO_OPERATION_FAILED;
{
if( fgets(buffer, size, fileio->file) == NULL)
return ERROR_FILEIO_OPERATION_FAILED;
-int fileio_fgets(fileio_t *fileio, u32 size, char *buffer)
+int fileio_fgets(fileio_t *fileio, uint32_t size, char *buffer)
{
return fileio_local_fgets(fileio, size, buffer);
}
{
return fileio_local_fgets(fileio, size, buffer);
}
-static inline int fileio_local_write(fileio_t *fileio, u32 size, const uint8_t *buffer, u32 *size_written)
+static inline int fileio_local_write(fileio_t *fileio, uint32_t size, const uint8_t *buffer, uint32_t *size_written)
{
*size_written = fwrite(buffer, 1, size, fileio->file);
return ERROR_OK;
}
{
*size_written = fwrite(buffer, 1, size, fileio->file);
return ERROR_OK;
}
-int fileio_write(fileio_t *fileio, u32 size, const uint8_t *buffer, u32 *size_written)
+int fileio_write(fileio_t *fileio, uint32_t size, const uint8_t *buffer, uint32_t *size_written)
-int fileio_write_u32(fileio_t *fileio, u32 data)
+int fileio_write_u32(fileio_t *fileio, uint32_t data)
int retval;
h_u32_to_be(buf, data);
int retval;
h_u32_to_be(buf, data);
-extern int fileio_write(fileio_t *fileio, u32 size, const uint8_t *buffer, u32 *size_written);
-extern int fileio_read(fileio_t *fileio, u32 size, uint8_t *buffer, u32 *size_read);
-extern int fileio_fgets(fileio_t *fileio, u32 size, char *buffer);
-extern int fileio_seek(fileio_t *fileio, u32 position);
+extern int fileio_write(fileio_t *fileio, uint32_t size, const uint8_t *buffer, uint32_t *size_written);
+extern int fileio_read(fileio_t *fileio, uint32_t size, uint8_t *buffer, uint32_t *size_read);
+extern int fileio_fgets(fileio_t *fileio, uint32_t size, char *buffer);
+extern int fileio_seek(fileio_t *fileio, uint32_t position);
extern int fileio_close(fileio_t *fileio);
extern int fileio_open(fileio_t *fileio, const char *url, enum fileio_access access, enum fileio_type type);
extern int fileio_close(fileio_t *fileio);
extern int fileio_open(fileio_t *fileio, const char *url, enum fileio_access access, enum fileio_type type);
-extern int fileio_read_u32(fileio_t *fileio, u32 *data);
-extern int fileio_write_u32(fileio_t *fileio, u32 data);
+extern int fileio_read_u32(fileio_t *fileio, uint32_t *data);
+extern int fileio_write_u32(fileio_t *fileio, uint32_t data);
#define ERROR_FILEIO_LOCATION_UNKNOWN (-1200)
#define ERROR_FILEIO_NOT_FOUND (-1201)
#define ERROR_FILEIO_LOCATION_UNKNOWN (-1200)
#define ERROR_FILEIO_NOT_FOUND (-1201)
typedef unsigned short uint16_t;
#endif
typedef unsigned short uint16_t;
#endif
-#ifndef u32
-typedef unsigned int u32;
+#ifndef uint32_t
+typedef unsigned int uint32_t;
-static inline u32 le_to_h_u32(const uint8_t* buf)
+static inline uint32_t le_to_h_u32(const uint8_t* buf)
- return (u32)(buf[0] | buf[1] << 8 | buf[2] << 16 | buf[3] << 24);
+ return (uint32_t)(buf[0] | buf[1] << 8 | buf[2] << 16 | buf[3] << 24);
}
static inline uint16_t le_to_h_u16(const uint8_t* buf)
}
static inline uint16_t le_to_h_u16(const uint8_t* buf)
return (uint16_t)(buf[0] | buf[1] << 8);
}
return (uint16_t)(buf[0] | buf[1] << 8);
}
-static inline u32 be_to_h_u32(const uint8_t* buf)
+static inline uint32_t be_to_h_u32(const uint8_t* buf)
- return (u32)(buf[3] | buf[2] << 8 | buf[1] << 16 | buf[0] << 24);
+ return (uint32_t)(buf[3] | buf[2] << 8 | buf[1] << 16 | buf[0] << 24);
}
static inline uint16_t be_to_h_u16(const uint8_t* buf)
}
static inline uint16_t be_to_h_u16(const uint8_t* buf)
{
char* name;
int TDO_PIO; /* PIO holding TDO */
{
char* name;
int TDO_PIO; /* PIO holding TDO */
- u32 TDO_MASK; /* TDO bitmask */
+ uint32_t TDO_MASK; /* TDO bitmask */
int TRST_PIO; /* PIO holding TRST */
int TRST_PIO; /* PIO holding TRST */
- u32 TRST_MASK; /* TRST bitmask */
+ uint32_t TRST_MASK; /* TRST bitmask */
int TMS_PIO; /* PIO holding TMS */
int TMS_PIO; /* PIO holding TMS */
- u32 TMS_MASK; /* TMS bitmask */
+ uint32_t TMS_MASK; /* TMS bitmask */
int TCK_PIO; /* PIO holding TCK */
int TCK_PIO; /* PIO holding TCK */
- u32 TCK_MASK; /* TCK bitmask */
+ uint32_t TCK_MASK; /* TCK bitmask */
int TDI_PIO; /* PIO holding TDI */
int TDI_PIO; /* PIO holding TDI */
- u32 TDI_MASK; /* TDI bitmask */
+ uint32_t TDI_MASK; /* TDI bitmask */
int SRST_PIO; /* PIO holding SRST */
int SRST_PIO; /* PIO holding SRST */
- u32 SRST_MASK; /* SRST bitmask */
+ uint32_t SRST_MASK; /* SRST bitmask */
};
static struct device_t devices[] =
};
static struct device_t devices[] =
static struct device_t* device;
static int dev_mem_fd;
static void *sys_controller;
static struct device_t* device;
static int dev_mem_fd;
static void *sys_controller;
+static uint32_t* pio_base;
/* low level command set
*/
/* low level command set
*/
close(dev_mem_fd);
return ERROR_JTAG_INIT_FAILED;
}
close(dev_mem_fd);
return ERROR_JTAG_INIT_FAILED;
}
- pio_base = (u32*)sys_controller + 0x100;
+ pio_base = (uint32_t*)sys_controller + 0x100;
/*
* Configure TDO as an input, and TDI, TCK, TMS, TRST, SRST
/*
* Configure TDO as an input, and TDI, TCK, TMS, TRST, SRST
typedef struct sleep_command_s
{
/// number of microseconds to sleep
typedef struct sleep_command_s
{
/// number of microseconds to sleep
}
void jtag_add_dr_out(jtag_tap_t* tap,
}
void jtag_add_dr_out(jtag_tap_t* tap,
- int num_fields, const int* num_bits, const u32* value,
+ int num_fields, const int* num_bits, const uint32_t* value,
tap_state_t end_state)
{
assert(end_state != TAP_INVALID);
tap_state_t end_state)
{
assert(end_state != TAP_INVALID);
return cmd_queue_end_state;
}
return cmd_queue_end_state;
}
-void jtag_add_sleep(u32 us)
+void jtag_add_sleep(uint32_t us)
{
/// @todo Here, keep_alive() appears to be a layering violation!!!
keep_alive();
{
/// @todo Here, keep_alive() appears to be a layering violation!!!
keep_alive();
+void jtag_sleep(uint32_t us)
{
alive_sleep(us/1000);
}
{
alive_sleep(us/1000);
}
}
static void jtag_examine_chain_display(enum log_levels level, const char *msg,
}
static void jtag_examine_chain_display(enum log_levels level, const char *msg,
- const char *name, u32 idcode)
+ const char *name, uint32_t idcode)
{
log_printf_lf(level, __FILE__, __LINE__, __FUNCTION__,
"JTAG tap: %s %16.16s: 0x%08x "
{
log_printf_lf(level, __FILE__, __LINE__, __FUNCTION__,
"JTAG tap: %s %16.16s: 0x%08x "
EXTRACT_MFG(idcode), EXTRACT_PART(idcode), EXTRACT_VER(idcode) );
}
EXTRACT_MFG(idcode), EXTRACT_PART(idcode), EXTRACT_VER(idcode) );
}
-static bool jtag_idcode_is_final(u32 idcode)
+static bool jtag_idcode_is_final(uint32_t idcode)
{
return idcode == 0x000000FF || idcode == 0xFFFFFFFF;
}
{
return idcode == 0x000000FF || idcode == 0xFFFFFFFF;
}
bool triggered = false;
for ( ; count < max - 31; count += 32)
{
bool triggered = false;
for ( ; count < max - 31; count += 32)
{
- u32 idcode = buf_get_u32(idcodes, count, 32);
+ uint32_t idcode = buf_get_u32(idcodes, count, 32);
// do not trigger the warning if the data looks good
if (!triggered && jtag_idcode_is_final(idcode))
continue;
// do not trigger the warning if the data looks good
if (!triggered && jtag_idcode_is_final(idcode))
continue;
for (unsigned bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
{
for (unsigned bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
{
- u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
+ uint32_t idcode = buf_get_u32(idcode_buffer, bit_count, 32);
if ((idcode & 1) == 0)
{
/* LSB must not be 0, this indicates a device in bypass */
if ((idcode & 1) == 0)
{
/* LSB must not be 0, this indicates a device in bypass */
void interface_jtag_add_dr_out(jtag_tap_t *target_tap,
int in_num_fields,
const int *num_bits,
void interface_jtag_add_dr_out(jtag_tap_t *target_tap,
int in_num_fields,
const int *num_bits,
tap_state_t end_state)
{
/* count devices in bypass */
tap_state_t end_state)
{
/* count devices in bypass */
-int interface_jtag_add_sleep(u32 us)
+int interface_jtag_add_sleep(uint32_t us)
{
/* allocate memory for a new list member */
jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
{
/* allocate memory for a new list member */
jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
static int clock_count; /* count clocks in any stable state, only stable states */
static int clock_count; /* count clocks in any stable state, only stable states */
+static uint32_t dummy_data;
static int dummy_speed(int speed);
static int dummy_speed(int speed);
static int set_gonk_mode(void)
{
void *syscon;
static int set_gonk_mode(void)
{
void *syscon;
syscon = mmap(NULL, 4096, PROT_READ | PROT_WRITE,
MAP_SHARED, dev_mem_fd, 0x80930000);
syscon = mmap(NULL, 4096, PROT_READ | PROT_WRITE,
MAP_SHARED, dev_mem_fd, 0x80930000);
-static int ft2232_write(uint8_t* buf, int size, u32* bytes_written)
+static int ft2232_write(uint8_t* buf, int size, uint32_t* bytes_written)
{
#if BUILD_FT2232_FTD2XX == 1
FT_STATUS status;
{
#if BUILD_FT2232_FTD2XX == 1
FT_STATUS status;
-static int ft2232_read(uint8_t* buf, u32 size, u32* bytes_read)
+static int ft2232_read(uint8_t* buf, uint32_t size, uint32_t* bytes_read)
{
#if BUILD_FT2232_FTD2XX == 1
DWORD dw_bytes_read;
{
#if BUILD_FT2232_FTD2XX == 1
DWORD dw_bytes_read;
uint8_t buf = use_adaptive_clocking ? 0x96 : 0x97;
LOG_DEBUG("%2.2x", buf);
uint8_t buf = use_adaptive_clocking ? 0x96 : 0x97;
LOG_DEBUG("%2.2x", buf);
+ uint32_t bytes_written;
int retval = ft2232_write(&buf, 1, &bytes_written);
if (ERROR_OK != retval || bytes_written != 1)
{
int retval = ft2232_write(&buf, 1, &bytes_written);
if (ERROR_OK != retval || bytes_written != 1)
{
{
uint8_t buf[3];
int retval;
{
uint8_t buf[3];
int retval;
+ uint32_t bytes_written;
ft2232_adaptive_clocking(speed);
ft2232_adaptive_clocking(speed);
int scan_size;
enum scan_type type;
int retval;
int scan_size;
enum scan_type type;
int retval;
- u32 bytes_written=0;
- u32 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;
int last_bit;
uint8_t* receive_buffer = malloc(CEIL(scan_size, 8));
uint8_t* receive_pointer = receive_buffer;
int last_bit;
uint8_t* receive_buffer = malloc(CEIL(scan_size, 8));
uint8_t* receive_pointer = receive_buffer;
- u32 bytes_written;
- u32 bytes_read;
+ uint32_t bytes_written;
+ uint32_t bytes_read;
int retval;
int thisrun_read = 0;
int retval;
int thisrun_read = 0;
if (status == FT_OK)
{
char** desc_array = malloc(sizeof(char*) * (num_devices + 1));
if (status == FT_OK)
{
char** desc_array = malloc(sizeof(char*) * (num_devices + 1));
for (i = 0; i < num_devices; i++)
desc_array[i] = malloc(64);
for (i = 0; i < num_devices; i++)
desc_array[i] = malloc(64);
{
uint8_t buf[1];
int retval;
{
uint8_t buf[1];
int retval;
+ uint32_t bytes_written;
const ft2232_layout_t* cur_layout = ft2232_layouts;
int i;
const ft2232_layout_t* cur_layout = ft2232_layouts;
int i;
static int usbjtag_init(void)
{
uint8_t buf[3];
static int usbjtag_init(void)
{
uint8_t buf[3];
+ uint32_t bytes_written;
low_output = 0x08;
low_direction = 0x0b;
low_output = 0x08;
low_direction = 0x0b;
static int axm0432_jtag_init(void)
{
uint8_t buf[3];
static int axm0432_jtag_init(void)
{
uint8_t buf[3];
+ uint32_t bytes_written;
low_output = 0x08;
low_direction = 0x2b;
low_output = 0x08;
low_direction = 0x2b;
static int jtagkey_init(void)
{
uint8_t buf[3];
static int jtagkey_init(void)
{
uint8_t buf[3];
+ uint32_t bytes_written;
low_output = 0x08;
low_direction = 0x1b;
low_output = 0x08;
low_direction = 0x1b;
static int olimex_jtag_init(void)
{
uint8_t buf[3];
static int olimex_jtag_init(void)
{
uint8_t buf[3];
+ uint32_t bytes_written;
low_output = 0x08;
low_direction = 0x1b;
low_output = 0x08;
low_direction = 0x1b;
static int flyswatter_init(void)
{
uint8_t buf[3];
static int flyswatter_init(void)
{
uint8_t buf[3];
+ uint32_t bytes_written;
low_output = 0x18;
low_direction = 0xfb;
low_output = 0x18;
low_direction = 0xfb;
static int turtle_init(void)
{
uint8_t buf[3];
static int turtle_init(void)
{
uint8_t buf[3];
+ uint32_t bytes_written;
low_output = 0x08;
low_direction = 0x5b;
low_output = 0x08;
low_direction = 0x5b;
static int comstick_init(void)
{
uint8_t buf[3];
static int comstick_init(void)
{
uint8_t buf[3];
+ uint32_t bytes_written;
low_output = 0x08;
low_direction = 0x0b;
low_output = 0x08;
low_direction = 0x0b;
static int stm32stick_init(void)
{
uint8_t buf[3];
static int stm32stick_init(void)
{
uint8_t buf[3];
+ uint32_t bytes_written;
low_output = 0x88;
low_direction = 0x8b;
low_output = 0x88;
low_direction = 0x8b;
static int sheevaplug_init(void)
{
uint8_t buf[3];
static int sheevaplug_init(void)
{
uint8_t buf[3];
+ uint32_t bytes_written;
low_output = 0x08;
low_direction = 0x1b;
low_output = 0x08;
low_direction = 0x1b;
static int cortino_jtag_init(void)
{
uint8_t buf[3];
static int cortino_jtag_init(void)
{
uint8_t buf[3];
+ uint32_t bytes_written;
low_output = 0x08;
low_direction = 0x1b;
low_output = 0x08;
low_direction = 0x1b;
*/
static int icebear_jtag_init(void) {
uint8_t buf[3];
*/
static int icebear_jtag_init(void) {
uint8_t buf[3];
+ uint32_t bytes_written;
low_direction = 0x0b; /* output: TCK TDI TMS; input: TDO */
low_output = 0x08; /* high: TMS; low: TCK TDI */
low_direction = 0x0b; /* output: TCK TDI TMS; input: TDO */
low_output = 0x08; /* high: TMS; low: TCK TDI */
- u32 jlink_caps, jlink_max_size;
+ uint32_t jlink_caps, jlink_max_size;
/* query hardware version */
jlink_simple_command(EMU_CMD_VERSION);
/* query hardware version */
jlink_simple_command(EMU_CMD_VERSION);
return ERROR_JTAG_DEVICE_ERROR;
}
return ERROR_JTAG_DEVICE_ERROR;
}
- u32 jlink_hw_version = buf_get_u32(usb_in_buffer, 0, 32);
- u32 major_revision = (jlink_hw_version / 10000) % 100;
+ uint32_t jlink_hw_version = buf_get_u32(usb_in_buffer, 0, 32);
+ uint32_t major_revision = (jlink_hw_version / 10000) % 100;
if (major_revision >= 5)
jlink_hw_jtag_version = 3;
if (major_revision >= 5)
jlink_hw_jtag_version = 3;
if (index >= JLINK_TAP_BUFFER_SIZE)
{
LOG_ERROR("jlink_tap_append_step: overflow");
if (index >= JLINK_TAP_BUFFER_SIZE)
{
LOG_ERROR("jlink_tap_append_step: overflow");
- *(u32 *)0xFFFFFFFF = 0;
+ *(uint32_t *)0xFFFFFFFF = 0;
/// Is this TAP currently enabled?
bool enabled;
int ir_length; /**< size of instruction register */
/// Is this TAP currently enabled?
bool enabled;
int ir_length; /**< size of instruction register */
+ uint32_t ir_capture_value;
uint8_t* expected; /**< Capture-IR expected value */
uint8_t* expected; /**< Capture-IR expected value */
+ uint32_t ir_capture_mask;
uint8_t* expected_mask; /**< Capture-IR expected mask */
uint8_t* expected_mask; /**< Capture-IR expected mask */
/**< device identification code */
/// Array of expected identification codes */
/**< device identification code */
/// Array of expected identification codes */
+ uint32_t* expected_ids;
/// Number of expected identification codes
uint8_t expected_ids_cnt;
/// Number of expected identification codes
uint8_t expected_ids_cnt;
*
**/
extern tap_state_t jtag_get_end_state(void);
*
**/
extern tap_state_t jtag_get_end_state(void);
-extern void jtag_add_sleep(u32 us);
+extern void jtag_add_sleep(uint32_t us);
*/
extern void jtag_check_value_mask(scan_field_t *field, uint8_t *value, uint8_t *mask);
*/
extern void jtag_check_value_mask(scan_field_t *field, uint8_t *value, uint8_t *mask);
-extern void jtag_sleep(u32 us);
+extern void jtag_sleep(uint32_t us);
/*
* The JTAG subsystem defines a number of error codes,
/*
* The JTAG subsystem defines a number of error codes,
* clocking data back in. Patches gladly accepted!
*/
extern void jtag_add_dr_out(jtag_tap_t* tap,
* clocking data back in. Patches gladly accepted!
*/
extern void jtag_add_dr_out(jtag_tap_t* tap,
- int num_fields, const int* num_bits, const u32* value,
+ int num_fields, const int* num_bits, const uint32_t* value,
}
extern void interface_jtag_add_dr_out(jtag_tap_t* tap,
}
extern void interface_jtag_add_dr_out(jtag_tap_t* tap,
- int num_fields, const int* num_bits, const u32* value,
+ int num_fields, const int* num_bits, const uint32_t* value,
tap_state_t end_state);
extern void interface_jtag_add_callback(jtag_callback1_t f, uint8_t *in);
tap_state_t end_state);
extern void interface_jtag_add_callback(jtag_callback1_t f, uint8_t *in);
*/
extern int interface_jtag_add_reset(int trst, int srst);
extern int interface_jtag_set_end_state(tap_state_t endstate);
*/
extern int interface_jtag_add_reset(int trst, int srst);
extern int interface_jtag_set_end_state(tap_state_t endstate);
-extern int interface_jtag_add_sleep(u32 us);
+extern int interface_jtag_add_sleep(uint32_t us);
extern int interface_jtag_add_clocks(int num_cycles);
extern int interface_jtag_execute_queue(void);
extern int interface_jtag_add_clocks(int num_cycles);
extern int interface_jtag_execute_queue(void);
static __inline__ void interface_jtag_add_dr_out_core(jtag_tap_t *target_tap,
int num_fields,
const int *num_bits,
static __inline__ void interface_jtag_add_dr_out_core(jtag_tap_t *target_tap,
int num_fields,
const int *num_bits,
enum tap_state end_state)
{
/* synchronously do the operation here */
enum tap_state end_state)
{
/* synchronously do the operation here */
static __inline__ void interface_jtag_add_dr_out(jtag_tap_t *target_tap,
int num_fields,
const int *num_bits,
static __inline__ void interface_jtag_add_dr_out(jtag_tap_t *target_tap,
int num_fields,
const int *num_bits,
enum tap_state end_state)
{
/* synchronously do the operation here */
enum tap_state end_state)
{
/* synchronously do the operation here */
-int interface_jtag_add_sleep(u32 us)
+int interface_jtag_add_sleep(uint32_t us)
{
jtag_sleep(us);
return ERROR_OK;
{
jtag_sleep(us);
return ERROR_OK;
0x80, 0xA0, 0xA8, 0xB0, 0xC0, 0xE0
};
0x80, 0xA0, 0xA8, 0xB0, 0xC0, 0xE0
};
-static int presto_write(uint8_t *buf, u32 size)
+static int presto_write(uint8_t *buf, uint32_t size)
{
#if BUILD_PRESTO_FTD2XX == 1
DWORD ftbytes;
{
#if BUILD_PRESTO_FTD2XX == 1
DWORD ftbytes;
}
#elif BUILD_PRESTO_LIBFTDI == 1
}
#elif BUILD_PRESTO_LIBFTDI == 1
if ((presto->retval = ftdi_write_data(&presto->ftdic, buf, size)) < 0)
{
LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&presto->ftdic));
if ((presto->retval = ftdi_write_data(&presto->ftdic, buf, size)) < 0)
{
LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&presto->ftdic));
- LOG_ERROR("couldn't write the requested number of bytes to PRESTO (%u < %u)", (u32)ftbytes, size);
+ LOG_ERROR("couldn't write the requested number of bytes to PRESTO (%u < %u)", (uint32_t)ftbytes, size);
return ERROR_JTAG_DEVICE_ERROR;
}
return ERROR_OK;
}
return ERROR_JTAG_DEVICE_ERROR;
}
return ERROR_OK;
}
-static int presto_read(uint8_t* buf, u32 size)
+static int presto_read(uint8_t* buf, uint32_t size)
{
#if BUILD_PRESTO_FTD2XX == 1
DWORD ftbytes;
{
#if BUILD_PRESTO_FTD2XX == 1
DWORD ftbytes;
}
#elif BUILD_PRESTO_LIBFTDI == 1
}
#elif BUILD_PRESTO_LIBFTDI == 1
struct timeval timeout, now;
gettimeofday(&timeout, NULL);
struct timeval timeout, now;
gettimeofday(&timeout, NULL);
if (ftbytes != size)
{
/* this is just a warning, there might have been timeout when detecting PRESTO, which is not fatal */
if (ftbytes != size)
{
/* this is just a warning, there might have been timeout when detecting PRESTO, which is not fatal */
- LOG_WARNING("couldn't read the requested number of bytes from PRESTO (%u < %u)", (u32)ftbytes, size);
+ LOG_WARNING("couldn't read the requested number of bytes from PRESTO (%u < %u)", (uint32_t)ftbytes, size);
return ERROR_JTAG_DEVICE_ERROR;
}
return ERROR_JTAG_DEVICE_ERROR;
}
#if BUILD_PRESTO_FTD2XX == 1
static int presto_open_ftd2xx(char *req_serial)
{
#if BUILD_PRESTO_FTD2XX == 1
static int presto_open_ftd2xx(char *req_serial)
{
DWORD numdevs;
DWORD vidpid;
char devname[FT_DEVICE_NAME_LEN];
DWORD numdevs;
DWORD vidpid;
char devname[FT_DEVICE_NAME_LEN];
struct {
dtc_reply_queue_entry_t *rq_head;
dtc_reply_queue_entry_t *rq_tail;
struct {
dtc_reply_queue_entry_t *rq_head;
dtc_reply_queue_entry_t *rq_tail;
- u32 cmd_index;
- u32 reply_index;
+ uint32_t cmd_index;
+ uint32_t reply_index;
uint8_t cmd_buffer[USB_EP2BANK_SIZE];
} dtc_queue;
uint8_t cmd_buffer[USB_EP2BANK_SIZE];
} dtc_queue;
- u32 length;
- u32 buffer;
+ uint32_t length;
+ uint32_t buffer;
break;
case NTAP_OPT_EXPECTED_ID:
{
break;
case NTAP_OPT_EXPECTED_ID:
{
+ uint32_t *new_expected_ids;
e = Jim_GetOpt_Wide( goi, &w );
if( e != JIM_OK) {
e = Jim_GetOpt_Wide( goi, &w );
if( e != JIM_OK) {
- new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
+ new_expected_ids = malloc(sizeof(uint32_t) * (pTap->expected_ids_cnt + 1));
if (new_expected_ids == NULL) {
Jim_SetResult_sprintf( goi->interp, "no memory");
return JIM_ERR;
}
if (new_expected_ids == NULL) {
Jim_SetResult_sprintf( goi->interp, "no memory");
return JIM_ERR;
}
- memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
+ memcpy(new_expected_ids, pTap->expected_ids, sizeof(uint32_t) * pTap->expected_ids_cnt);
new_expected_ids[pTap->expected_ids_cnt] = w;
new_expected_ids[pTap->expected_ids_cnt] = w;
command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
while( tap ){
command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
while( tap ){
- u32 expected, expected_mask, cur_instr, ii;
+ uint32_t expected, expected_mask, cur_instr, ii;
expected = buf_get_u32(tap->expected, 0, tap->ir_length);
expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
expected = buf_get_u32(tap->expected, 0, tap->ir_length);
expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
fields[i].num_bits = field_size;
fields[i].out_value = malloc(CEIL(field_size, 8));
fields[i].num_bits = field_size;
fields[i].out_value = malloc(CEIL(field_size, 8));
retval = parse_u32(args[i * 2 + 1], &value);
if (ERROR_OK != retval)
goto error_return;
retval = parse_u32(args[i * 2 + 1], &value);
if (ERROR_OK != retval)
goto error_return;
static __inline__ void interface_jtag_add_dr_out_core(jtag_tap_t *target_tap,
int num_fields,
const int *num_bits,
static __inline__ void interface_jtag_add_dr_out_core(jtag_tap_t *target_tap,
int num_fields,
const int *num_bits,
enum tap_state end_state)
{
enum tap_state pause_state = TAP_DRSHIFT;
enum tap_state end_state)
{
enum tap_state pause_state = TAP_DRSHIFT;
static __inline__ void interface_jtag_add_dr_out(jtag_tap_t *target_tap,
int num_fields,
const int *num_bits,
static __inline__ void interface_jtag_add_dr_out(jtag_tap_t *target_tap,
int num_fields,
const int *num_bits,
enum tap_state end_state)
{
enum tap_state end_state)
{
}
}
/* mask away unused bits for easier debugging */
}
}
/* mask away unused bits for easier debugging */
- value&=~(((u32)0xffffffff)<<k);
+ value&=~(((uint32_t)0xffffffff)<<k);
shiftValueInner(shiftState, pause_state, k, value);
shiftValueInner(shiftState, pause_state, k, value);
return zy1000_jtag_add_clocks(num_cycles, cmd_queue_cur_state, cmd_queue_cur_state);
}
return zy1000_jtag_add_clocks(num_cycles, cmd_queue_cur_state, cmd_queue_cur_state);
}
-int interface_jtag_add_sleep(u32 us)
+int interface_jtag_add_sleep(uint32_t us)
{
jtag_sleep(us);
return ERROR_OK;
{
jtag_sleep(us);
return ERROR_OK;
-static int virtex2_set_instr(jtag_tap_t *tap, u32 new_instr)
+static int virtex2_set_instr(jtag_tap_t *tap, uint32_t new_instr)
{
if (tap == NULL)
return ERROR_FAIL;
{
if (tap == NULL)
return ERROR_FAIL;
}
static int virtex2_send_32(struct pld_device_s *pld_device,
}
static int virtex2_send_32(struct pld_device_s *pld_device,
- int num_words, u32 *words)
+ int num_words, uint32_t *words)
{
virtex2_pld_device_t *virtex2_info = pld_device->driver_priv;
scan_field_t scan_field;
{
virtex2_pld_device_t *virtex2_info = pld_device->driver_priv;
scan_field_t scan_field;
static __inline__ void virtexflip32(uint8_t *in)
{
static __inline__ void virtexflip32(uint8_t *in)
{
- *((u32 *)in) = flip_u32(le_to_h_u32(in), 32);
+ *((uint32_t *)in) = flip_u32(le_to_h_u32(in), 32);
}
static int virtex2_receive_32(struct pld_device_s *pld_device,
}
static int virtex2_receive_32(struct pld_device_s *pld_device,
- int num_words, u32 *words)
+ int num_words, uint32_t *words)
{
virtex2_pld_device_t *virtex2_info = pld_device->driver_priv;
scan_field_t scan_field;
{
virtex2_pld_device_t *virtex2_info = pld_device->driver_priv;
scan_field_t scan_field;
-static int virtex2_read_stat(struct pld_device_s *pld_device, u32 *status)
+static int virtex2_read_stat(struct pld_device_s *pld_device, uint32_t *status)
{
pld_device_t *device;
virtex2_pld_device_t *virtex2_info;
{
pld_device_t *device;
virtex2_pld_device_t *virtex2_info;
static int read_section(FILE *input_file, int length_size, char section,
static int read_section(FILE *input_file, int length_size, char section,
- u32 *buffer_length, uint8_t **buffer)
+ uint32_t *buffer_length, uint8_t **buffer)
{
uint8_t length_buffer[4];
int length;
{
uint8_t length_buffer[4];
int length;
uint8_t *part_name;
uint8_t *date;
uint8_t *time;
uint8_t *part_name;
uint8_t *date;
uint8_t *time;
uint8_t *data;
} xilinx_bit_file_t;
uint8_t *data;
} xilinx_bit_file_t;
int gdb_read_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
char *separator;
int gdb_read_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
char *separator;
- u32 addr = 0;
- u32 len = 0;
+ uint32_t addr = 0;
+ uint32_t len = 0;
uint8_t *buffer;
char *hex_buffer;
uint8_t *buffer;
char *hex_buffer;
{
hex_buffer = malloc(len * 2 + 1);
{
hex_buffer = malloc(len * 2 + 1);
for (i = 0; i < len; i++)
{
uint8_t t = buffer[i];
for (i = 0; i < len; i++)
{
uint8_t t = buffer[i];
int gdb_write_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
char *separator;
int gdb_write_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
char *separator;
- u32 addr = 0;
- u32 len = 0;
+ uint32_t addr = 0;
+ uint32_t len = 0;
int retval;
/* skip command character */
int retval;
/* skip command character */
sscanf(separator + 2*i, "%2x", &tmp);
buffer[i] = tmp;
}
sscanf(separator + 2*i, "%2x", &tmp);
buffer[i] = tmp;
}
int gdb_write_memory_binary_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
char *separator;
int gdb_write_memory_binary_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
char *separator;
- u32 addr = 0;
- u32 len = 0;
+ uint32_t addr = 0;
+ uint32_t len = 0;
int gdb_step_continue_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
int current = 0;
int gdb_step_continue_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
int current = 0;
+ uint32_t address = 0x0;
int retval=ERROR_OK;
LOG_DEBUG("-");
int retval=ERROR_OK;
LOG_DEBUG("-");
int type;
enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */;
enum watchpoint_rw wp_type;
int type;
enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */;
enum watchpoint_rw wp_type;
- u32 address;
- u32 size;
+ uint32_t address;
+ uint32_t size;
char *separator;
int retval;
char *separator;
int retval;
int gdb_calc_blocksize(flash_bank_t *bank)
{
int gdb_calc_blocksize(flash_bank_t *bank)
{
- u32 i;
- u32 block_size = 0xffffffff;
+ uint32_t i;
+ uint32_t block_size = 0xffffffff;
/* loop through all sectors and return smallest sector size */
/* loop through all sectors and return smallest sector size */
- for (i = 0; i < (u32)bank->num_sectors; i++)
+ for (i = 0; i < (uint32_t)bank->num_sectors; i++)
{
if (bank->sectors[i].size < block_size)
block_size = bank->sectors[i].size;
{
if (bank->sectors[i].size < block_size)
block_size = bank->sectors[i].size;
cmd = malloc((packet_size - 6)/2 + 1);
for (i=0; i < (packet_size - 6)/2; i++)
{
cmd = malloc((packet_size - 6)/2 + 1);
for (i=0; i < (packet_size - 6)/2; i++)
{
sscanf(packet + 6 + 2*i, "%2x", &tmp);
cmd[i] = tmp;
}
sscanf(packet + 6 + 2*i, "%2x", &tmp);
cmd[i] = tmp;
}
int retval;
char gdb_reply[10];
char *separator;
int retval;
char gdb_reply[10];
char *separator;
- u32 checksum;
- u32 addr = 0;
- u32 len = 0;
+ uint32_t checksum;
+ uint32_t addr = 0;
+ uint32_t len = 0;
/* skip command character */
packet += 5;
/* skip command character */
packet += 5;
qsort(banks, flash_get_bank_count(), sizeof(flash_bank_t *), compare_bank);
qsort(banks, flash_get_bank_count(), sizeof(flash_bank_t *), compare_bank);
for (i=0; i<flash_get_bank_count(); i++)
{
p = banks[i];
for (i=0; i<flash_get_bank_count(); i++)
{
p = banks[i];
if (!strcmp(packet, "vFlashDone"))
{
if (!strcmp(packet, "vFlashDone"))
{
/* process the flashing buffer. No need to erase as GDB
* always issues a vFlashErase first. */
/* process the flashing buffer. No need to erase as GDB
* always issues a vFlashErase first. */
{
tap_state_t from;
tap_state_t to;
{
tap_state_t from;
tap_state_t to;
tap_state_t paths[8];
}svf_statemove_t;
tap_state_t paths[8];
}svf_statemove_t;
unsigned svf_get_mask_u32(int bitlen)
{
unsigned svf_get_mask_u32(int bitlen)
{
case XWAIT:
{
/* expected in stream:
case XWAIT:
{
/* expected in stream:
- XWAIT <uint8_t wait_state> <uint8_t end_state> <u32 usecs>
+ XWAIT <uint8_t wait_state> <uint8_t end_state> <uint32_t usecs>
case XWAITSTATE:
{
/* expected in stream:
case XWAITSTATE:
{
/* expected in stream:
- XWAITSTATE <uint8_t wait_state> <uint8_t end_state> <u32 clock_count> <u32 usecs>
+ XWAITSTATE <uint8_t wait_state> <uint8_t end_state> <uint32_t clock_count> <uint32_t usecs>
case LCOUNT:
{
/* expected in stream:
case LCOUNT:
{
/* expected in stream:
- LCOUNT <u32 loop_count>
+ LCOUNT <uint32_t loop_count>
case LDELAY:
{
/* expected in stream:
case LDELAY:
{
/* expected in stream:
- LDELAY <uint8_t wait_state> <u32 clock_count> <u32 usecs_to_sleep>
+ LDELAY <uint8_t wait_state> <uint32_t clock_count> <uint32_t usecs_to_sleep>
*/
uint8_t state;
uint8_t clock_buf[4];
*/
uint8_t state;
uint8_t clock_buf[4];
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)