X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Fadi_v5_swd.c;h=a6aada32611ba26884ebf4e739f113e26ead3e3c;hp=39f38572c541d07c3866a96ad34802289d65b681;hb=7e6445109763d47707e1d31620b3733b5137faba;hpb=7cd2617384f4ac620c468343c1f2009fbfa2fc79 diff --git a/src/target/adi_v5_swd.c b/src/target/adi_v5_swd.c index 39f38572c5..a6aada3261 100644 --- a/src/target/adi_v5_swd.c +++ b/src/target/adi_v5_swd.c @@ -13,9 +13,7 @@ * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the - * Free Software Foundation, Inc., - * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * along with this program. If not, see . ***************************************************************************/ /** @@ -50,75 +48,237 @@ #include "arm_adi_v5.h" #include -#include +#include #include #include +/* YUK! - but this is currently a global.... */ +extern struct jtag_interface *jtag_interface; +static bool do_sync; +static void swd_finish_read(struct adiv5_dap *dap) +{ + const struct swd_driver *swd = jtag_interface->swd; + if (dap->last_read != NULL) { + swd->read_reg(swd_cmd(true, false, DP_RDBUFF), dap->last_read, 0); + dap->last_read = NULL; + } +} +static int swd_queue_dp_write(struct adiv5_dap *dap, unsigned reg, + uint32_t data); static int swd_queue_dp_read(struct adiv5_dap *dap, unsigned reg, - uint32_t *data) + uint32_t *data); + +static void swd_clear_sticky_errors(struct adiv5_dap *dap) +{ + const struct swd_driver *swd = jtag_interface->swd; + assert(swd); + + swd->write_reg(swd_cmd(false, false, DP_ABORT), + STKCMPCLR | STKERRCLR | WDERRCLR | ORUNERRCLR, 0); +} + +static int swd_run_inner(struct adiv5_dap *dap) +{ + const struct swd_driver *swd = jtag_interface->swd; + int retval; + + retval = swd->run(); + + if (retval != ERROR_OK) { + /* fault response */ + dap->do_reconnect = true; + } + + return retval; +} + +static int swd_connect(struct adiv5_dap *dap) +{ + uint32_t dpidr; + int status; + + /* FIXME validate transport config ... is the + * configured DAP present (check IDCODE)? + * Is *only* one DAP configured? + * + * MUST READ DPIDR + */ + + /* Check if we should reset srst already when connecting, but not if reconnecting. */ + if (!dap->do_reconnect) { + enum reset_types jtag_reset_config = jtag_get_reset_config(); + + if (jtag_reset_config & RESET_CNCT_UNDER_SRST) { + if (jtag_reset_config & RESET_SRST_NO_GATING) + swd_add_reset(1); + else + LOG_WARNING("\'srst_nogate\' reset_config option is required"); + } + } + + /* Note, debugport_init() does setup too */ + jtag_interface->swd->switch_seq(JTAG_TO_SWD); + + /* Clear link state, including the SELECT cache. */ + dap->do_reconnect = false; + dap->select = DP_SELECT_INVALID; + + swd_queue_dp_read(dap, DP_DPIDR, &dpidr); + + /* force clear all sticky faults */ + swd_clear_sticky_errors(dap); + + status = swd_run_inner(dap); + + if (status == ERROR_OK) { + LOG_INFO("SWD DPIDR %#8.8" PRIx32, dpidr); + dap->do_reconnect = false; + } else + dap->do_reconnect = true; + + return status; +} + +static inline int check_sync(struct adiv5_dap *dap) { - // REVISIT status return vs ack ... - return swd->read_reg(swd_cmd(true, false, reg), data); + return do_sync ? swd_run_inner(dap) : ERROR_OK; } -static int swd_queue_idcode_read(struct adiv5_dap *dap, - uint8_t *ack, uint32_t *data) +static int swd_check_reconnect(struct adiv5_dap *dap) { - int status = swd_queue_dp_read(dap, DP_IDCODE, data); - if (status < 0) - return status; - *ack = status; - // ?? + if (dap->do_reconnect) + return swd_connect(dap); + return ERROR_OK; } -static int (swd_queue_dp_write)(struct adiv5_dap *dap, unsigned reg, - uint32_t data) +static int swd_queue_ap_abort(struct adiv5_dap *dap, uint8_t *ack) { - // REVISIT status return vs ack ... - return swd->write_reg(swd_cmd(false, false, reg), data); + const struct swd_driver *swd = jtag_interface->swd; + assert(swd); + + swd->write_reg(swd_cmd(false, false, DP_ABORT), + DAPABORT | STKCMPCLR | STKERRCLR | WDERRCLR | ORUNERRCLR, 0); + return check_sync(dap); } +/** Select the DP register bank matching bits 7:4 of reg. */ +static void swd_queue_dp_bankselect(struct adiv5_dap *dap, unsigned reg) +{ + /* Only register address 4 is banked. */ + if ((reg & 0xf) != 4) + return; + + uint32_t select_dp_bank = (reg & 0x000000F0) >> 4; + uint32_t sel = select_dp_bank + | (dap->select & (DP_SELECT_APSEL | DP_SELECT_APBANK)); + + if (sel == dap->select) + return; -static int (swd_queue_ap_read)(struct adiv5_dap *dap, unsigned reg, + dap->select = sel; + + swd_queue_dp_write(dap, DP_SELECT, sel); +} + +static int swd_queue_dp_read(struct adiv5_dap *dap, unsigned reg, uint32_t *data) { - // REVISIT APSEL ... - // REVISIT status return ... - return swd->read_reg(swd_cmd(true, true, reg), data); + const struct swd_driver *swd = jtag_interface->swd; + assert(swd); + + int retval = swd_check_reconnect(dap); + if (retval != ERROR_OK) + return retval; + + swd_queue_dp_bankselect(dap, reg); + swd->read_reg(swd_cmd(true, false, reg), data, 0); + + return check_sync(dap); } -static int (swd_queue_ap_write)(struct adiv5_dap *dap, unsigned reg, +static int swd_queue_dp_write(struct adiv5_dap *dap, unsigned reg, uint32_t data) { - // REVISIT APSEL ... - // REVISIT status return ... - return swd->write_reg(swd_cmd(false, true, reg), data); + const struct swd_driver *swd = jtag_interface->swd; + assert(swd); + + int retval = swd_check_reconnect(dap); + if (retval != ERROR_OK) + return retval; + + swd_finish_read(dap); + swd_queue_dp_bankselect(dap, reg); + swd->write_reg(swd_cmd(false, false, reg), data, 0); + + return check_sync(dap); } -static int (swd_queue_ap_abort)(struct adiv5_dap *dap, uint8_t *ack) +/** Select the AP register bank matching bits 7:4 of reg. */ +static void swd_queue_ap_bankselect(struct adiv5_ap *ap, unsigned reg) { - return ERROR_FAIL; + struct adiv5_dap *dap = ap->dap; + uint32_t sel = ((uint32_t)ap->ap_num << 24) + | (reg & 0x000000F0) + | (dap->select & DP_SELECT_DPBANK); + + if (sel == dap->select) + return; + + dap->select = sel; + + swd_queue_dp_write(dap, DP_SELECT, sel); +} + +static int swd_queue_ap_read(struct adiv5_ap *ap, unsigned reg, + uint32_t *data) +{ + const struct swd_driver *swd = jtag_interface->swd; + assert(swd); + + struct adiv5_dap *dap = ap->dap; + + int retval = swd_check_reconnect(dap); + if (retval != ERROR_OK) + return retval; + + swd_queue_ap_bankselect(ap, reg); + swd->read_reg(swd_cmd(true, true, reg), dap->last_read, ap->memaccess_tck); + dap->last_read = data; + + return check_sync(dap); +} + +static int swd_queue_ap_write(struct adiv5_ap *ap, unsigned reg, + uint32_t data) +{ + const struct swd_driver *swd = jtag_interface->swd; + assert(swd); + + struct adiv5_dap *dap = ap->dap; + + int retval = swd_check_reconnect(dap); + if (retval != ERROR_OK) + return retval; + + swd_finish_read(dap); + swd_queue_ap_bankselect(ap, reg); + swd->write_reg(swd_cmd(false, true, reg), data, ap->memaccess_tck); + + return check_sync(dap); } /** Executes all queued DAP operations. */ static int swd_run(struct adiv5_dap *dap) { - /* for now the SWD interface hard-wires a zero-size queue. */ - - /* FIXME but we still need to check and scrub - * any hardware errors ... - */ - return ERROR_OK; + swd_finish_read(dap); + return swd_run_inner(dap); } const struct dap_ops swd_dap_ops = { - .is_swd = true, - - .queue_idcode_read = swd_queue_idcode_read, .queue_dp_read = swd_queue_dp_read, .queue_dp_write = swd_queue_dp_write, .queue_ap_read = swd_queue_ap_read, @@ -170,6 +330,11 @@ int dap_to_swd(struct target *target) struct arm *arm = target_to_arm(target); int retval; + if (!arm->dap) { + LOG_ERROR("SWD mode is not available"); + return ERROR_FAIL; + } + LOG_DEBUG("Enter SWD mode"); /* REVISIT it's ugly to need to make calls to a "jtag" @@ -187,64 +352,6 @@ int dap_to_swd(struct target *target) return retval; } - - -COMMAND_HANDLER(handle_swd_wcr) -{ - int retval; - struct target *target = get_current_target(CMD_CTX); - struct arm *arm = target_to_arm(target); -struct adiv5_dap *dap = arm->dap; - uint32_t wcr; - unsigned trn, scale = 0; - - - switch (CMD_ARGC) { - /* no-args: just dump state */ - case 0: - //retval = swd_queue_dp_read(dap, DP_WCR, &wcr); - retval = dap_queue_dp_read(dap, DP_WCR, &wcr); - if (retval == ERROR_OK) - dap->ops->run(dap); - if (retval != ERROR_OK) { - LOG_ERROR("can't read WCR?"); - return retval; - } - - command_print(CMD_CTX, - "turnaround=%d, prescale=%d", - WCR_TO_TRN(wcr), - WCR_TO_PRESCALE(wcr)); - return ERROR_OK; - - case 2: /* TRN and prescale */ - COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], scale); - if (scale > 7) { - LOG_ERROR("prescale %d is too big", scale); - return ERROR_FAIL; - } - /* FALL THROUGH */ - - case 1: /* TRN only */ - COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], trn); - if (trn < 1 || trn > 4) { - LOG_ERROR("turnaround %d is invalid", trn); - return ERROR_FAIL; - } - - wcr = ((trn - 1) << 8) | scale; - /* FIXME - * write WCR ... - * then, re-init adapter with new TRN - */ - LOG_ERROR("can't yet modify WCR"); - return ERROR_FAIL; - - default: /* too many arguments */ - return ERROR_COMMAND_SYNTAX_ERROR; - } -} - static const struct command_registration swd_commands[] = { { /* @@ -259,15 +366,6 @@ static const struct command_registration swd_commands[] = { .mode = COMMAND_CONFIG, .help = "declare a new SWD DAP" }, - { - .name = "wcr", - .handler = handle_swd_wcr, - .mode = COMMAND_ANY, - .help = "display or update DAP's WCR register", - .usage = "turnaround (1..4), prescale (0..7)", - }, - - /* REVISIT -- add a command for SWV trace on/off */ COMMAND_REGISTRATION_DONE }; @@ -283,7 +381,6 @@ static const struct command_registration swd_handlers[] = { static int swd_select(struct command_context *ctx) { - struct target *target = get_current_target(ctx); int retval; retval = register_commands(ctx, NULL, swd_handlers); @@ -291,6 +388,8 @@ static int swd_select(struct command_context *ctx) if (retval != ERROR_OK) return retval; + const struct swd_driver *swd = jtag_interface->swd; + /* be sure driver is in SWD mode; start * with hardware default TRN (1), it can be changed later */ @@ -299,14 +398,20 @@ static int swd_select(struct command_context *ctx) return ERROR_FAIL; } - retval = swd->init(1); + retval = swd->init(); if (retval != ERROR_OK) { LOG_DEBUG("can't init SWD driver"); return retval; } /* force DAP into SWD mode (not JTAG) */ - retval = dap_to_swd(target); + /*retval = dap_to_swd(target);*/ + + if (ctx->current_target) { + /* force DAP into SWD mode (not JTAG) */ + struct target *target = get_current_target(ctx); + retval = dap_to_swd(target); + } return retval; } @@ -315,29 +420,17 @@ static int swd_init(struct command_context *ctx) { struct target *target = get_current_target(ctx); struct arm *arm = target_to_arm(target); -struct adiv5_dap *dap = arm->dap; - uint32_t idcode; - int status; - - - /* FIXME validate transport config ... is the - * configured DAP present (check IDCODE)? - * Is *only* one DAP configured? - * - * MUST READ IDCODE - */ - - /* Note, debugport_init() does setup too */ - - uint8_t ack; - - status = swd_queue_idcode_read(dap, &ack, &idcode); - - if (status == ERROR_OK) - LOG_INFO("SWD IDCODE %#8.8x", idcode); - - return status; + struct adiv5_dap *dap = arm->dap; + /* Force the DAP's ops vector for SWD mode. + * messy - is there a better way? */ + arm->dap->ops = &swd_dap_ops; + /* First connect after init is not reconnecting. */ + dap->do_reconnect = false; + int retval = swd_connect(dap); + if (retval != ERROR_OK) + LOG_ERROR("SWD connect failed"); + return retval; } static struct transport swd_transport = {