Functions and variables that are not used outside the file should
be declared as static.
Change-Id: I58c9f5557d4809db9ccc34d32182c3797f825da1
Signed-off-by: Antonio Borneo <borneo.antonio@gmail.com>
Reviewed-on: http://openocd.zylin.com/5896
Tested-by: jenkins
14 files changed:
#ifdef _WIN32
PROCESS_INFORMATION proc_info;
#ifdef _WIN32
PROCESS_INFORMATION proc_info;
-HANDLE aice_pipe_output[2];
-HANDLE aice_pipe_input[2];
+static HANDLE aice_pipe_output[2];
+static HANDLE aice_pipe_input[2];
static int aice_pipe_write(const void *buffer, int count)
{
static int aice_pipe_write(const void *buffer, int count)
{
-int aice_pipe_output[2];
-int aice_pipe_input[2];
+static int aice_pipe_output[2];
+static int aice_pipe_input[2];
static int aice_pipe_write(const void *buffer, int count)
{
static int aice_pipe_write(const void *buffer, int count)
{
-int aice_read_dtr(uint8_t target_id, uint32_t *data)
+static int aice_read_dtr(uint8_t target_id, uint32_t *data)
-int aice_read_dtr_to_buffer(uint8_t target_id, uint32_t buffer_idx)
+static int aice_read_dtr_to_buffer(uint8_t target_id, uint32_t buffer_idx)
-int aice_write_dtr(uint8_t target_id, uint32_t data)
+static int aice_write_dtr(uint8_t target_id, uint32_t data)
-int aice_write_dtr_from_buffer(uint8_t target_id, uint32_t buffer_idx)
+static int aice_write_dtr_from_buffer(uint8_t target_id, uint32_t buffer_idx)
-int aice_read_misc(uint8_t target_id, uint32_t address, uint32_t *data)
+static int aice_read_misc(uint8_t target_id, uint32_t address, uint32_t *data)
-int aice_write_misc(uint8_t target_id, uint32_t address, uint32_t data)
+static int aice_write_misc(uint8_t target_id, uint32_t address, uint32_t data)
-int aice_read_edmsr(uint8_t target_id, uint32_t address, uint32_t *data)
+static int aice_read_edmsr(uint8_t target_id, uint32_t address, uint32_t *data)
-int aice_write_edmsr(uint8_t target_id, uint32_t address, uint32_t data)
+static int aice_write_edmsr(uint8_t target_id, uint32_t address, uint32_t data)
-int aice_write_mem_b(uint8_t target_id, uint32_t address, uint32_t data)
+static int aice_write_mem_b(uint8_t target_id, uint32_t address, uint32_t data)
-int aice_write_mem_h(uint8_t target_id, uint32_t address, uint32_t data)
+static int aice_write_mem_h(uint8_t target_id, uint32_t address, uint32_t data)
-int aice_write_mem(uint8_t target_id, uint32_t address, uint32_t data)
+static int aice_write_mem(uint8_t target_id, uint32_t address, uint32_t data)
-int aice_fastread_mem(uint8_t target_id, uint8_t *word, uint32_t num_of_words)
+static int aice_fastread_mem(uint8_t target_id, uint8_t *word, uint32_t num_of_words)
-int aice_fastwrite_mem(uint8_t target_id, const uint8_t *word, uint32_t num_of_words)
+static int aice_fastwrite_mem(uint8_t target_id, const uint8_t *word, uint32_t num_of_words)
-int aice_read_mem_b(uint8_t target_id, uint32_t address, uint32_t *data)
+static int aice_read_mem_b(uint8_t target_id, uint32_t address, uint32_t *data)
-int aice_read_mem_h(uint8_t target_id, uint32_t address, uint32_t *data)
+static int aice_read_mem_h(uint8_t target_id, uint32_t address, uint32_t *data)
-int aice_read_mem(uint8_t target_id, uint32_t address, uint32_t *data)
+static int aice_read_mem(uint8_t target_id, uint32_t address, uint32_t *data)
-int aice_batch_buffer_read(uint8_t buf_index, uint32_t *word, uint32_t num_of_words)
+static int aice_batch_buffer_read(uint8_t buf_index, uint32_t *word, uint32_t num_of_words)
typedef int (*read_mem_func_t)(uint32_t coreid, uint32_t address, uint32_t *data);
typedef int (*write_mem_func_t)(uint32_t coreid, uint32_t address, uint32_t data);
typedef int (*read_mem_func_t)(uint32_t coreid, uint32_t address, uint32_t *data);
typedef int (*write_mem_func_t)(uint32_t coreid, uint32_t address, uint32_t data);
-struct aice_nds32_info core_info[AICE_MAX_NUM_CORE];
+static struct aice_nds32_info core_info[AICE_MAX_NUM_CORE];
static uint8_t total_num_of_core;
static char *custom_srst_script;
static uint8_t total_num_of_core;
static char *custom_srst_script;
}
/** Append a new TAP to the chain of all taps. */
}
/** Append a new TAP to the chain of all taps. */
-void jtag_tap_add(struct jtag_tap *t)
+static void jtag_tap_add(struct jtag_tap *t)
{
unsigned jtag_num_taps = 0;
{
unsigned jtag_num_taps = 0;
-void ft232r_increase_buf_size(size_t new_buf_size)
+static void ft232r_increase_buf_size(size_t new_buf_size)
{
uint8_t *new_buf_ptr;
if (new_buf_size >= ft232r_buf_size) {
{
uint8_t *new_buf_ptr;
if (new_buf_size >= ft232r_buf_size) {
#endif
/* configuration */
#endif
/* configuration */
+static uint16_t gw16012_port;
/* interface variables
*/
/* interface variables
*/
static int opendous_usb_read(struct opendous_jtag *opendous_jtag);
/* helper functions */
static int opendous_usb_read(struct opendous_jtag *opendous_jtag);
/* helper functions */
-int opendous_get_version_info(void);
+static int opendous_get_version_info(void);
#ifdef _DEBUG_USB_COMMS_
static void opendous_debug_buffer(uint8_t *buffer, int length);
#ifdef _DEBUG_USB_COMMS_
static void opendous_debug_buffer(uint8_t *buffer, int length);
-int opendous_get_version_info(void)
+static int opendous_get_version_info(void)
static void stlink_usb_init_buffer(void *handle, uint8_t direction, uint32_t size);
static int stlink_swim_status(void *handle);
static void stlink_usb_init_buffer(void *handle, uint8_t direction, uint32_t size);
static int stlink_swim_status(void *handle);
-void stlink_dump_speed_map(const struct speed_map *map, unsigned int map_size);
+static void stlink_dump_speed_map(const struct speed_map *map, unsigned int map_size);
static int stlink_get_com_freq(void *handle, bool is_jtag, struct speed_map *map);
static int stlink_speed(void *handle, int khz, bool query);
static int stlink_usb_open_ap(void *handle, unsigned short apsel);
static int stlink_get_com_freq(void *handle, bool is_jtag, struct speed_map *map);
static int stlink_speed(void *handle, int khz, bool query);
static int stlink_usb_open_ap(void *handle, unsigned short apsel);
return stlink_khz_to_speed_map_jtag[speed_index].speed;
}
return stlink_khz_to_speed_map_jtag[speed_index].speed;
}
-void stlink_dump_speed_map(const struct speed_map *map, unsigned int map_size)
+static void stlink_dump_speed_map(const struct speed_map *map, unsigned int map_size)
* based on the length (0x1a = 26) we could easily decide if we have to fixup the serial
* and then we have just to convert the raw data into printable characters using sprintf
*/
* based on the length (0x1a = 26) we could easily decide if we have to fixup the serial
* and then we have just to convert the raw data into printable characters using sprintf
*/
-char *stlink_usb_get_alternate_serial(libusb_device_handle *device,
+static char *stlink_usb_get_alternate_serial(libusb_device_handle *device,
struct libusb_device_descriptor *dev_desc)
{
int usb_retval;
struct libusb_device_descriptor *dev_desc)
{
int usb_retval;
return stlink_usb_open(param, stlink_get_mode(param->transport), fd);
}
return stlink_usb_open(param, stlink_get_mode(param->transport), fd);
}
-int stlink_config_trace(void *handle, bool enabled,
+static int stlink_config_trace(void *handle, bool enabled,
enum tpiu_pin_protocol pin_protocol, uint32_t port_size,
unsigned int *trace_freq, unsigned int traceclkin_freq,
uint16_t *prescaler)
enum tpiu_pin_protocol pin_protocol, uint32_t port_size,
unsigned int *trace_freq, unsigned int traceclkin_freq,
uint16_t *prescaler)
/**************************** Function Prototypes *****************************/
/* USB helper functions */
/**************************** Function Prototypes *****************************/
/* USB helper functions */
-int ulink_usb_open(struct ulink **device);
-int ulink_usb_close(struct ulink **device);
+static int ulink_usb_open(struct ulink **device);
+static int ulink_usb_close(struct ulink **device);
/* ULINK MCU (Cypress EZ-USB) specific functions */
/* ULINK MCU (Cypress EZ-USB) specific functions */
-int ulink_cpu_reset(struct ulink *device, unsigned char reset_bit);
-int ulink_load_firmware_and_renumerate(struct ulink **device, const char *filename,
+static int ulink_cpu_reset(struct ulink *device, unsigned char reset_bit);
+static int ulink_load_firmware_and_renumerate(struct ulink **device, const char *filename,
-int ulink_load_firmware(struct ulink *device, const char *filename);
-int ulink_write_firmware_section(struct ulink *device,
+static int ulink_load_firmware(struct ulink *device, const char *filename);
+static int ulink_write_firmware_section(struct ulink *device,
struct image *firmware_image, int section_index);
/* Generic helper functions */
struct image *firmware_image, int section_index);
/* Generic helper functions */
-void ulink_print_signal_states(uint8_t input_signals, uint8_t output_signals);
+static void ulink_print_signal_states(uint8_t input_signals, uint8_t output_signals);
/* OpenULINK command generation helper functions */
/* OpenULINK command generation helper functions */
-int ulink_allocate_payload(struct ulink_cmd *ulink_cmd, int size,
+static int ulink_allocate_payload(struct ulink_cmd *ulink_cmd, int size,
enum ulink_payload_direction direction);
/* OpenULINK command queue helper functions */
enum ulink_payload_direction direction);
/* OpenULINK command queue helper functions */
-int ulink_get_queue_size(struct ulink *device,
+static int ulink_get_queue_size(struct ulink *device,
enum ulink_payload_direction direction);
enum ulink_payload_direction direction);
-void ulink_clear_queue(struct ulink *device);
-int ulink_append_queue(struct ulink *device, struct ulink_cmd *ulink_cmd);
-int ulink_execute_queued_commands(struct ulink *device, int timeout);
+static void ulink_clear_queue(struct ulink *device);
+static int ulink_append_queue(struct ulink *device, struct ulink_cmd *ulink_cmd);
+static int ulink_execute_queued_commands(struct ulink *device, int timeout);
static void ulink_print_queue(struct ulink *device);
static void ulink_print_queue(struct ulink *device);
-int ulink_append_scan_cmd(struct ulink *device,
+static int ulink_append_scan_cmd(struct ulink *device,
enum scan_type scan_type,
int scan_size_bits,
uint8_t *tdi,
enum scan_type scan_type,
int scan_size_bits,
uint8_t *tdi,
uint8_t tms_sequence_end,
struct jtag_command *origin,
bool postprocess);
uint8_t tms_sequence_end,
struct jtag_command *origin,
bool postprocess);
-int ulink_append_clock_tms_cmd(struct ulink *device, uint8_t count,
+static int ulink_append_clock_tms_cmd(struct ulink *device, uint8_t count,
-int ulink_append_clock_tck_cmd(struct ulink *device, uint16_t count);
-int ulink_append_get_signals_cmd(struct ulink *device);
-int ulink_append_set_signals_cmd(struct ulink *device, uint8_t low,
+static int ulink_append_clock_tck_cmd(struct ulink *device, uint16_t count);
+static int ulink_append_get_signals_cmd(struct ulink *device);
+static int ulink_append_set_signals_cmd(struct ulink *device, uint8_t low,
-int ulink_append_sleep_cmd(struct ulink *device, uint32_t us);
-int ulink_append_configure_tck_cmd(struct ulink *device,
+static int ulink_append_sleep_cmd(struct ulink *device, uint32_t us);
+static int ulink_append_configure_tck_cmd(struct ulink *device,
int delay_scan_in,
int delay_scan_out,
int delay_scan_io,
int delay_tck,
int delay_tms);
int delay_scan_in,
int delay_scan_out,
int delay_scan_io,
int delay_tck,
int delay_tms);
-int ulink_append_led_cmd(struct ulink *device, uint8_t led_state);
-int ulink_append_test_cmd(struct ulink *device);
+static int __attribute__((unused)) ulink_append_led_cmd(struct ulink *device, uint8_t led_state);
+static int ulink_append_test_cmd(struct ulink *device);
/* OpenULINK TCK frequency helper functions */
/* OpenULINK TCK frequency helper functions */
-int ulink_calculate_delay(enum ulink_delay_type type, long f, int *delay);
+static int ulink_calculate_delay(enum ulink_delay_type type, long f, int *delay);
/* Interface between OpenULINK and OpenOCD */
static void ulink_set_end_state(tap_state_t endstate);
/* Interface between OpenULINK and OpenOCD */
static void ulink_set_end_state(tap_state_t endstate);
-int ulink_queue_statemove(struct ulink *device);
+static int ulink_queue_statemove(struct ulink *device);
-int ulink_queue_scan(struct ulink *device, struct jtag_command *cmd);
-int ulink_queue_tlr_reset(struct ulink *device, struct jtag_command *cmd);
-int ulink_queue_runtest(struct ulink *device, struct jtag_command *cmd);
-int ulink_queue_reset(struct ulink *device, struct jtag_command *cmd);
-int ulink_queue_pathmove(struct ulink *device, struct jtag_command *cmd);
-int ulink_queue_sleep(struct ulink *device, struct jtag_command *cmd);
-int ulink_queue_stableclocks(struct ulink *device, struct jtag_command *cmd);
+static int ulink_queue_scan(struct ulink *device, struct jtag_command *cmd);
+static int ulink_queue_tlr_reset(struct ulink *device, struct jtag_command *cmd);
+static int ulink_queue_runtest(struct ulink *device, struct jtag_command *cmd);
+static int ulink_queue_reset(struct ulink *device, struct jtag_command *cmd);
+static int ulink_queue_pathmove(struct ulink *device, struct jtag_command *cmd);
+static int ulink_queue_sleep(struct ulink *device, struct jtag_command *cmd);
+static int ulink_queue_stableclocks(struct ulink *device, struct jtag_command *cmd);
-int ulink_post_process_scan(struct ulink_cmd *ulink_cmd);
-int ulink_post_process_queue(struct ulink *device);
+static int ulink_post_process_scan(struct ulink_cmd *ulink_cmd);
+static int ulink_post_process_queue(struct ulink *device);
/* adapter driver functions */
static int ulink_execute_queue(void);
/* adapter driver functions */
static int ulink_execute_queue(void);
/****************************** Global Variables ******************************/
/****************************** Global Variables ******************************/
-struct ulink *ulink_handle;
+static struct ulink *ulink_handle;
/**************************** USB helper functions ****************************/
/**************************** USB helper functions ****************************/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_usb_open(struct ulink **device)
+static int ulink_usb_open(struct ulink **device)
{
ssize_t num_devices, i;
bool found;
{
ssize_t num_devices, i;
bool found;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_usb_close(struct ulink **device)
+static int ulink_usb_close(struct ulink **device)
{
if (libusb_release_interface((*device)->usb_device_handle, 0) != 0)
return ERROR_FAIL;
{
if (libusb_release_interface((*device)->usb_device_handle, 0) != 0)
return ERROR_FAIL;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_cpu_reset(struct ulink *device, unsigned char reset_bit)
+static int ulink_cpu_reset(struct ulink *device, unsigned char reset_bit)
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_load_firmware_and_renumerate(struct ulink **device,
+static int ulink_load_firmware_and_renumerate(struct ulink **device,
const char *filename, uint32_t delay)
{
int ret;
const char *filename, uint32_t delay)
{
int ret;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_load_firmware(struct ulink *device, const char *filename)
+static int ulink_load_firmware(struct ulink *device, const char *filename)
{
struct image ulink_firmware_image;
int ret, i;
{
struct image ulink_firmware_image;
int ret, i;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_write_firmware_section(struct ulink *device,
+static int ulink_write_firmware_section(struct ulink *device,
struct image *firmware_image, int section_index)
{
uint16_t addr, size, bytes_remaining, chunk_size;
struct image *firmware_image, int section_index)
{
uint16_t addr, size, bytes_remaining, chunk_size;
* @param input_signals input signal states as returned by CMD_GET_SIGNALS
* @param output_signals output signal states as returned by CMD_GET_SIGNALS
*/
* @param input_signals input signal states as returned by CMD_GET_SIGNALS
* @param output_signals output signal states as returned by CMD_GET_SIGNALS
*/
-void ulink_print_signal_states(uint8_t input_signals, uint8_t output_signals)
+static void ulink_print_signal_states(uint8_t input_signals, uint8_t output_signals)
{
LOG_INFO("ULINK signal states: TDI: %i, TDO: %i, TMS: %i, TCK: %i, TRST: %i,"
" SRST: %i",
{
LOG_INFO("ULINK signal states: TDI: %i, TDO: %i, TMS: %i, TCK: %i, TRST: %i,"
" SRST: %i",
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_allocate_payload(struct ulink_cmd *ulink_cmd, int size,
+static int ulink_allocate_payload(struct ulink_cmd *ulink_cmd, int size,
enum ulink_payload_direction direction)
{
uint8_t *payload;
enum ulink_payload_direction direction)
{
uint8_t *payload;
* @return the number of bytes currently stored in the queue for the specified
* direction.
*/
* @return the number of bytes currently stored in the queue for the specified
* direction.
*/
-int ulink_get_queue_size(struct ulink *device,
+static int ulink_get_queue_size(struct ulink *device,
enum ulink_payload_direction direction)
{
struct ulink_cmd *current = device->queue_start;
enum ulink_payload_direction direction)
{
struct ulink_cmd *current = device->queue_start;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-void ulink_clear_queue(struct ulink *device)
+static void ulink_clear_queue(struct ulink *device)
{
struct ulink_cmd *current = device->queue_start;
struct ulink_cmd *next = NULL;
{
struct ulink_cmd *current = device->queue_start;
struct ulink_cmd *next = NULL;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_append_queue(struct ulink *device, struct ulink_cmd *ulink_cmd)
+static int ulink_append_queue(struct ulink *device, struct ulink_cmd *ulink_cmd)
{
int newsize_out, newsize_in;
int ret = ERROR_OK;
{
int newsize_out, newsize_in;
int ret = ERROR_OK;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_execute_queued_commands(struct ulink *device, int timeout)
+static int ulink_execute_queued_commands(struct ulink *device, int timeout)
{
struct ulink_cmd *current;
int ret, i, index_out, index_in, count_out, count_in, transferred;
{
struct ulink_cmd *current;
int ret, i, index_out, index_in, count_out, count_in, transferred;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_append_scan_cmd(struct ulink *device, enum scan_type scan_type,
+static int ulink_append_scan_cmd(struct ulink *device, enum scan_type scan_type,
int scan_size_bits, uint8_t *tdi, uint8_t *tdo_start, uint8_t *tdo,
uint8_t tms_count_start, uint8_t tms_sequence_start, uint8_t tms_count_end,
uint8_t tms_sequence_end, struct jtag_command *origin, bool postprocess)
int scan_size_bits, uint8_t *tdi, uint8_t *tdo_start, uint8_t *tdo,
uint8_t tms_count_start, uint8_t tms_sequence_start, uint8_t tms_count_end,
uint8_t tms_sequence_end, struct jtag_command *origin, bool postprocess)
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_append_clock_tms_cmd(struct ulink *device, uint8_t count,
+static int ulink_append_clock_tms_cmd(struct ulink *device, uint8_t count,
uint8_t sequence)
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
uint8_t sequence)
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_append_clock_tck_cmd(struct ulink *device, uint16_t count)
+static int ulink_append_clock_tck_cmd(struct ulink *device, uint16_t count)
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
int ret;
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
int ret;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_append_get_signals_cmd(struct ulink *device)
+static int ulink_append_get_signals_cmd(struct ulink *device)
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
int ret;
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
int ret;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_append_set_signals_cmd(struct ulink *device, uint8_t low,
+static int ulink_append_set_signals_cmd(struct ulink *device, uint8_t low,
uint8_t high)
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
uint8_t high)
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_append_sleep_cmd(struct ulink *device, uint32_t us)
+static int ulink_append_sleep_cmd(struct ulink *device, uint32_t us)
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
int ret;
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
int ret;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_append_configure_tck_cmd(struct ulink *device, int delay_scan_in,
+static int ulink_append_configure_tck_cmd(struct ulink *device, int delay_scan_in,
int delay_scan_out, int delay_scan_io, int delay_tck, int delay_tms)
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
int delay_scan_out, int delay_scan_io, int delay_tck, int delay_tms)
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_append_led_cmd(struct ulink *device, uint8_t led_state)
+static int ulink_append_led_cmd(struct ulink *device, uint8_t led_state)
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
int ret;
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
int ret;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_append_test_cmd(struct ulink *device)
+static int ulink_append_test_cmd(struct ulink *device)
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
int ret;
{
struct ulink_cmd *cmd = calloc(1, sizeof(struct ulink_cmd));
int ret;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_calculate_delay(enum ulink_delay_type type, long f, int *delay)
+static int ulink_calculate_delay(enum ulink_delay_type type, long f, int *delay)
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_queue_statemove(struct ulink *device)
+static int ulink_queue_statemove(struct ulink *device)
{
uint8_t tms_sequence, tms_count;
int ret;
{
uint8_t tms_sequence, tms_count;
int ret;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_queue_scan(struct ulink *device, struct jtag_command *cmd)
+static int ulink_queue_scan(struct ulink *device, struct jtag_command *cmd)
{
uint32_t scan_size_bits, scan_size_bytes, bits_last_scan;
uint32_t scans_max_payload, bytecount;
{
uint32_t scan_size_bits, scan_size_bytes, bits_last_scan;
uint32_t scans_max_payload, bytecount;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_queue_tlr_reset(struct ulink *device, struct jtag_command *cmd)
+static int ulink_queue_tlr_reset(struct ulink *device, struct jtag_command *cmd)
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_queue_runtest(struct ulink *device, struct jtag_command *cmd)
+static int ulink_queue_runtest(struct ulink *device, struct jtag_command *cmd)
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_queue_reset(struct ulink *device, struct jtag_command *cmd)
+static int ulink_queue_reset(struct ulink *device, struct jtag_command *cmd)
{
uint8_t low = 0, high = 0;
{
uint8_t low = 0, high = 0;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_queue_pathmove(struct ulink *device, struct jtag_command *cmd)
+static int ulink_queue_pathmove(struct ulink *device, struct jtag_command *cmd)
{
int ret, i, num_states, batch_size, state_count;
tap_state_t *path;
{
int ret, i, num_states, batch_size, state_count;
tap_state_t *path;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_queue_sleep(struct ulink *device, struct jtag_command *cmd)
+static int ulink_queue_sleep(struct ulink *device, struct jtag_command *cmd)
{
/* IMPORTANT! Due to the time offset in command execution introduced by
* command queueing, this needs to be implemented in the ULINK device */
{
/* IMPORTANT! Due to the time offset in command execution introduced by
* command queueing, this needs to be implemented in the ULINK device */
* @param device pointer to struct ulink identifying ULINK driver instance.
* @param cmd pointer to the command that shall be executed.
*/
* @param device pointer to struct ulink identifying ULINK driver instance.
* @param cmd pointer to the command that shall be executed.
*/
-int ulink_queue_stableclocks(struct ulink *device, struct jtag_command *cmd)
+static int ulink_queue_stableclocks(struct ulink *device, struct jtag_command *cmd)
{
int ret;
unsigned num_cycles;
{
int ret;
unsigned num_cycles;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_post_process_scan(struct ulink_cmd *ulink_cmd)
+static int ulink_post_process_scan(struct ulink_cmd *ulink_cmd)
{
struct jtag_command *cmd = ulink_cmd->cmd_origin;
int ret;
{
struct jtag_command *cmd = ulink_cmd->cmd_origin;
int ret;
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
* @return on success: ERROR_OK
* @return on failure: ERROR_FAIL
*/
-int ulink_post_process_queue(struct ulink *device)
+static int ulink_post_process_queue(struct ulink *device)
{
struct ulink_cmd *current;
struct jtag_command *openocd_cmd;
{
struct ulink_cmd *current;
struct jtag_command *openocd_cmd;
*
* Returns pin value (1 means driven high, 0 mean driven low)
*/
*
* Returns pin value (1 means driven high, 0 mean driven low)
*/
-bool ublast_compute_pin(enum gpio_steer steer)
+static bool ublast_compute_pin(enum gpio_steer steer)
{
switch (steer) {
case FIXED_0:
{
switch (steer) {
case FIXED_0:
#include "usbtoxxx.h"
#include "usbtoxxx_internal.h"
#include "usbtoxxx.h"
#include "usbtoxxx_internal.h"
-RESULT usbtoswd_read_callback(void *p, uint8_t *src, uint8_t *processed)
+static RESULT usbtoswd_read_callback(void *p, uint8_t *src, uint8_t *processed)
{
struct versaloon_pending_t *pending = (struct versaloon_pending_t *)p;
{
struct versaloon_pending_t *pending = (struct versaloon_pending_t *)p;
-RESULT usbtoswd_write_callback(void *p, uint8_t *src, uint8_t *processed)
+static RESULT usbtoswd_write_callback(void *p, uint8_t *src, uint8_t *processed)
{
struct versaloon_pending_t *pending = (struct versaloon_pending_t *)p;
{
struct versaloon_pending_t *pending = (struct versaloon_pending_t *)p;
-const char *types_name[96] = {
+static const char *types_name[96] = {
"usbtousart", "usbtospi", "usbtoi2c", "usbtogpio", "usbtocan", "usbtopwm",
"usbtoadc", "usbtodac",
"usbtomicrowire", "usbtoswim", "usbtodusi", N_A, N_A, N_A, "usbtopower", "usbtodelay",
"usbtousart", "usbtospi", "usbtoi2c", "usbtogpio", "usbtocan", "usbtopwm",
"usbtoadc", "usbtodac",
"usbtomicrowire", "usbtoswim", "usbtodusi", N_A, N_A, N_A, "usbtopower", "usbtodelay",
static uint16_t usbtoxxx_current_cmd_index;
static uint8_t *usbtoxxx_buffer;
static uint16_t usbtoxxx_current_cmd_index;
static uint8_t *usbtoxxx_buffer;
-uint16_t collect_index;
-uint8_t collect_cmd;
+static uint16_t collect_index;
+static uint8_t collect_cmd;
static uint8_t poll_nesting;
struct usbtoxxx_context_t {
static uint8_t poll_nesting;
struct usbtoxxx_context_t {
versaloon_pending_idx = c->versaloon_pending_idx;
}
versaloon_pending_idx = c->versaloon_pending_idx;
}
-RESULT usbtoxxx_validate_current_command_type(void)
+static RESULT usbtoxxx_validate_current_command_type(void)
{
if (type_pre > 0) {
/* not the first command */
{
if (type_pre > 0) {
/* not the first command */
return (usbtoxxx_abilities[cmd / 8] & (1 << (cmd % 8))) > 0;
}
return (usbtoxxx_abilities[cmd / 8] & (1 << (cmd % 8))) > 0;
}
-RESULT usbtoxxx_ensure_buffer_size(uint16_t cmdlen)
+static RESULT usbtoxxx_ensure_buffer_size(uint16_t cmdlen)
{
/* check free space, commit if not enough */
if (((usbtoxxx_buffer_index + usbtoxxx_current_cmd_index + cmdlen)
{
/* check free space, commit if not enough */
if (((usbtoxxx_buffer_index + usbtoxxx_current_cmd_index + cmdlen)
libusb_device_handle *versaloon_usb_device_handle;
static uint32_t versaloon_usb_to = VERSALOON_TIMEOUT;
libusb_device_handle *versaloon_usb_device_handle;
static uint32_t versaloon_usb_to = VERSALOON_TIMEOUT;
-RESULT versaloon_init(void);
-RESULT versaloon_fini(void);
-RESULT versaloon_get_target_voltage(uint16_t *voltage);
-RESULT versaloon_set_target_voltage(uint16_t voltage);
-RESULT versaloon_delay_ms(uint16_t ms);
-RESULT versaloon_delay_us(uint16_t us);
+static RESULT versaloon_init(void);
+static RESULT versaloon_fini(void);
+static RESULT versaloon_get_target_voltage(uint16_t *voltage);
+static RESULT versaloon_set_target_voltage(uint16_t voltage);
+static RESULT versaloon_delay_ms(uint16_t ms);
+static RESULT versaloon_delay_us(uint16_t us);
struct versaloon_interface_t versaloon_interface = {
.init = versaloon_init,
struct versaloon_interface_t versaloon_interface = {
.init = versaloon_init,
}
#define VERSALOON_RETRY_CNT 10
}
#define VERSALOON_RETRY_CNT 10
-RESULT versaloon_init(void)
+static RESULT versaloon_init(void)
{
uint16_t ret = 0;
uint8_t retry;
{
uint16_t ret = 0;
uint8_t retry;
return versaloon_get_target_voltage(&ret);
}
return versaloon_get_target_voltage(&ret);
}
-RESULT versaloon_fini(void)
+static RESULT versaloon_fini(void)
{
if (versaloon_usb_device_handle != NULL) {
usbtoxxx_fini();
{
if (versaloon_usb_device_handle != NULL) {
usbtoxxx_fini();
-RESULT versaloon_set_target_voltage(uint16_t voltage)
+static RESULT versaloon_set_target_voltage(uint16_t voltage)
{
usbtopwr_init(0);
usbtopwr_config(0);
{
usbtopwr_init(0);
usbtopwr_config(0);
return usbtoxxx_execute_command();
}
return usbtoxxx_execute_command();
}
-RESULT versaloon_get_target_voltage(uint16_t *voltage)
+static RESULT versaloon_get_target_voltage(uint16_t *voltage)
-RESULT versaloon_delay_ms(uint16_t ms)
+static RESULT versaloon_delay_ms(uint16_t ms)
{
return usbtodelay_delay(ms | 0x8000);
}
{
return usbtodelay_delay(ms | 0x8000);
}
-RESULT versaloon_delay_us(uint16_t us)
+static RESULT versaloon_delay_us(uint16_t us)
{
return usbtodelay_delay(us & 0x7FFF);
}
{
return usbtodelay_delay(us & 0x7FFF);
}
#define CMD_STABLECLOCKS 4
/* Array to convert from OpenOCD tap_state_t to XDS JTAG state */
#define CMD_STABLECLOCKS 4
/* Array to convert from OpenOCD tap_state_t to XDS JTAG state */
-const uint32_t xds_jtag_state[] = {
+static const uint32_t xds_jtag_state[] = {
XDS_JTAG_STATE_EXIT2_DR, /* TAP_DREXIT2 = 0x0 */
XDS_JTAG_STATE_EXIT1_DR, /* TAP_DREXIT1 = 0x1 */
XDS_JTAG_STATE_SHIFT_DR, /* TAP_DRSHIFT = 0x2 */
XDS_JTAG_STATE_EXIT2_DR, /* TAP_DREXIT2 = 0x0 */
XDS_JTAG_STATE_EXIT1_DR, /* TAP_DREXIT1 = 0x1 */
XDS_JTAG_STATE_SHIFT_DR, /* TAP_DRSHIFT = 0x2 */
-int hl_interface_config_trace(bool enabled, enum tpiu_pin_protocol pin_protocol,
+static int hl_interface_config_trace(bool enabled, enum tpiu_pin_protocol pin_protocol,
uint32_t port_size, unsigned int *trace_freq,
unsigned int traceclkin_freq, uint16_t *prescaler)
{
uint32_t port_size, unsigned int *trace_freq,
unsigned int traceclkin_freq, uint16_t *prescaler)
{
-int hl_interface_poll_trace(uint8_t *buf, size_t *size)
+static int hl_interface_poll_trace(uint8_t *buf, size_t *size)
{
if (hl_if.layout->api->poll_trace)
return hl_if.layout->api->poll_trace(hl_if.handle, buf, size);
{
if (hl_if.layout->api->poll_trace)
return hl_if.layout->api->poll_trace(hl_if.handle, buf, size);
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)