1 // SPDX-License-Identifier: GPL-2.0-or-later
3 /***************************************************************************
4 * Copyright (C) 2006 by Magnus Lundin
7 * Copyright (C) 2008 by Spencer Oliver
10 * Copyright (C) 2009 by Oyvind Harboe
11 * oyvind.harboe@zylin.com
13 * Copyright (C) 2009-2010 by David Brownell
15 * Copyright (C) 2020-2021, Ampere Computing LLC *
16 ***************************************************************************/
20 * This file implements JTAG transport support for cores implementing
21 the ARM Debug Interface version 5 (ADIv5) and version 6 (ADIv6).
29 #include "arm_adi_v5.h"
30 #include <helper/time_support.h>
31 #include <helper/list.h>
34 /*#define DEBUG_WAIT*/
36 /* JTAG instructions/registers for JTAG-DP and SWJ-DP */
37 #define JTAG_DP_ABORT 0xF8
38 #define JTAG_DP_DPACC 0xFA
39 #define JTAG_DP_APACC 0xFB
40 #define JTAG_DP_IDCODE 0xFE
42 /* three-bit ACK values for DPACC and APACC reads */
43 #define JTAG_ACK_WAIT 0x1 /* ADIv5 and ADIv6 */
44 #define JTAG_ACK_OK_FAULT 0x2 /* ADIv5 */
45 #define JTAG_ACK_FAULT 0x2 /* ADIv6 */
46 #define JTAG_ACK_OK 0x4 /* ADIV6 */
48 static int jtag_ap_q_abort(struct adiv5_dap
*dap
, uint8_t *ack
);
51 static const char *dap_reg_name(struct adiv5_dap
*dap
, uint8_t instr
, uint16_t reg_addr
)
53 char *reg_name
= "UNK";
55 if (instr
== JTAG_DP_DPACC
) {
61 reg_name
= "CTRL/STAT";
78 if (instr
== JTAG_DP_APACC
) {
79 if (reg_addr
== MEM_AP_REG_CSW(dap
))
81 else if (reg_addr
== MEM_AP_REG_TAR(dap
))
83 else if (reg_addr
== MEM_AP_REG_TAR64(dap
))
85 else if (reg_addr
== MEM_AP_REG_DRW(dap
))
87 else if (reg_addr
== MEM_AP_REG_BD0(dap
))
89 else if (reg_addr
== MEM_AP_REG_BD1(dap
))
91 else if (reg_addr
== MEM_AP_REG_BD2(dap
))
93 else if (reg_addr
== MEM_AP_REG_BD3(dap
))
95 else if (reg_addr
== MEM_AP_REG_CFG(dap
))
97 else if (reg_addr
== MEM_AP_REG_BASE(dap
))
99 else if (reg_addr
== MEM_AP_REG_BASE64(dap
))
101 else if (reg_addr
== AP_REG_IDR(dap
))
118 uint32_t memaccess_tck
;
121 struct scan_field fields
[2];
122 uint8_t out_addr_buf
;
123 uint8_t invalue_buf
[4];
124 uint8_t outvalue_buf
[4];
127 #define MAX_DAP_COMMAND_NUM 65536
129 struct dap_cmd_pool
{
134 static void log_dap_cmd(struct adiv5_dap
*dap
, const char *header
, struct dap_cmd
*el
)
139 case JTAG_ACK_WAIT
: /* ADIv5 and ADIv6 */
142 case JTAG_ACK_OK_FAULT
: /* ADIv5, same value as JTAG_ACK_FAULT */
143 /* case JTAG_ACK_FAULT: */ /* ADIv6 */
149 case JTAG_ACK_OK
: /* ADIv6 */
159 LOG_DEBUG("%s: %2s %6s %5s 0x%08x 0x%08x %2s", header
,
160 el
->instr
== JTAG_DP_APACC
? "AP" : "DP",
161 dap_reg_name(dap
, el
->instr
, el
->reg_addr
),
162 el
->rnw
== DPAP_READ
? "READ" : "WRITE",
163 buf_get_u32(el
->outvalue_buf
, 0, 32),
164 buf_get_u32(el
->invalue
, 0, 32),
169 static int jtag_limit_queue_size(struct adiv5_dap
*dap
)
171 if (dap
->cmd_pool_size
< MAX_DAP_COMMAND_NUM
)
177 static struct dap_cmd
*dap_cmd_new(struct adiv5_dap
*dap
, uint8_t instr
,
178 uint16_t reg_addr
, uint8_t rnw
,
179 uint8_t *outvalue
, uint8_t *invalue
,
180 uint32_t memaccess_tck
)
183 struct dap_cmd_pool
*pool
= NULL
;
185 if (list_empty(&dap
->cmd_pool
)) {
186 pool
= calloc(1, sizeof(struct dap_cmd_pool
));
190 pool
= list_first_entry(&dap
->cmd_pool
, struct dap_cmd_pool
, lh
);
194 INIT_LIST_HEAD(&pool
->lh
);
195 dap
->cmd_pool_size
++;
197 struct dap_cmd
*cmd
= &pool
->cmd
;
198 INIT_LIST_HEAD(&cmd
->lh
);
200 cmd
->reg_addr
= reg_addr
;
203 memcpy(cmd
->outvalue_buf
, outvalue
, 4);
204 cmd
->invalue
= (invalue
) ? invalue
: cmd
->invalue_buf
;
205 cmd
->memaccess_tck
= memaccess_tck
;
210 static void dap_cmd_release(struct adiv5_dap
*dap
, struct dap_cmd
*cmd
)
212 struct dap_cmd_pool
*pool
= container_of(cmd
, struct dap_cmd_pool
, cmd
);
213 if (dap
->cmd_pool_size
> MAX_DAP_COMMAND_NUM
)
216 list_add(&pool
->lh
, &dap
->cmd_pool
);
218 dap
->cmd_pool_size
--;
221 static void flush_journal(struct adiv5_dap
*dap
, struct list_head
*lh
)
223 struct dap_cmd
*el
, *tmp
;
225 list_for_each_entry_safe(el
, tmp
, lh
, lh
) {
227 dap_cmd_release(dap
, el
);
231 static void jtag_quit(struct adiv5_dap
*dap
)
233 struct dap_cmd_pool
*el
, *tmp
;
234 struct list_head
*lh
= &dap
->cmd_pool
;
236 list_for_each_entry_safe(el
, tmp
, lh
, lh
) {
242 /***************************************************************************
244 * DPACC and APACC scanchain access through JTAG-DP (or SWJ-DP)
246 ***************************************************************************/
248 static int adi_jtag_dp_scan_cmd(struct adiv5_dap
*dap
, struct dap_cmd
*cmd
, uint8_t *ack
)
250 struct jtag_tap
*tap
= dap
->tap
;
253 retval
= arm_jtag_set_instr(tap
, cmd
->instr
, NULL
, TAP_IDLE
);
254 if (retval
!= ERROR_OK
)
257 /* Scan out a read or write operation using some DP or AP register.
258 * For APACC access with any sticky error flag set, this is discarded.
260 cmd
->fields
[0].num_bits
= 3;
261 buf_set_u32(&cmd
->out_addr_buf
, 0, 3, ((cmd
->reg_addr
>> 1) & 0x6) | (cmd
->rnw
& 0x1));
262 cmd
->fields
[0].out_value
= &cmd
->out_addr_buf
;
263 cmd
->fields
[0].in_value
= (ack
) ? ack
: &cmd
->ack
;
265 /* NOTE: if we receive JTAG_ACK_WAIT, the previous operation did not
266 * complete; data we write is discarded, data we read is unpredictable.
267 * When overrun detect is active, STICKYORUN is set.
270 cmd
->fields
[1].num_bits
= 32;
271 cmd
->fields
[1].out_value
= cmd
->outvalue_buf
;
272 cmd
->fields
[1].in_value
= cmd
->invalue
;
274 jtag_add_dr_scan(tap
, 2, cmd
->fields
, TAP_IDLE
);
276 /* Add specified number of tck clocks after starting AP register
277 * access or memory bus access, giving the hardware time to complete
279 * They provide more time for the (MEM) AP to complete the read ...
280 * See "Minimum Response Time" for JTAG-DP, in the ADIv5/ADIv6 spec.
282 if (cmd
->instr
== JTAG_DP_APACC
&& cmd
->memaccess_tck
!= 0)
283 jtag_add_runtest(cmd
->memaccess_tck
, TAP_IDLE
);
288 static int adi_jtag_dp_scan_cmd_sync(struct adiv5_dap
*dap
, struct dap_cmd
*cmd
, uint8_t *ack
)
292 retval
= adi_jtag_dp_scan_cmd(dap
, cmd
, ack
);
293 if (retval
!= ERROR_OK
)
296 return jtag_execute_queue();
300 * Scan DPACC or APACC using target ordered uint8_t buffers. No endianness
301 * conversions are performed. See section 4.4.3 of the ADIv5/ADIv6 spec, which
302 * discusses operations which access these registers.
304 * Note that only one scan is performed. If rnw is set, a separate scan
305 * will be needed to collect the data which was read; the "invalue" collects
306 * the posted result of a preceding operation, not the current one.
309 * @param instr JTAG_DP_APACC (AP access) or JTAG_DP_DPACC (DP access)
310 * @param reg_addr two significant bits; A[3:2]; for APACC access, the
311 * SELECT register has more addressing bits.
312 * @param rnw false iff outvalue will be written to the DP or AP
313 * @param outvalue points to a 32-bit (little-endian) integer
314 * @param invalue NULL, or points to a 32-bit (little-endian) integer
315 * @param ack points to where the three bit JTAG_ACK_* code will be stored
316 * @param memaccess_tck number of idle cycles to add after AP access
319 static int adi_jtag_dp_scan(struct adiv5_dap
*dap
,
320 uint8_t instr
, uint16_t reg_addr
, uint8_t rnw
,
321 uint8_t *outvalue
, uint8_t *invalue
,
322 uint32_t memaccess_tck
, uint8_t *ack
)
327 cmd
= dap_cmd_new(dap
, instr
, reg_addr
, rnw
, outvalue
, invalue
, memaccess_tck
);
329 cmd
->dp_select
= dap
->select
;
331 return ERROR_JTAG_DEVICE_ERROR
;
333 retval
= adi_jtag_dp_scan_cmd(dap
, cmd
, ack
);
334 if (retval
== ERROR_OK
)
335 list_add_tail(&cmd
->lh
, &dap
->cmd_journal
);
341 * Scan DPACC or APACC out and in from host ordered uint32_t buffers.
342 * This is exactly like adi_jtag_dp_scan(), except that endianness
343 * conversions are performed (so the types of invalue and outvalue
344 * must be different).
346 static int adi_jtag_dp_scan_u32(struct adiv5_dap
*dap
,
347 uint8_t instr
, uint16_t reg_addr
, uint8_t rnw
,
348 uint32_t outvalue
, uint32_t *invalue
,
349 uint32_t memaccess_tck
, uint8_t *ack
)
351 uint8_t out_value_buf
[4];
353 uint64_t sel
= (reg_addr
>> 4) & 0xf;
355 /* No need to change SELECT or RDBUFF as they are not banked */
356 if (instr
== JTAG_DP_DPACC
&& reg_addr
!= DP_SELECT
&& reg_addr
!= DP_RDBUFF
&&
357 sel
!= (dap
->select
& 0xf)) {
358 if (dap
->select
!= DP_SELECT_INVALID
)
359 sel
|= dap
->select
& ~0xfull
;
361 LOG_DEBUG("DP BANKSEL: %x", (uint32_t)sel
);
362 buf_set_u32(out_value_buf
, 0, 32, (uint32_t)sel
);
363 retval
= adi_jtag_dp_scan(dap
, JTAG_DP_DPACC
,
364 DP_SELECT
, DPAP_WRITE
, out_value_buf
, NULL
, 0, NULL
);
365 if (retval
!= ERROR_OK
)
368 buf_set_u32(out_value_buf
, 0, 32, outvalue
);
370 retval
= adi_jtag_dp_scan(dap
, instr
, reg_addr
, rnw
,
371 out_value_buf
, (uint8_t *)invalue
, memaccess_tck
, ack
);
372 if (retval
!= ERROR_OK
)
376 jtag_add_callback(arm_le_to_h_u32
,
377 (jtag_callback_data_t
) invalue
);
382 static int adi_jtag_finish_read(struct adiv5_dap
*dap
)
384 int retval
= ERROR_OK
;
386 if (dap
->last_read
) {
387 retval
= adi_jtag_dp_scan_u32(dap
, JTAG_DP_DPACC
,
388 DP_RDBUFF
, DPAP_READ
, 0, dap
->last_read
, 0, NULL
);
389 dap
->last_read
= NULL
;
395 static int adi_jtag_scan_inout_check_u32(struct adiv5_dap
*dap
,
396 uint8_t instr
, uint16_t reg_addr
, uint8_t rnw
,
397 uint32_t outvalue
, uint32_t *invalue
, uint32_t memaccess_tck
)
401 /* Issue the read or write */
402 retval
= adi_jtag_dp_scan_u32(dap
, instr
, reg_addr
,
403 rnw
, outvalue
, NULL
, memaccess_tck
, NULL
);
404 if (retval
!= ERROR_OK
)
407 /* For reads, collect posted value; RDBUFF has no other effect.
408 * Assumes read gets acked with OK/FAULT, and CTRL_STAT says "OK".
410 if ((rnw
== DPAP_READ
) && (invalue
)) {
411 retval
= adi_jtag_dp_scan_u32(dap
, JTAG_DP_DPACC
,
412 DP_RDBUFF
, DPAP_READ
, 0, invalue
, 0, NULL
);
413 if (retval
!= ERROR_OK
)
417 return jtag_execute_queue();
420 static int jtagdp_overrun_check(struct adiv5_dap
*dap
)
423 struct dap_cmd
*el
, *tmp
, *prev
= NULL
;
426 LIST_HEAD(replay_list
);
428 /* make sure all queued transactions are complete */
429 retval
= jtag_execute_queue();
430 if (retval
!= ERROR_OK
)
433 /* skip all completed transactions up to the first WAIT */
434 list_for_each_entry(el
, &dap
->cmd_journal
, lh
) {
436 * JTAG_ACK_OK_FAULT (ADIv5) and JTAG_ACK_FAULT (ADIv6) are equal so
437 * the following statement is checking to see if an acknowledgment of
438 * OK or FAULT is generated for ADIv5 or ADIv6
440 if (el
->ack
== JTAG_ACK_OK_FAULT
|| (is_adiv6(dap
) && el
->ack
== JTAG_ACK_OK
)) {
441 log_dap_cmd(dap
, "LOG", el
);
442 } else if (el
->ack
== JTAG_ACK_WAIT
) {
446 LOG_ERROR("Invalid ACK (%1x) in DAP response", el
->ack
);
447 log_dap_cmd(dap
, "ERR", el
);
448 retval
= ERROR_JTAG_DEVICE_ERROR
;
454 * If we found a stalled transaction and a previous transaction
455 * exists, check if it's a READ access.
457 if (found_wait
&& el
!= list_first_entry(&dap
->cmd_journal
, struct dap_cmd
, lh
)) {
458 prev
= list_entry(el
->lh
.prev
, struct dap_cmd
, lh
);
459 if (prev
->rnw
== DPAP_READ
) {
460 log_dap_cmd(dap
, "PND", prev
);
461 /* search for the next OK transaction, it contains
462 * the result of the previous READ */
464 list_for_each_entry_from(tmp
, &dap
->cmd_journal
, lh
) {
465 /* The following check covers OK and FAULT ACKs for both ADIv5 and ADIv6 */
466 if (tmp
->ack
== JTAG_ACK_OK_FAULT
|| (is_adiv6(dap
) && tmp
->ack
== JTAG_ACK_OK
)) {
467 /* recover the read value */
468 log_dap_cmd(dap
, "FND", tmp
);
469 if (el
->invalue
!= el
->invalue_buf
) {
470 uint32_t invalue
= le_to_h_u32(tmp
->invalue
);
471 memcpy(el
->invalue
, &invalue
, sizeof(uint32_t));
479 log_dap_cmd(dap
, "LST", el
);
482 * At this point we're sure that no previous
483 * transaction completed and the DAP/AP is still
484 * in busy state. We know that the next "OK" scan
485 * will return the READ result we need to recover.
486 * To complete the READ, we just keep polling RDBUFF
487 * until the WAIT condition clears
489 tmp
= dap_cmd_new(dap
, JTAG_DP_DPACC
,
490 DP_RDBUFF
, DPAP_READ
, NULL
, NULL
, 0);
492 retval
= ERROR_JTAG_DEVICE_ERROR
;
495 /* synchronously retry the command until it succeeds */
496 time_now
= timeval_ms();
498 retval
= adi_jtag_dp_scan_cmd_sync(dap
, tmp
, NULL
);
499 if (retval
!= ERROR_OK
)
501 /* The following check covers OK and FAULT ACKs for both ADIv5 and ADIv6 */
502 if (tmp
->ack
== JTAG_ACK_OK_FAULT
|| (is_adiv6(dap
) && tmp
->ack
== JTAG_ACK_OK
)) {
503 log_dap_cmd(dap
, "FND", tmp
);
504 if (el
->invalue
!= el
->invalue_buf
) {
505 uint32_t invalue
= le_to_h_u32(tmp
->invalue
);
506 memcpy(el
->invalue
, &invalue
, sizeof(uint32_t));
510 if (tmp
->ack
!= JTAG_ACK_WAIT
) {
511 LOG_ERROR("Invalid ACK (%1x) in DAP response", tmp
->ack
);
512 log_dap_cmd(dap
, "ERR", tmp
);
513 retval
= ERROR_JTAG_DEVICE_ERROR
;
517 } while (timeval_ms() - time_now
< 1000);
519 if (retval
== ERROR_OK
) {
520 /* timeout happened */
521 if (tmp
->ack
== JTAG_ACK_WAIT
) {
522 LOG_ERROR("Timeout during WAIT recovery");
523 dap
->select
= DP_SELECT_INVALID
;
524 jtag_ap_q_abort(dap
, NULL
);
525 /* clear the sticky overrun condition */
526 adi_jtag_scan_inout_check_u32(dap
, JTAG_DP_DPACC
,
527 DP_CTRL_STAT
, DPAP_WRITE
,
528 dap
->dp_ctrl_stat
| SSTICKYORUN
, NULL
, 0);
529 retval
= ERROR_JTAG_DEVICE_ERROR
;
533 /* we're done with this command, release it */
534 dap_cmd_release(dap
, tmp
);
536 if (retval
!= ERROR_OK
)
540 /* make el->invalue point to the default invalue
541 * so that we can safely retry it without clobbering
542 * the result we just recovered */
543 el
->invalue
= el
->invalue_buf
;
547 /* move all remaining transactions over to the replay list */
548 list_for_each_entry_safe_from(el
, tmp
, &dap
->cmd_journal
, lh
) {
549 log_dap_cmd(dap
, "REP", el
);
550 list_move_tail(&el
->lh
, &replay_list
);
553 /* we're done with the journal, flush it */
554 flush_journal(dap
, &dap
->cmd_journal
);
556 /* check for overrun condition in the last batch of transactions */
558 LOG_INFO("DAP transaction stalled (WAIT) - slowing down and resending");
559 /* clear the sticky overrun condition */
560 retval
= adi_jtag_scan_inout_check_u32(dap
, JTAG_DP_DPACC
,
561 DP_CTRL_STAT
, DPAP_WRITE
,
562 dap
->dp_ctrl_stat
| SSTICKYORUN
, NULL
, 0);
563 if (retval
!= ERROR_OK
)
566 /* restore SELECT register first */
567 if (!list_empty(&replay_list
)) {
568 el
= list_first_entry(&replay_list
, struct dap_cmd
, lh
);
569 tmp
= dap_cmd_new(dap
, JTAG_DP_DPACC
,
570 DP_SELECT
, DPAP_WRITE
, (uint8_t *)&el
->dp_select
, NULL
, 0);
572 retval
= ERROR_JTAG_DEVICE_ERROR
;
575 list_add(&tmp
->lh
, &replay_list
);
577 dap
->select
= DP_SELECT_INVALID
;
580 list_for_each_entry_safe(el
, tmp
, &replay_list
, lh
) {
581 time_now
= timeval_ms();
583 retval
= adi_jtag_dp_scan_cmd_sync(dap
, el
, NULL
);
584 if (retval
!= ERROR_OK
)
586 log_dap_cmd(dap
, "REC", el
);
587 if (el
->ack
== JTAG_ACK_OK_FAULT
|| (is_adiv6(dap
) && el
->ack
== JTAG_ACK_OK
)) {
588 if (el
->invalue
!= el
->invalue_buf
) {
589 uint32_t invalue
= le_to_h_u32(el
->invalue
);
590 memcpy(el
->invalue
, &invalue
, sizeof(uint32_t));
594 if (el
->ack
!= JTAG_ACK_WAIT
) {
595 LOG_ERROR("Invalid ACK (%1x) in DAP response", el
->ack
);
596 log_dap_cmd(dap
, "ERR", el
);
597 retval
= ERROR_JTAG_DEVICE_ERROR
;
600 LOG_DEBUG("DAP transaction stalled during replay (WAIT) - resending");
601 /* clear the sticky overrun condition */
602 retval
= adi_jtag_scan_inout_check_u32(dap
, JTAG_DP_DPACC
,
603 DP_CTRL_STAT
, DPAP_WRITE
,
604 dap
->dp_ctrl_stat
| SSTICKYORUN
, NULL
, 0);
605 if (retval
!= ERROR_OK
)
607 } while (timeval_ms() - time_now
< 1000);
609 if (retval
== ERROR_OK
) {
610 if (el
->ack
== JTAG_ACK_WAIT
) {
611 LOG_ERROR("Timeout during WAIT recovery");
612 dap
->select
= DP_SELECT_INVALID
;
613 jtag_ap_q_abort(dap
, NULL
);
614 /* clear the sticky overrun condition */
615 adi_jtag_scan_inout_check_u32(dap
, JTAG_DP_DPACC
,
616 DP_CTRL_STAT
, DPAP_WRITE
,
617 dap
->dp_ctrl_stat
| SSTICKYORUN
, NULL
, 0);
618 retval
= ERROR_JTAG_DEVICE_ERROR
;
627 flush_journal(dap
, &replay_list
);
628 flush_journal(dap
, &dap
->cmd_journal
);
632 static int jtagdp_transaction_endcheck(struct adiv5_dap
*dap
)
635 uint32_t ctrlstat
, pwrmask
;
637 /* too expensive to call keep_alive() here */
639 /* Post CTRL/STAT read; discard any previous posted read value
640 * but collect its ACK status.
642 retval
= adi_jtag_scan_inout_check_u32(dap
, JTAG_DP_DPACC
,
643 DP_CTRL_STAT
, DPAP_READ
, 0, &ctrlstat
, 0);
644 if (retval
!= ERROR_OK
)
647 /* REVISIT also STICKYCMP, for pushed comparisons (nyet used) */
649 /* Check for STICKYERR */
650 if (ctrlstat
& SSTICKYERR
) {
651 LOG_DEBUG("jtag-dp: CTRL/STAT 0x%" PRIx32
, ctrlstat
);
652 /* Check power to debug regions */
653 pwrmask
= CDBGPWRUPREQ
| CDBGPWRUPACK
| CSYSPWRUPREQ
;
654 if (!dap
->ignore_syspwrupack
)
655 pwrmask
|= CSYSPWRUPACK
;
656 if ((ctrlstat
& pwrmask
) != pwrmask
) {
657 LOG_ERROR("Debug regions are unpowered, an unexpected reset might have happened");
658 dap
->do_reconnect
= true;
661 if (ctrlstat
& SSTICKYERR
)
662 LOG_ERROR("JTAG-DP STICKY ERROR");
663 if (ctrlstat
& SSTICKYORUN
)
664 LOG_DEBUG("JTAG-DP STICKY OVERRUN");
666 /* Clear Sticky Error and Sticky Overrun Bits */
667 retval
= adi_jtag_scan_inout_check_u32(dap
, JTAG_DP_DPACC
,
668 DP_CTRL_STAT
, DPAP_WRITE
,
669 dap
->dp_ctrl_stat
| SSTICKYERR
| SSTICKYORUN
, NULL
, 0);
670 if (retval
!= ERROR_OK
)
673 retval
= ERROR_JTAG_DEVICE_ERROR
;
677 flush_journal(dap
, &dap
->cmd_journal
);
681 /*--------------------------------------------------------------------------*/
683 static int jtag_connect(struct adiv5_dap
*dap
)
685 dap
->do_reconnect
= false;
686 return dap_dp_init(dap
);
689 static int jtag_check_reconnect(struct adiv5_dap
*dap
)
691 if (dap
->do_reconnect
)
692 return jtag_connect(dap
);
697 static int jtag_send_sequence(struct adiv5_dap
*dap
, enum swd_special_seq seq
)
703 retval
= jtag_add_tms_seq(swd_seq_jtag_to_swd_len
,
704 swd_seq_jtag_to_swd
, TAP_INVALID
);
707 retval
= jtag_add_tms_seq(swd_seq_swd_to_jtag_len
,
708 swd_seq_swd_to_jtag
, TAP_RESET
);
711 LOG_ERROR("Sequence %d not supported", seq
);
714 if (retval
== ERROR_OK
)
715 retval
= jtag_execute_queue();
719 static int jtag_dp_q_read(struct adiv5_dap
*dap
, unsigned reg
,
722 int retval
= jtag_limit_queue_size(dap
);
723 if (retval
!= ERROR_OK
)
726 retval
= adi_jtag_dp_scan_u32(dap
, JTAG_DP_DPACC
, reg
,
727 DPAP_READ
, 0, dap
->last_read
, 0, NULL
);
728 dap
->last_read
= data
;
732 static int jtag_dp_q_write(struct adiv5_dap
*dap
, unsigned reg
,
735 int retval
= jtag_limit_queue_size(dap
);
736 if (retval
!= ERROR_OK
)
739 retval
= adi_jtag_dp_scan_u32(dap
, JTAG_DP_DPACC
,
740 reg
, DPAP_WRITE
, data
, dap
->last_read
, 0, NULL
);
741 dap
->last_read
= NULL
;
745 /** Select the AP register bank matching bits 7:4 of reg. */
746 static int jtag_ap_q_bankselect(struct adiv5_ap
*ap
, unsigned reg
)
749 struct adiv5_dap
*dap
= ap
->dap
;
753 sel
= ap
->ap_num
| (reg
& 0x00000FF0);
754 if (sel
== (dap
->select
& ~0xfull
))
757 if (dap
->select
!= DP_SELECT_INVALID
)
758 sel
|= dap
->select
& 0xf;
760 LOG_DEBUG("AP BANKSEL: %" PRIx64
, sel
);
762 retval
= jtag_dp_q_write(dap
, DP_SELECT
, (uint32_t)sel
);
763 if (retval
!= ERROR_OK
)
767 return jtag_dp_q_write(dap
, DP_SELECT1
, (uint32_t)(sel
>> 32));
772 sel
= (ap
->ap_num
<< 24) | (reg
& 0x000000F0);
774 if (sel
== dap
->select
)
779 return jtag_dp_q_write(dap
, DP_SELECT
, (uint32_t)sel
);
782 static int jtag_ap_q_read(struct adiv5_ap
*ap
, unsigned reg
,
785 int retval
= jtag_limit_queue_size(ap
->dap
);
786 if (retval
!= ERROR_OK
)
789 retval
= jtag_check_reconnect(ap
->dap
);
790 if (retval
!= ERROR_OK
)
793 retval
= jtag_ap_q_bankselect(ap
, reg
);
794 if (retval
!= ERROR_OK
)
797 retval
= adi_jtag_dp_scan_u32(ap
->dap
, JTAG_DP_APACC
, reg
,
798 DPAP_READ
, 0, ap
->dap
->last_read
, ap
->memaccess_tck
, NULL
);
799 ap
->dap
->last_read
= data
;
804 static int jtag_ap_q_write(struct adiv5_ap
*ap
, unsigned reg
,
807 int retval
= jtag_limit_queue_size(ap
->dap
);
808 if (retval
!= ERROR_OK
)
811 retval
= jtag_check_reconnect(ap
->dap
);
812 if (retval
!= ERROR_OK
)
815 retval
= jtag_ap_q_bankselect(ap
, reg
);
816 if (retval
!= ERROR_OK
)
819 retval
= adi_jtag_dp_scan_u32(ap
->dap
, JTAG_DP_APACC
, reg
,
820 DPAP_WRITE
, data
, ap
->dap
->last_read
, ap
->memaccess_tck
, NULL
);
821 ap
->dap
->last_read
= NULL
;
825 static int jtag_ap_q_abort(struct adiv5_dap
*dap
, uint8_t *ack
)
827 /* for JTAG, this is the only valid ABORT register operation */
828 int retval
= adi_jtag_dp_scan_u32(dap
, JTAG_DP_ABORT
,
829 0, DPAP_WRITE
, 1, NULL
, 0, NULL
);
830 if (retval
!= ERROR_OK
)
833 return jtag_execute_queue();
836 static int jtag_dp_run(struct adiv5_dap
*dap
)
839 int retval2
= ERROR_OK
;
841 retval
= adi_jtag_finish_read(dap
);
842 if (retval
!= ERROR_OK
)
844 retval2
= jtagdp_overrun_check(dap
);
845 retval
= jtagdp_transaction_endcheck(dap
);
848 return (retval2
!= ERROR_OK
) ? retval2
: retval
;
851 static int jtag_dp_sync(struct adiv5_dap
*dap
)
853 return jtagdp_overrun_check(dap
);
856 /* FIXME don't export ... just initialize as
859 const struct dap_ops jtag_dp_ops
= {
860 .connect
= jtag_connect
,
861 .send_sequence
= jtag_send_sequence
,
862 .queue_dp_read
= jtag_dp_q_read
,
863 .queue_dp_write
= jtag_dp_q_write
,
864 .queue_ap_read
= jtag_ap_q_read
,
865 .queue_ap_write
= jtag_ap_q_write
,
866 .queue_ap_abort
= jtag_ap_q_abort
,
868 .sync
= jtag_dp_sync
,