interesting
/
riscv-openocd
mirror of https://github.com/riscv/riscv-openocd.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #1018 from en-sc/en-sc/from_upstream 

Merge up to efdd5e0 from upstream
This commit is contained in:
Evgeniy Naydanov 2024-02-24 15:55:18 +03:00 committed by GitHub
parent 9f4c0ba1cc bfedb42adf
commit 3c88a95d44
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
42 changed files with 256 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
doc/openocd.texi
View File

@ -3474,6 +3474,15 @@ Currently valid @var{variant} values include:
The USB device description string of the adapter. The USB device description string of the adapter.
This value is only used with the standard variant. This value is only used with the standard variant.
@end deffn @end deffn
@deffn {Config Command} {openjtag vid_pid} vid pid
The USB vendor ID and product ID of the adapter. If not specified, default
0x0403:0x6001 is used.
This value is only used with the standard variant.
@example
openjtag vid_pid 0x403 0x6014
@end example
@end deffn
@end deffn @end deffn
@ -9055,9 +9064,10 @@ echo "Downloading kernel -- please wait"
@end example @end example
@end deffn @end deffn
@deffn {Command} {log_output} [filename | "default"] @deffn {Command} {log_output} [filename | 'default']
Redirect logging to @var{filename} or set it back to default output; Redirect logging to @var{filename}. If used without an argument or
the default log output channel is stderr. @var{filename} is set to 'default' log output channel is set to
stderr.
@end deffn @end deffn
@deffn {Command} {add_script_search_dir} [directory] @deffn {Command} {add_script_search_dir} [directory]

58
src/helper/jep106.inc
View File

@ -2,13 +2,13 @@
/* /*
* The manufacturer's standard identification code list appears in JEP106. * The manufacturer's standard identification code list appears in JEP106.
* Copyright (c) 2023 JEDEC. All rights reserved. * Copyright (c) 2024 JEDEC. All rights reserved.
* *
* JEP106 is regularly updated. For the current manufacturer's standard * JEP106 is regularly updated. For the current manufacturer's standard
* identification code list, please visit the JEDEC website at www.jedec.org . * identification code list, please visit the JEDEC website at www.jedec.org .
*/ */
/* This file is aligned to revision JEP106BH September 2023. */ /* This file is aligned to revision JEP106BI January 2024. */
/* "NXP (Philips)" is reported below, while missing since JEP106BG */ /* "NXP (Philips)" is reported below, while missing since JEP106BG */
@ -1621,7 +1621,7 @@
[12][0x5f - 1] = "Sitrus Technology", [12][0x5f - 1] = "Sitrus Technology",
[12][0x60 - 1] = "AnHui Conner Storage Co Ltd", [12][0x60 - 1] = "AnHui Conner Storage Co Ltd",
[12][0x61 - 1] = "Rochester Electronics", [12][0x61 - 1] = "Rochester Electronics",
[12][0x62 - 1] = "Wuxi Petabyte Technologies Co Ltd", [12][0x62 - 1] = "Wuxi Smart Memories Technologies Co",
[12][0x63 - 1] = "Star Memory", [12][0x63 - 1] = "Star Memory",
[12][0x64 - 1] = "Agile Memory Technology Co Ltd", [12][0x64 - 1] = "Agile Memory Technology Co Ltd",
[12][0x65 - 1] = "MEJEC", [12][0x65 - 1] = "MEJEC",
@ -1864,7 +1864,7 @@
[14][0x56 - 1] = "Exacta Technologies Ltd", [14][0x56 - 1] = "Exacta Technologies Ltd",
[14][0x57 - 1] = "Synology", [14][0x57 - 1] = "Synology",
[14][0x58 - 1] = "Trium Elektronik Bilgi Islem San Ve Dis", [14][0x58 - 1] = "Trium Elektronik Bilgi Islem San Ve Dis",
[14][0x59 - 1] = "Shenzhen Hippstor Technology Co Ltd", [14][0x59 - 1] = "Wuxi HippStor Technology Co Ltd",
[14][0x5a - 1] = "SSCT", [14][0x5a - 1] = "SSCT",
[14][0x5b - 1] = "Sichuan Heentai Semiconductor Co Ltd", [14][0x5b - 1] = "Sichuan Heentai Semiconductor Co Ltd",
[14][0x5c - 1] = "Zhejiang University", [14][0x5c - 1] = "Zhejiang University",
@ -1888,4 +1888,54 @@
[14][0x6e - 1] = "Chemgdu EG Technology Co Ltd", [14][0x6e - 1] = "Chemgdu EG Technology Co Ltd",
[14][0x6f - 1] = "AGI Technology", [14][0x6f - 1] = "AGI Technology",
[14][0x70 - 1] = "Syntiant", [14][0x70 - 1] = "Syntiant",
[14][0x71 - 1] = "AOC",
[14][0x72 - 1] = "GamePP",
[14][0x73 - 1] = "Yibai Electronic Technologies",
[14][0x74 - 1] = "Hangzhou Rencheng Trading Co Ltd",
[14][0x75 - 1] = "HOGE Technology Co Ltd",
[14][0x76 - 1] = "United Micro Technology (Shenzhen) Co",
[14][0x77 - 1] = "Fabric of Truth Inc",
[14][0x78 - 1] = "Epitech",
[14][0x79 - 1] = "Elitestek",
[14][0x7a - 1] = "Cornelis Networks Inc",
[14][0x7b - 1] = "WingSemi Technologies Co Ltd",
[14][0x7c - 1] = "ForwardEdge ASIC",
[14][0x7d - 1] = "Beijing Future Imprint Technology Co Ltd",
[14][0x7e - 1] = "Fine Made Microelectronics Group Co Ltd",
[15][0x01 - 1] = "Changxin Memory Technology (Shanghai)",
[15][0x02 - 1] = "Synconv",
[15][0x03 - 1] = "MULTIUNIT",
[15][0x04 - 1] = "Zero ASIC Corporation",
[15][0x05 - 1] = "NTT Innovative Devices Corporation",
[15][0x06 - 1] = "Xbstor",
[15][0x07 - 1] = "Shenzhen South Electron Co Ltd",
[15][0x08 - 1] = "Iontra Inc",
[15][0x09 - 1] = "SIEFFI Inc",
[15][0x0a - 1] = "HK Winston Electronics Co Limited",
[15][0x0b - 1] = "Anhui SunChip Semiconductor Technology",
[15][0x0c - 1] = "HaiLa Technologies Inc",
[15][0x0d - 1] = "AUTOTALKS",
[15][0x0e - 1] = "Shenzhen Ranshuo Technology Co Limited",
[15][0x0f - 1] = "ScaleFlux",
[15][0x10 - 1] = "XC Memory",
[15][0x11 - 1] = "Guangzhou Beimu Technology Co., Ltd",
[15][0x12 - 1] = "Rays Semiconductor Nanjing Co Ltd",
[15][0x13 - 1] = "Milli-Centi Intelligence Technology Jiangsu",
[15][0x14 - 1] = "Zilia Technologioes",
[15][0x15 - 1] = "Incore Semiconductors",
[15][0x16 - 1] = "Kinetic Technologies",
[15][0x17 - 1] = "Nanjing Houmo Technology Co Ltd",
[15][0x18 - 1] = "Suzhou Yige Technology Co Ltd",
[15][0x19 - 1] = "Shenzhen Techwinsemi Technology Co Ltd",
[15][0x1a - 1] = "Pure Array Technology (Shanghai) Co. Ltd",
[15][0x1b - 1] = "Shenzhen Techwinsemi Technology Udstore",
[15][0x1c - 1] = "RISE MODE",
[15][0x1d - 1] = "NEWREESTAR",
[15][0x1e - 1] = "Hangzhou Hualan Microeletronique Co Ltd",
[15][0x1f - 1] = "Senscomm Semiconductor Co Ltd",
[15][0x20 - 1] = "Holt Integrated Circuits",
[15][0x21 - 1] = "Tenstorrent Inc",
[15][0x22 - 1] = "SkyeChip",
[15][0x23 - 1] = "Guangzhou Kaishile Trading Co Ltd",
[15][0x24 - 1] = "Jing Pai Digital Technology (Shenzhen) Co",
/* EOF */ /* EOF */

31
src/helper/log.c
View File

@ -214,31 +214,28 @@ COMMAND_HANDLER(handle_debug_level_command)
COMMAND_HANDLER(handle_log_output_command) COMMAND_HANDLER(handle_log_output_command)
{ {
if (CMD_ARGC == 0 || (CMD_ARGC == 1 && strcmp(CMD_ARGV[0], "default") == 0)) { if (CMD_ARGC > 1)
if (log_output != stderr && log_output) { return ERROR_COMMAND_SYNTAX_ERROR;
/* Close previous log file, if it was open and wasn't stderr. */
fclose(log_output); FILE *file;
} if (CMD_ARGC == 1 && strcmp(CMD_ARGV[0], "default") != 0) {
log_output = stderr; file = fopen(CMD_ARGV[0], "w");
LOG_DEBUG("set log_output to default");
return ERROR_OK;
}
if (CMD_ARGC == 1) {
FILE *file = fopen(CMD_ARGV[0], "w");
if (!file) { if (!file) {
LOG_ERROR("failed to open output log '%s'", CMD_ARGV[0]); command_print(CMD, "failed to open output log \"%s\"", CMD_ARGV[0]);
return ERROR_FAIL; return ERROR_FAIL;
} }
command_print(CMD, "set log_output to \"%s\"", CMD_ARGV[0]);
} else {
file = stderr;
command_print(CMD, "set log_output to default");
}
if (log_output != stderr && log_output) { if (log_output != stderr && log_output) {
/* Close previous log file, if it was open and wasn't stderr. */ /* Close previous log file, if it was open and wasn't stderr. */
fclose(log_output); fclose(log_output);
} }
log_output = file; log_output = file;
LOG_DEBUG("set log_output to \"%s\"", CMD_ARGV[0]);
return ERROR_OK; return ERROR_OK;
}
return ERROR_COMMAND_SYNTAX_ERROR;
} }
static const struct command_registration log_command_handlers[] = { static const struct command_registration log_command_handlers[] = {
@ -247,7 +244,7 @@ static const struct command_registration log_command_handlers[] = {
.handler = handle_log_output_command, .handler = handle_log_output_command,
.mode = COMMAND_ANY, .mode = COMMAND_ANY,
.help = "redirect logging to a file (default: stderr)", .help = "redirect logging to a file (default: stderr)",
.usage = "[file_name | \"default\"]", .usage = "[file_name | 'default']",
}, },
{ {
.name = "debug_level", .name = "debug_level",

22
src/jtag/adapter.c
View File

@ -94,8 +94,9 @@ static void adapter_driver_gpios_init(void)
return; return;
for (int i = 0; i < ADAPTER_GPIO_IDX_NUM; ++i) { for (int i = 0; i < ADAPTER_GPIO_IDX_NUM; ++i) {
adapter_config.gpios[i].gpio_num = -1; /* Use ADAPTER_GPIO_NOT_SET as the sentinel 'unset' value. */
adapter_config.gpios[i].chip_num = -1; adapter_config.gpios[i].gpio_num = ADAPTER_GPIO_NOT_SET;
adapter_config.gpios[i].chip_num = ADAPTER_GPIO_NOT_SET;
if (gpio_map[i].direction == ADAPTER_GPIO_DIRECTION_INPUT) if (gpio_map[i].direction == ADAPTER_GPIO_DIRECTION_INPUT)
adapter_config.gpios[i].init_state = ADAPTER_GPIO_INIT_STATE_INPUT; adapter_config.gpios[i].init_state = ADAPTER_GPIO_INIT_STATE_INPUT;
} }
@ -848,6 +849,11 @@ static COMMAND_HELPER(helper_adapter_gpio_print_config, enum adapter_gpio_config
const char *pull = ""; const char *pull = "";
const char *init_state = ""; const char *init_state = "";
if (gpio_config->gpio_num == ADAPTER_GPIO_NOT_SET) {
command_print(CMD, "adapter gpio %s: not configured", gpio_map[gpio_idx].name);
return ERROR_OK;
}
switch (gpio_map[gpio_idx].direction) { switch (gpio_map[gpio_idx].direction) {
case ADAPTER_GPIO_DIRECTION_INPUT: case ADAPTER_GPIO_DIRECTION_INPUT:
dir = "input"; dir = "input";
@ -900,8 +906,8 @@ static COMMAND_HELPER(helper_adapter_gpio_print_config, enum adapter_gpio_config
} }
} }
command_print(CMD, "adapter gpio %s (%s): num %d, chip %d, active-%s%s%s%s", command_print(CMD, "adapter gpio %s (%s): num %u, chip %d, active-%s%s%s%s",
gpio_map[gpio_idx].name, dir, gpio_config->gpio_num, gpio_config->chip_num, active_state, gpio_map[gpio_idx].name, dir, gpio_config->gpio_num, (int)gpio_config->chip_num, active_state,
drive, pull, init_state); drive, pull, init_state);
return ERROR_OK; return ERROR_OK;
@ -942,9 +948,7 @@ COMMAND_HANDLER(adapter_gpio_config_handler)
LOG_DEBUG("Processing %s", CMD_ARGV[i]); LOG_DEBUG("Processing %s", CMD_ARGV[i]);
if (isdigit(*CMD_ARGV[i])) { if (isdigit(*CMD_ARGV[i])) {
int gpio_num; /* Use a meaningful output parameter for more helpful error messages */ COMMAND_PARSE_NUMBER(uint, CMD_ARGV[i], gpio_config->gpio_num);
COMMAND_PARSE_NUMBER(int, CMD_ARGV[i], gpio_num);
gpio_config->gpio_num = gpio_num;
++i; ++i;
continue; continue;
} }
@ -955,9 +959,7 @@ COMMAND_HANDLER(adapter_gpio_config_handler)
return ERROR_FAIL; return ERROR_FAIL;
} }
LOG_DEBUG("-chip arg is %s", CMD_ARGV[i + 1]); LOG_DEBUG("-chip arg is %s", CMD_ARGV[i + 1]);
int chip_num; /* Use a meaningful output parameter for more helpful error messages */ COMMAND_PARSE_NUMBER(uint, CMD_ARGV[i + 1], gpio_config->chip_num);
COMMAND_PARSE_NUMBER(int, CMD_ARGV[i + 1], chip_num);
gpio_config->chip_num = chip_num;
i += 2; i += 2;
continue; continue;
} }

7
src/jtag/adapter.h
View File

@ -10,6 +10,7 @@
#include <stdbool.h> #include <stdbool.h>
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <limits.h>
/** Supported output drive modes for adaptor GPIO */ /** Supported output drive modes for adaptor GPIO */
enum adapter_gpio_drive_mode { enum adapter_gpio_drive_mode {
@ -56,8 +57,8 @@ enum adapter_gpio_config_index {
/** Configuration options for a single GPIO */ /** Configuration options for a single GPIO */
struct adapter_gpio_config { struct adapter_gpio_config {
int gpio_num; unsigned int gpio_num;
int chip_num; unsigned int chip_num;
enum adapter_gpio_drive_mode drive; /* For outputs only */ enum adapter_gpio_drive_mode drive; /* For outputs only */
enum adapter_gpio_init_state init_state; enum adapter_gpio_init_state init_state;
bool active_low; bool active_low;
@ -121,4 +122,6 @@ const char *adapter_gpio_get_name(enum adapter_gpio_config_index idx);
*/ */
const struct adapter_gpio_config *adapter_gpio_get_config(void); const struct adapter_gpio_config *adapter_gpio_get_config(void);
#define ADAPTER_GPIO_NOT_SET UINT_MAX
#endif /* OPENOCD_JTAG_ADAPTER_H */ #endif /* OPENOCD_JTAG_ADAPTER_H */

7
src/jtag/commands.c
View File

@ -33,7 +33,7 @@ struct cmd_queue_page {
static struct cmd_queue_page *cmd_queue_pages; static struct cmd_queue_page *cmd_queue_pages;
static struct cmd_queue_page *cmd_queue_pages_tail; static struct cmd_queue_page *cmd_queue_pages_tail;
struct jtag_command *jtag_command_queue; static struct jtag_command *jtag_command_queue;
static struct jtag_command **next_command_pointer = &jtag_command_queue; static struct jtag_command **next_command_pointer = &jtag_command_queue;
void jtag_queue_command(struct jtag_command *cmd) void jtag_queue_command(struct jtag_command *cmd)
@ -147,6 +147,11 @@ void jtag_command_queue_reset(void)
next_command_pointer = &jtag_command_queue; next_command_pointer = &jtag_command_queue;
} }
struct jtag_command *jtag_command_queue_get(void)
{
return jtag_command_queue;
}
/** /**
* Copy a struct scan_field for insertion into the queue. * Copy a struct scan_field for insertion into the queue.
* *

4
src/jtag/commands.h
View File

@ -149,13 +149,11 @@ struct jtag_command {
struct jtag_command *next; struct jtag_command *next;
}; };
/** The current queue of jtag_command_s structures. */
extern struct jtag_command *jtag_command_queue;
void *cmd_queue_alloc(size_t size); void *cmd_queue_alloc(size_t size);
void jtag_queue_command(struct jtag_command *cmd); void jtag_queue_command(struct jtag_command *cmd);
void jtag_command_queue_reset(void); void jtag_command_queue_reset(void);
struct jtag_command *jtag_command_queue_get(void);
void jtag_scan_field_clone(struct scan_field *dst, const struct scan_field *src); void jtag_scan_field_clone(struct scan_field *dst, const struct scan_field *src);
enum scan_type jtag_scan_type(const struct scan_command *cmd); enum scan_type jtag_scan_type(const struct scan_command *cmd);

4
src/jtag/core.c
View File

@ -951,9 +951,9 @@ int default_interface_jtag_execute_queue(void)
return ERROR_OK; return ERROR_OK;
} }
int result = adapter_driver->jtag_ops->execute_queue(); struct jtag_command *cmd = jtag_command_queue_get();
int result = adapter_driver->jtag_ops->execute_queue(cmd);
struct jtag_command *cmd = jtag_command_queue;
while (debug_level >= LOG_LVL_DEBUG_IO && cmd) { while (debug_level >= LOG_LVL_DEBUG_IO && cmd) {
switch (cmd->type) { switch (cmd->type) {
case JTAG_SCAN: case JTAG_SCAN:

15
src/jtag/drivers/am335xgpio.c
View File

@ -86,9 +86,7 @@ static const struct adapter_gpio_config *adapter_gpio_config;
static bool is_gpio_config_valid(const struct adapter_gpio_config *gpio_config) static bool is_gpio_config_valid(const struct adapter_gpio_config *gpio_config)
{ {
return gpio_config->chip_num >= 0 return gpio_config->chip_num < AM335XGPIO_NUM_GPIO_CHIPS
&& gpio_config->chip_num < AM335XGPIO_NUM_GPIO_CHIPS
&& gpio_config->gpio_num >= 0
&& gpio_config->gpio_num < AM335XGPIO_NUM_GPIO_PER_CHIP; && gpio_config->gpio_num < AM335XGPIO_NUM_GPIO_PER_CHIP;
} }
@ -249,10 +247,13 @@ static int am335xgpio_reset(int trst, int srst)
if (is_gpio_config_valid(&adapter_gpio_config[ADAPTER_GPIO_IDX_TRST])) if (is_gpio_config_valid(&adapter_gpio_config[ADAPTER_GPIO_IDX_TRST]))
set_gpio_value(&adapter_gpio_config[ADAPTER_GPIO_IDX_TRST], trst); set_gpio_value(&adapter_gpio_config[ADAPTER_GPIO_IDX_TRST], trst);
LOG_DEBUG("am335xgpio_reset(%d, %d), trst_gpio: %d %d, srst_gpio: %d %d", LOG_DEBUG("trst %d gpio: %d %d, srst %d gpio: %d %d",
trst, srst, trst,
adapter_gpio_config[ADAPTER_GPIO_IDX_TRST].chip_num, adapter_gpio_config[ADAPTER_GPIO_IDX_TRST].gpio_num, (int)adapter_gpio_config[ADAPTER_GPIO_IDX_TRST].chip_num,
adapter_gpio_config[ADAPTER_GPIO_IDX_SRST].chip_num, adapter_gpio_config[ADAPTER_GPIO_IDX_SRST].gpio_num); (int)adapter_gpio_config[ADAPTER_GPIO_IDX_TRST].gpio_num,
srst,
(int)adapter_gpio_config[ADAPTER_GPIO_IDX_SRST].chip_num,
(int)adapter_gpio_config[ADAPTER_GPIO_IDX_SRST].gpio_num);
return ERROR_OK; return ERROR_OK;
} }

4
src/jtag/drivers/amt_jtagaccel.c
View File

@ -317,9 +317,9 @@ static void amt_jtagaccel_scan(bool ir_scan, enum scan_type type, uint8_t *buffe
tap_set_state(tap_get_end_state()); tap_set_state(tap_get_end_state());
} }
static int amt_jtagaccel_execute_queue(void) static int amt_jtagaccel_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; /* currently processed command */ struct jtag_command *cmd = cmd_queue; /* currently processed command */
int scan_size; int scan_size;
enum scan_type type; enum scan_type type;
uint8_t *buffer; uint8_t *buffer;

6
src/jtag/drivers/angie.c
View File

@ -233,7 +233,7 @@ static int angie_post_process_scan(struct angie_cmd *angie_cmd);
static int angie_post_process_queue(struct angie *device); static int angie_post_process_queue(struct angie *device);
/* adapter driver functions */ /* adapter driver functions */
static int angie_execute_queue(void); static int angie_execute_queue(struct jtag_command *cmd_queue);
static int angie_khz(int khz, int *jtag_speed); static int angie_khz(int khz, int *jtag_speed);
static int angie_speed(int speed); static int angie_speed(int speed);
static int angie_speed_div(int speed, int *khz); static int angie_speed_div(int speed, int *khz);
@ -2037,9 +2037,9 @@ static int angie_post_process_queue(struct angie *device)
* @return on success: ERROR_OK * @return on success: ERROR_OK
* @return on failure: ERROR_FAIL * @return on failure: ERROR_FAIL
*/ */
static int angie_execute_queue(void) static int angie_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; struct jtag_command *cmd = cmd_queue;
int ret; int ret;
while (cmd) { while (cmd) {

4
src/jtag/drivers/arm-jtag-ew.c
View File

@ -85,9 +85,9 @@ static struct armjtagew *armjtagew_handle;
/************************************************************************** /**************************************************************************
* External interface implementation */ * External interface implementation */
static int armjtagew_execute_queue(void) static int armjtagew_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; struct jtag_command *cmd = cmd_queue;
int scan_size; int scan_size;
enum scan_type type; enum scan_type type;
uint8_t *buffer; uint8_t *buffer;

16
src/jtag/drivers/bcm2835gpio.c
View File

@ -84,10 +84,7 @@ static inline void bcm2835_delay(void)
static bool is_gpio_config_valid(enum adapter_gpio_config_index idx) static bool is_gpio_config_valid(enum adapter_gpio_config_index idx)
{ {
/* Only chip 0 is supported, accept unset value (-1) too */ /* Only chip 0 is supported, accept unset value (-1) too */
return adapter_gpio_config[idx].chip_num >= -1 return adapter_gpio_config[idx].gpio_num <= 31;
&& adapter_gpio_config[idx].chip_num <= 0
&& adapter_gpio_config[idx].gpio_num >= 0
&& adapter_gpio_config[idx].gpio_num <= 31;
} }
static void set_gpio_value(const struct adapter_gpio_config *gpio_config, int value) static void set_gpio_value(const struct adapter_gpio_config *gpio_config, int value)
@ -243,10 +240,13 @@ static int bcm2835gpio_reset(int trst, int srst)
if (is_gpio_config_valid(ADAPTER_GPIO_IDX_TRST)) if (is_gpio_config_valid(ADAPTER_GPIO_IDX_TRST))
set_gpio_value(&adapter_gpio_config[ADAPTER_GPIO_IDX_TRST], trst); set_gpio_value(&adapter_gpio_config[ADAPTER_GPIO_IDX_TRST], trst);
LOG_DEBUG("BCM2835 GPIO: bcm2835gpio_reset(%d, %d), trst_gpio: %d %d, srst_gpio: %d %d", LOG_DEBUG("trst %d gpio: %d %d, srst %d gpio: %d %d",
trst, srst, trst,
adapter_gpio_config[ADAPTER_GPIO_IDX_TRST].chip_num, adapter_gpio_config[ADAPTER_GPIO_IDX_TRST].gpio_num, (int)adapter_gpio_config[ADAPTER_GPIO_IDX_TRST].chip_num,
adapter_gpio_config[ADAPTER_GPIO_IDX_SRST].chip_num, adapter_gpio_config[ADAPTER_GPIO_IDX_SRST].gpio_num); (int)adapter_gpio_config[ADAPTER_GPIO_IDX_TRST].gpio_num,
srst,
(int)adapter_gpio_config[ADAPTER_GPIO_IDX_SRST].chip_num,
(int)adapter_gpio_config[ADAPTER_GPIO_IDX_SRST].gpio_num);
return ERROR_OK; return ERROR_OK;
} }

5
src/jtag/drivers/bitbang.c
View File

@ -15,6 +15,7 @@
#include "config.h" #include "config.h"
#endif #endif
#include <jtag/jtag.h> /* Added to avoid include loop in commands.h */
#include "bitbang.h" #include "bitbang.h"
#include <jtag/interface.h> #include <jtag/interface.h>
#include <jtag/commands.h> #include <jtag/commands.h>
@ -287,9 +288,9 @@ static void bitbang_sleep(unsigned int microseconds)
} }
} }
int bitbang_execute_queue(void) int bitbang_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; /* currently processed command */ struct jtag_command *cmd = cmd_queue; /* currently processed command */
int scan_size; int scan_size;
enum scan_type type; enum scan_type type;
uint8_t *buffer; uint8_t *buffer;

3
src/jtag/drivers/bitbang.h
View File

@ -12,6 +12,7 @@
#define OPENOCD_JTAG_DRIVERS_BITBANG_H #define OPENOCD_JTAG_DRIVERS_BITBANG_H
#include <jtag/swd.h> #include <jtag/swd.h>
#include <jtag/commands.h>
typedef enum { typedef enum {
BB_LOW, BB_LOW,
@ -64,7 +65,7 @@ struct bitbang_interface {
extern const struct swd_driver bitbang_swd; extern const struct swd_driver bitbang_swd;
int bitbang_execute_queue(void); int bitbang_execute_queue(struct jtag_command *cmd_queue);
extern struct bitbang_interface *bitbang_interface; extern struct bitbang_interface *bitbang_interface;

6
src/jtag/drivers/bitq.c
View File

@ -203,11 +203,11 @@ static void bitq_scan(struct scan_command *cmd)
bitq_scan_field(&cmd->fields[i], 1); bitq_scan_field(&cmd->fields[i], 1);
} }
int bitq_execute_queue(void) int bitq_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; /* currently processed command */ struct jtag_command *cmd = cmd_queue; /* currently processed command */
bitq_in_state.cmd = jtag_command_queue; bitq_in_state.cmd = cmd_queue;
bitq_in_state.field_idx = 0; bitq_in_state.field_idx = 0;
bitq_in_state.bit_pos = 0; bitq_in_state.bit_pos = 0;
bitq_in_state.status = ERROR_OK; bitq_in_state.status = ERROR_OK;

2
src/jtag/drivers/bitq.h
View File

@ -27,7 +27,7 @@ struct bitq_interface {
extern struct bitq_interface *bitq_interface; extern struct bitq_interface *bitq_interface;
int bitq_execute_queue(void); int bitq_execute_queue(struct jtag_command *cmd_queue);
void bitq_cleanup(void); void bitq_cleanup(void);

6
src/jtag/drivers/buspirate.c
View File

@ -20,7 +20,7 @@
#undef DEBUG_SERIAL #undef DEBUG_SERIAL
/*#define DEBUG_SERIAL */ /*#define DEBUG_SERIAL */
static int buspirate_execute_queue(void); static int buspirate_execute_queue(struct jtag_command *cmd_queue);
static int buspirate_init(void); static int buspirate_init(void);
static int buspirate_quit(void); static int buspirate_quit(void);
static int buspirate_reset(int trst, int srst); static int buspirate_reset(int trst, int srst);
@ -151,10 +151,10 @@ static int buspirate_serial_read(int fd, uint8_t *buf, int size);
static void buspirate_serial_close(int fd); static void buspirate_serial_close(int fd);
static void buspirate_print_buffer(uint8_t *buf, int size); static void buspirate_print_buffer(uint8_t *buf, int size);
static int buspirate_execute_queue(void) static int buspirate_execute_queue(struct jtag_command *cmd_queue)
{ {
/* currently processed command */ /* currently processed command */
struct jtag_command *cmd = jtag_command_queue; struct jtag_command *cmd = cmd_queue;
int scan_size; int scan_size;
enum scan_type type; enum scan_type type;
uint8_t *buffer; uint8_t *buffer;

4
src/jtag/drivers/cmsis_dap.c
View File

@ -1954,9 +1954,9 @@ static void cmsis_dap_execute_command(struct jtag_command *cmd)
} }
} }
static int cmsis_dap_execute_queue(void) static int cmsis_dap_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; struct jtag_command *cmd = cmd_queue;
while (cmd) { while (cmd) {
cmsis_dap_execute_command(cmd); cmsis_dap_execute_command(cmd);

4
src/jtag/drivers/ft232r.c
View File

@ -803,9 +803,9 @@ static void syncbb_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int
} }
} }
static int syncbb_execute_queue(void) static int syncbb_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; /* currently processed command */ struct jtag_command *cmd = cmd_queue; /* currently processed command */
int scan_size; int scan_size;
enum scan_type type; enum scan_type type;
uint8_t *buffer; uint8_t *buffer;

4
src/jtag/drivers/ftdi.c
View File

@ -702,14 +702,14 @@ static void ftdi_execute_command(struct jtag_command *cmd)
} }
} }
static int ftdi_execute_queue(void) static int ftdi_execute_queue(struct jtag_command *cmd_queue)
{ {
/* blink, if the current layout has that feature */ /* blink, if the current layout has that feature */
struct signal *led = find_signal_by_name("LED"); struct signal *led = find_signal_by_name("LED");
if (led) if (led)
ftdi_set_signal(led, '1'); ftdi_set_signal(led, '1');
for (struct jtag_command *cmd = jtag_command_queue; cmd; cmd = cmd->next) { for (struct jtag_command *cmd = cmd_queue; cmd; cmd = cmd->next) {
/* fill the write buffer with the desired command */ /* fill the write buffer with the desired command */
ftdi_execute_command(cmd); ftdi_execute_command(cmd);
} }

4
src/jtag/drivers/gw16012.c
View File

@ -270,9 +270,9 @@ static void gw16012_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int
} }
} }
static int gw16012_execute_queue(void) static int gw16012_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; /* currently processed command */ struct jtag_command *cmd = cmd_queue; /* currently processed command */
int scan_size; int scan_size;
enum scan_type type; enum scan_type type;
uint8_t *buffer; uint8_t *buffer;

8
src/jtag/drivers/jlink.c
View File

@ -276,10 +276,10 @@ static int jlink_execute_command(struct jtag_command *cmd)
return ERROR_OK; return ERROR_OK;
} }
static int jlink_execute_queue(void) static int jlink_execute_queue(struct jtag_command *cmd_queue)
{ {
int ret; int ret;
struct jtag_command *cmd = jtag_command_queue; struct jtag_command *cmd = cmd_queue;
while (cmd) { while (cmd) {
ret = jlink_execute_command(cmd); ret = jlink_execute_command(cmd);
@ -2108,7 +2108,7 @@ static int jlink_swd_switch_seq(enum swd_special_seq seq)
switch (seq) { switch (seq) {
case LINE_RESET: case LINE_RESET:
LOG_DEBUG("SWD line reset"); LOG_DEBUG_IO("SWD line reset");
s = swd_seq_line_reset; s = swd_seq_line_reset;
s_len = swd_seq_line_reset_len; s_len = swd_seq_line_reset_len;
break; break;
@ -2157,7 +2157,7 @@ static int jlink_swd_run_queue(void)
int i; int i;
int ret; int ret;
LOG_DEBUG("Executing %d queued transactions", pending_scan_results_length); LOG_DEBUG_IO("Executing %d queued transactions", pending_scan_results_length);
if (queued_retval != ERROR_OK) { if (queued_retval != ERROR_OK) {
LOG_DEBUG("Skipping due to previous errors: %d", queued_retval); LOG_DEBUG("Skipping due to previous errors: %d", queued_retval);

4
src/jtag/drivers/jtag_dpi.c
View File

@ -222,12 +222,12 @@ static int jtag_dpi_stableclocks(int cycles)
return jtag_dpi_runtest(cycles); return jtag_dpi_runtest(cycles);
} }
static int jtag_dpi_execute_queue(void) static int jtag_dpi_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd; struct jtag_command *cmd;
int ret = ERROR_OK; int ret = ERROR_OK;
for (cmd = jtag_command_queue; ret == ERROR_OK && cmd; for (cmd = cmd_queue; ret == ERROR_OK && cmd;
cmd = cmd->next) { cmd = cmd->next) {
switch (cmd->type) { switch (cmd->type) {
case JTAG_RUNTEST: case JTAG_RUNTEST:

4
src/jtag/drivers/jtag_vpi.c
View File

@ -480,12 +480,12 @@ static int jtag_vpi_stableclocks(int cycles)
return ERROR_OK; return ERROR_OK;
} }
static int jtag_vpi_execute_queue(void) static int jtag_vpi_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd; struct jtag_command *cmd;
int retval = ERROR_OK; int retval = ERROR_OK;
for (cmd = jtag_command_queue; retval == ERROR_OK && cmd; for (cmd = cmd_queue; retval == ERROR_OK && cmd;
cmd = cmd->next) { cmd = cmd->next) {
switch (cmd->type) { switch (cmd->type) {
case JTAG_RESET: case JTAG_RESET:

4
src/jtag/drivers/linuxgpiod.c
View File

@ -37,9 +37,7 @@ static const struct adapter_gpio_config *adapter_gpio_config;
*/ */
static bool is_gpio_config_valid(enum adapter_gpio_config_index idx) static bool is_gpio_config_valid(enum adapter_gpio_config_index idx)
{ {
return adapter_gpio_config[idx].chip_num >= 0 return adapter_gpio_config[idx].chip_num < 1000
&& adapter_gpio_config[idx].chip_num < 1000
&& adapter_gpio_config[idx].gpio_num >= 0
&& adapter_gpio_config[idx].gpio_num < 10000; && adapter_gpio_config[idx].gpio_num < 10000;
} }

23
src/jtag/drivers/mpsse.c
View File

@ -880,20 +880,6 @@ int mpsse_flush(struct mpsse_ctx *ctx)
retval = libusb_handle_events_timeout_completed(ctx->usb_ctx, &timeout_usb, NULL); retval = libusb_handle_events_timeout_completed(ctx->usb_ctx, &timeout_usb, NULL);
keep_alive(); keep_alive();
if (retval == LIBUSB_ERROR_NO_DEVICE || retval == LIBUSB_ERROR_INTERRUPTED)
break;
if (retval != LIBUSB_SUCCESS) {
libusb_cancel_transfer(write_transfer);
if (read_transfer)
libusb_cancel_transfer(read_transfer);
while (!write_result.done || !read_result.done) {
retval = libusb_handle_events_timeout_completed(ctx->usb_ctx,
&timeout_usb, NULL);
if (retval != LIBUSB_SUCCESS)
break;
}
}
int64_t now = timeval_ms(); int64_t now = timeval_ms();
if (now - start > warn_after) { if (now - start > warn_after) {
@ -901,6 +887,15 @@ int mpsse_flush(struct mpsse_ctx *ctx)
"ms.", now - start); "ms.", now - start);
warn_after *= 2; warn_after *= 2;
} }
if (retval == LIBUSB_ERROR_INTERRUPTED)
continue;
if (retval != LIBUSB_SUCCESS) {
libusb_cancel_transfer(write_transfer);
if (read_transfer)
libusb_cancel_transfer(read_transfer);
}
} }
error_check: error_check:

6
src/jtag/drivers/opendous.c
View File

@ -99,7 +99,7 @@ static char *opendous_type;
static const struct opendous_probe *opendous_probe; static const struct opendous_probe *opendous_probe;
/* External interface functions */ /* External interface functions */
static int opendous_execute_queue(void); static int opendous_execute_queue(struct jtag_command *cmd_queue);
static int opendous_init(void); static int opendous_init(void);
static int opendous_quit(void); static int opendous_quit(void);
@ -238,9 +238,9 @@ struct adapter_driver opendous_adapter_driver = {
.jtag_ops = &opendous_interface, .jtag_ops = &opendous_interface,
}; };
static int opendous_execute_queue(void) static int opendous_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; struct jtag_command *cmd = cmd_queue;
int scan_size; int scan_size;
enum scan_type type; enum scan_type type;
uint8_t *buffer; uint8_t *buffer;

49
src/jtag/drivers/openjtag.c
View File

@ -530,9 +530,20 @@ static int openjtag_quit(void)
static void openjtag_write_tap_buffer(void) static void openjtag_write_tap_buffer(void)
{ {
uint32_t written; uint32_t written;
uint32_t rx_expected = 0;
/* calculate expected number of return bytes */
for (int tx_offs = 0; tx_offs < usb_tx_buf_offs; tx_offs++) {
if ((usb_tx_buf[tx_offs] & 0x0F) == 6) {
rx_expected++;
tx_offs++;
} else if ((usb_tx_buf[tx_offs] & 0x0F) == 2) {
rx_expected++;
}
}
openjtag_buf_write(usb_tx_buf, usb_tx_buf_offs, &written); openjtag_buf_write(usb_tx_buf, usb_tx_buf_offs, &written);
openjtag_buf_read(usb_rx_buf, usb_tx_buf_offs, &usb_rx_buf_len); openjtag_buf_read(usb_rx_buf, rx_expected, &usb_rx_buf_len);
usb_tx_buf_offs = 0; usb_tx_buf_offs = 0;
} }
@ -660,14 +671,12 @@ static void openjtag_execute_reset(struct jtag_command *cmd)
uint8_t buf = 0x00; uint8_t buf = 0x00;
if (cmd->cmd.reset->trst) { /* Pull SRST low for 5 TCLK cycles */
buf = 0x03; if (cmd->cmd.reset->srst) {
} else {
buf |= 0x04; buf |= 0x04;
buf |= 0x05 << 4; buf |= 0x05 << 4;
}
openjtag_add_byte(buf); openjtag_add_byte(buf);
}
} }
static void openjtag_execute_sleep(struct jtag_command *cmd) static void openjtag_execute_sleep(struct jtag_command *cmd)
@ -680,8 +689,14 @@ static void openjtag_set_state(uint8_t openocd_state)
uint8_t state = openjtag_get_tap_state(openocd_state); uint8_t state = openjtag_get_tap_state(openocd_state);
uint8_t buf = 0; uint8_t buf = 0;
if (state != OPENJTAG_TAP_RESET) {
buf = 0x01; buf = 0x01;
buf |= state << 4; buf |= state << 4;
} else {
/* Force software TLR */
buf = 0x03;
}
openjtag_add_byte(buf); openjtag_add_byte(buf);
} }
@ -790,9 +805,9 @@ static void openjtag_execute_command(struct jtag_command *cmd)
} }
} }
static int openjtag_execute_queue(void) static int openjtag_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; struct jtag_command *cmd = cmd_queue;
while (cmd) { while (cmd) {
openjtag_execute_command(cmd); openjtag_execute_command(cmd);
@ -861,6 +876,17 @@ COMMAND_HANDLER(openjtag_handle_variant_command)
return ERROR_OK; return ERROR_OK;
} }
COMMAND_HANDLER(openjtag_handle_vid_pid_command)
{
if (CMD_ARGC != 2)
return ERROR_COMMAND_SYNTAX_ERROR;
COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], openjtag_vid);
COMMAND_PARSE_NUMBER(u16, CMD_ARGV[1], openjtag_pid);
return ERROR_OK;
}
static const struct command_registration openjtag_subcommand_handlers[] = { static const struct command_registration openjtag_subcommand_handlers[] = {
{ {
.name = "device_desc", .name = "device_desc",
@ -876,6 +902,13 @@ static const struct command_registration openjtag_subcommand_handlers[] = {
.help = "set the OpenJTAG variant", .help = "set the OpenJTAG variant",
.usage = "variant-string", .usage = "variant-string",
}, },
{
.name = "vid_pid",
.handler = openjtag_handle_vid_pid_command,
.mode = COMMAND_CONFIG,
.help = "USB VID and PID of the adapter",
.usage = "vid pid",
},
COMMAND_REGISTRATION_DONE COMMAND_REGISTRATION_DONE
}; };

4
src/jtag/drivers/osbdm.c
View File

@ -628,7 +628,7 @@ static int osbdm_execute_command(
return retval; return retval;
} }
static int osbdm_execute_queue(void) static int osbdm_execute_queue(struct jtag_command *cmd_queue)
{ {
int retval = ERROR_OK; int retval = ERROR_OK;
@ -637,7 +637,7 @@ static int osbdm_execute_queue(void)
LOG_ERROR("BUG: can't allocate bit queue"); LOG_ERROR("BUG: can't allocate bit queue");
retval = ERROR_FAIL; retval = ERROR_FAIL;
} else { } else {
struct jtag_command *cmd = jtag_command_queue; struct jtag_command *cmd = cmd_queue;
while (retval == ERROR_OK && cmd) { while (retval == ERROR_OK && cmd) {
retval = osbdm_execute_command(&osbdm_context, queue, cmd); retval = osbdm_execute_command(&osbdm_context, queue, cmd);

4
src/jtag/drivers/remote_bitbang.c
View File

@ -456,14 +456,14 @@ static const struct command_registration remote_bitbang_command_handlers[] = {
COMMAND_REGISTRATION_DONE COMMAND_REGISTRATION_DONE
}; };
static int remote_bitbang_execute_queue(void) static int remote_bitbang_execute_queue(struct jtag_command *cmd_queue)
{ {
/* safety: the send buffer must be empty, no leftover characters from /* safety: the send buffer must be empty, no leftover characters from
* previous transactions */ * previous transactions */
assert(remote_bitbang_send_buf_used == 0); assert(remote_bitbang_send_buf_used == 0);
/* process the JTAG command queue */ /* process the JTAG command queue */
int ret = bitbang_execute_queue(); int ret = bitbang_execute_queue(cmd_queue);
if (ret != ERROR_OK) if (ret != ERROR_OK)
return ret; return ret;

4
src/jtag/drivers/rlink.c
View File

@ -1262,9 +1262,9 @@ static int rlink_scan(struct jtag_command *cmd, enum scan_type type,
return 0; return 0;
} }
static int rlink_execute_queue(void) static int rlink_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; /* currently processed command */ struct jtag_command *cmd = cmd_queue; /* currently processed command */
int scan_size; int scan_size;
enum scan_type type; enum scan_type type;
uint8_t *buffer; uint8_t *buffer;

6
src/jtag/drivers/ulink.c
View File

@ -227,7 +227,7 @@ static int ulink_post_process_scan(struct ulink_cmd *ulink_cmd);
static int ulink_post_process_queue(struct ulink *device); static int ulink_post_process_queue(struct ulink *device);
/* adapter driver functions */ /* adapter driver functions */
static int ulink_execute_queue(void); static int ulink_execute_queue(struct jtag_command *cmd_queue);
static int ulink_khz(int khz, int *jtag_speed); static int ulink_khz(int khz, int *jtag_speed);
static int ulink_speed(int speed); static int ulink_speed(int speed);
static int ulink_speed_div(int speed, int *khz); static int ulink_speed_div(int speed, int *khz);
@ -1905,9 +1905,9 @@ static int ulink_post_process_queue(struct ulink *device)
* @return on success: ERROR_OK * @return on success: ERROR_OK
* @return on failure: ERROR_FAIL * @return on failure: ERROR_FAIL
*/ */
static int ulink_execute_queue(void) static int ulink_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; struct jtag_command *cmd = cmd_queue;
int ret; int ret;
while (cmd) { while (cmd) {

4
src/jtag/drivers/usb_blaster/usb_blaster.c
View File

@ -765,7 +765,7 @@ static void ublast_initial_wipeout(void)
tap_set_state(TAP_RESET); tap_set_state(TAP_RESET);
} }
static int ublast_execute_queue(void) static int ublast_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd; struct jtag_command *cmd;
static int first_call = 1; static int first_call = 1;
@ -776,7 +776,7 @@ static int ublast_execute_queue(void)
ublast_initial_wipeout(); ublast_initial_wipeout();
} }
for (cmd = jtag_command_queue; ret == ERROR_OK && cmd; for (cmd = cmd_queue; ret == ERROR_OK && cmd;
cmd = cmd->next) { cmd = cmd->next) {
switch (cmd->type) { switch (cmd->type) {
case JTAG_RESET: case JTAG_RESET:

4
src/jtag/drivers/usbprog.c
View File

@ -83,9 +83,9 @@ static void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag, unsigned
static void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag, int bit, int value); static void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag, int bit, int value);
/* static int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit); */ /* static int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit); */
static int usbprog_execute_queue(void) static int usbprog_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; /* currently processed command */ struct jtag_command *cmd = cmd_queue; /* currently processed command */
int scan_size; int scan_size;
enum scan_type type; enum scan_type type;
uint8_t *buffer; uint8_t *buffer;

4
src/jtag/drivers/vdebug.c
View File

@ -1046,11 +1046,11 @@ static int vdebug_jtag_div(int speed, int *khz)
return ERROR_OK; return ERROR_OK;
} }
static int vdebug_jtag_execute_queue(void) static int vdebug_jtag_execute_queue(struct jtag_command *cmd_queue)
{ {
int rc = ERROR_OK; int rc = ERROR_OK;
for (struct jtag_command *cmd = jtag_command_queue; rc == ERROR_OK && cmd; cmd = cmd->next) { for (struct jtag_command *cmd = cmd_queue; rc == ERROR_OK && cmd; cmd = cmd->next) {
switch (cmd->type) { switch (cmd->type) {
case JTAG_RUNTEST: case JTAG_RUNTEST:
rc = vdebug_jtag_runtest(cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state, !cmd->next); rc = vdebug_jtag_runtest(cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state, !cmd->next);

4
src/jtag/drivers/vsllink.c
View File

@ -84,9 +84,9 @@ static bool swd_mode;
static struct vsllink *vsllink_handle; static struct vsllink *vsllink_handle;
static int vsllink_execute_queue(void) static int vsllink_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; struct jtag_command *cmd = cmd_queue;
int scan_size; int scan_size;
enum scan_type type; enum scan_type type;
uint8_t *buffer; uint8_t *buffer;

4
src/jtag/drivers/xds110.c
View File

@ -1840,9 +1840,9 @@ static void xds110_execute_command(struct jtag_command *cmd)
} }
} }
static int xds110_execute_queue(void) static int xds110_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; struct jtag_command *cmd = cmd_queue;
while (cmd) { while (cmd) {
xds110_execute_command(cmd); xds110_execute_command(cmd);

4
src/jtag/drivers/xlnx-pcie-xvc.c
View File

@ -362,9 +362,9 @@ static int xlnx_pcie_xvc_execute_command(struct jtag_command *cmd)
return ERROR_OK; return ERROR_OK;
} }
static int xlnx_pcie_xvc_execute_queue(void) static int xlnx_pcie_xvc_execute_queue(struct jtag_command *cmd_queue)
{ {
struct jtag_command *cmd = jtag_command_queue; struct jtag_command *cmd = cmd_queue;
int ret; int ret;
while (cmd) { while (cmd) {

6
src/jtag/interface.h
View File

@ -187,10 +187,12 @@ struct jtag_interface {
#define DEBUG_CAP_TMS_SEQ (1 << 0) #define DEBUG_CAP_TMS_SEQ (1 << 0)
/** /**
* Execute queued commands. * Execute commands in the supplied queue
* @param cmd_queue - a linked list of commands to execute
* @returns ERROR_OK on success, or an error code on failure. * @returns ERROR_OK on success, or an error code on failure.
*/ */
int (*execute_queue)(void);
int (*execute_queue)(struct jtag_command *cmd_queue);
}; };
/** /**

2
src/jtag/tcl.c
View File

@ -315,7 +315,7 @@ __COMMAND_HANDLER(handle_jtag_configure)
const struct nvp *n = nvp_name2value(nvp_config_opts, CMD_ARGV[i]); const struct nvp *n = nvp_name2value(nvp_config_opts, CMD_ARGV[i]);
switch (n->value) { switch (n->value) {
case JCFG_EVENT: case JCFG_EVENT:
if (i + (is_configure ? 3 : 2) >= CMD_ARGC) { if (i + (is_configure ? 2 : 1) >= CMD_ARGC) {
command_print(CMD, "wrong # args: should be \"-event <event-name>%s\"", command_print(CMD, "wrong # args: should be \"-event <event-name>%s\"",
is_configure ? " <event-body>" : ""); is_configure ? " <event-body>" : "");
return ERROR_COMMAND_ARGUMENT_INVALID; return ERROR_COMMAND_ARGUMENT_INVALID;

46
src/target/cortex_m.c
View File

@ -1106,6 +1106,7 @@ static int cortex_m_poll(struct target *target)
static int cortex_m_halt_one(struct target *target) static int cortex_m_halt_one(struct target *target)
{ {
int retval;
LOG_TARGET_DEBUG(target, "target->state: %s", target_state_name(target)); LOG_TARGET_DEBUG(target, "target->state: %s", target_state_name(target));
if (target->state == TARGET_HALTED) { if (target->state == TARGET_HALTED) {
@ -1116,22 +1117,8 @@ static int cortex_m_halt_one(struct target *target)
if (target->state == TARGET_UNKNOWN) if (target->state == TARGET_UNKNOWN)
LOG_TARGET_WARNING(target, "target was in unknown state when halt was requested"); LOG_TARGET_WARNING(target, "target was in unknown state when halt was requested");
if (target->state == TARGET_RESET) {
if ((jtag_get_reset_config() & RESET_SRST_PULLS_TRST) && jtag_get_srst()) {
LOG_TARGET_ERROR(target, "can't request a halt while in reset if nSRST pulls nTRST");
return ERROR_TARGET_FAILURE;
} else {
/* we came here in a reset_halt or reset_init sequence
* debug entry was already prepared in cortex_m3_assert_reset()
*/
target->debug_reason = DBG_REASON_DBGRQ;
return ERROR_OK;
}
}
/* Write to Debug Halting Control and Status Register */ /* Write to Debug Halting Control and Status Register */
cortex_m_write_debug_halt_mask(target, C_HALT, 0); retval = cortex_m_write_debug_halt_mask(target, C_HALT, 0);
/* Do this really early to minimize the window where the MASKINTS erratum /* Do this really early to minimize the window where the MASKINTS erratum
* can pile up pending interrupts. */ * can pile up pending interrupts. */
@ -1139,7 +1126,7 @@ static int cortex_m_halt_one(struct target *target)
target->debug_reason = DBG_REASON_DBGRQ; target->debug_reason = DBG_REASON_DBGRQ;
return ERROR_OK; return retval;
} }
static int cortex_m_halt(struct target *target) static int cortex_m_halt(struct target *target)
@ -1620,12 +1607,13 @@ static int cortex_m_assert_reset(struct target *target)
} }
/* some cores support connecting while srst is asserted /* some cores support connecting while srst is asserted
* use that mode is it has been configured */ * use that mode if it has been configured */
bool srst_asserted = false; bool srst_asserted = false;
if ((jtag_reset_config & RESET_HAS_SRST) && if ((jtag_reset_config & RESET_HAS_SRST) &&
((jtag_reset_config & RESET_SRST_NO_GATING) || !armv7m->debug_ap)) { ((jtag_reset_config & RESET_SRST_NO_GATING)
|| (!armv7m->debug_ap && !target->defer_examine))) {
/* If we have no debug_ap, asserting SRST is the only thing /* If we have no debug_ap, asserting SRST is the only thing
* we can do now */ * we can do now */
adapter_assert_reset(); adapter_assert_reset();
@ -1705,9 +1693,8 @@ static int cortex_m_assert_reset(struct target *target)
/* srst is asserted, ignore AP access errors */ /* srst is asserted, ignore AP access errors */
retval = ERROR_OK; retval = ERROR_OK;
} else { } else {
/* Use a standard Cortex-M3 software reset mechanism. /* Use a standard Cortex-M software reset mechanism.
* We default to using VECTRESET as it is supported on all current cores * We default to using VECTRESET.
* (except Cortex-M0, M0+ and M1 which support SYSRESETREQ only!)
* This has the disadvantage of not resetting the peripherals, so a * This has the disadvantage of not resetting the peripherals, so a
* reset-init event handler is needed to perform any peripheral resets. * reset-init event handler is needed to perform any peripheral resets.
*/ */
@ -1754,17 +1741,7 @@ static int cortex_m_assert_reset(struct target *target)
register_cache_invalidate(cortex_m->armv7m.arm.core_cache); register_cache_invalidate(cortex_m->armv7m.arm.core_cache);
/* now return stored error code if any */
if (retval != ERROR_OK)
return retval; return retval;
if (target->reset_halt && target_was_examined(target)) {
retval = target_halt(target);
if (retval != ERROR_OK)
return retval;
}
return ERROR_OK;
} }
static int cortex_m_deassert_reset(struct target *target) static int cortex_m_deassert_reset(struct target *target)
@ -2807,7 +2784,7 @@ static int cortex_m_init_arch_info(struct target *target,
armv7m_init_arch_info(target, armv7m); armv7m_init_arch_info(target, armv7m);
/* default reset mode is to use srst if fitted /* default reset mode is to use srst if fitted
* if not it will use CORTEX_M3_RESET_VECTRESET */ * if not it will use CORTEX_M_RESET_VECTRESET */
cortex_m->soft_reset_config = CORTEX_M_RESET_VECTRESET; cortex_m->soft_reset_config = CORTEX_M_RESET_VECTRESET;
armv7m->arm.dap = dap; armv7m->arm.dap = dap;
@ -2864,8 +2841,7 @@ static int cortex_m_verify_pointer(struct command_invocation *cmd,
/* /*
* Only stuff below this line should need to verify that its target * Only stuff below this line should need to verify that its target
* is a Cortex-M3. Everything else should have indirected through the * is a Cortex-M with available DAP access (not a HLA adapter).
* cortexm3_target structure, which is only used with CM3 targets.
*/ */
COMMAND_HANDLER(handle_cortex_m_vector_catch_command) COMMAND_HANDLER(handle_cortex_m_vector_catch_command)
@ -2924,7 +2900,7 @@ COMMAND_HANDLER(handle_cortex_m_vector_catch_command)
break; break;
} }
if (i == ARRAY_SIZE(vec_ids)) { if (i == ARRAY_SIZE(vec_ids)) {
LOG_TARGET_ERROR(target, "No CM3 vector '%s'", CMD_ARGV[CMD_ARGC]); LOG_TARGET_ERROR(target, "No Cortex-M vector '%s'", CMD_ARGV[CMD_ARGC]);
return ERROR_COMMAND_SYNTAX_ERROR; return ERROR_COMMAND_SYNTAX_ERROR;
} }
} }