OpenOCD
adi_v5_jtag.c
Go to the documentation of this file.
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 
3 /***************************************************************************
4  * Copyright (C) 2006 by Magnus Lundin
5  * lundin@mlu.mine.nu
6  *
7  * Copyright (C) 2008 by Spencer Oliver
8  * spen@spen-soft.co.uk
9  *
10  * Copyright (C) 2009 by Oyvind Harboe
11  * oyvind.harboe@zylin.com
12  *
13  * Copyright (C) 2009-2010 by David Brownell
14  *
15  * Copyright (C) 2020-2021, Ampere Computing LLC *
16  ***************************************************************************/
17 
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27 
28 #include "arm.h"
29 #include "arm_adi_v5.h"
30 #include <helper/time_support.h>
31 #include <helper/list.h>
32 #include <jtag/swd.h>
33 
34 /*#define DEBUG_WAIT*/
35 
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
41 
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 */
47 
48 static int jtag_ap_q_abort(struct adiv5_dap *dap, uint8_t *ack);
49 
50 #ifdef DEBUG_WAIT
51 static const char *dap_reg_name(struct adiv5_dap *dap, uint8_t instr, uint16_t reg_addr)
52 {
53  char *reg_name = "UNK";
54 
55  if (instr == JTAG_DP_DPACC) {
56  switch (reg_addr) {
57  case DP_ABORT:
58  reg_name = "ABORT";
59  break;
60  case DP_CTRL_STAT:
61  reg_name = "CTRL/STAT";
62  break;
63  case DP_SELECT:
64  reg_name = "SELECT";
65  break;
66  case DP_RDBUFF:
67  reg_name = "RDBUFF";
68  break;
69  case DP_DLCR:
70  reg_name = "DLCR";
71  break;
72  default:
73  reg_name = "UNK";
74  break;
75  }
76  }
77 
78  if (instr == JTAG_DP_APACC) {
79  if (reg_addr == MEM_AP_REG_CSW(dap))
80  reg_name = "CSW";
81  else if (reg_addr == MEM_AP_REG_TAR(dap))
82  reg_name = "TAR";
83  else if (reg_addr == MEM_AP_REG_TAR64(dap))
84  reg_name = "TAR64";
85  else if (reg_addr == MEM_AP_REG_DRW(dap))
86  reg_name = "DRW";
87  else if (reg_addr == MEM_AP_REG_BD0(dap))
88  reg_name = "BD0";
89  else if (reg_addr == MEM_AP_REG_BD1(dap))
90  reg_name = "BD1";
91  else if (reg_addr == MEM_AP_REG_BD2(dap))
92  reg_name = "BD2";
93  else if (reg_addr == MEM_AP_REG_BD3(dap))
94  reg_name = "BD3";
95  else if (reg_addr == MEM_AP_REG_CFG(dap))
96  reg_name = "CFG";
97  else if (reg_addr == MEM_AP_REG_BASE(dap))
98  reg_name = "BASE";
99  else if (reg_addr == MEM_AP_REG_BASE64(dap))
100  reg_name = "BASE64";
101  else if (reg_addr == AP_REG_IDR(dap))
102  reg_name = "IDR";
103  else
104  reg_name = "UNK";
105  }
106 
107  return reg_name;
108 }
109 #endif
110 
111 struct dap_cmd {
112  struct list_head lh;
113  uint8_t instr;
114  uint16_t reg_addr;
115  uint8_t rnw;
116  uint8_t *invalue;
117  uint8_t ack;
118  uint32_t memaccess_tck;
119  uint64_t dp_select;
120 
121  struct scan_field fields[2];
122  uint8_t out_addr_buf;
123  uint8_t invalue_buf[4];
124  uint8_t outvalue_buf[4];
125 };
126 
127 #define MAX_DAP_COMMAND_NUM 65536
128 
129 struct dap_cmd_pool {
130  struct list_head lh;
131  struct dap_cmd cmd;
132 };
133 
134 static void log_dap_cmd(struct adiv5_dap *dap, const char *header, struct dap_cmd *el)
135 {
136 #ifdef DEBUG_WAIT
137  const char *ack;
138  switch (el->ack) {
139  case JTAG_ACK_WAIT: /* ADIv5 and ADIv6 */
140  ack = "WAIT";
141  break;
142  case JTAG_ACK_OK_FAULT: /* ADIv5, same value as JTAG_ACK_FAULT */
143  /* case JTAG_ACK_FAULT: */ /* ADIv6 */
144  if (is_adiv6(dap))
145  ack = "FAULT";
146  else
147  ack = "OK";
148  break;
149  case JTAG_ACK_OK: /* ADIv6 */
150  if (is_adiv6(dap)) {
151  ack = "OK";
152  break;
153  }
154  /* fall-through */
155  default:
156  ack = "INVAL";
157  break;
158  }
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),
165  ack);
166 #endif
167 }
168 
169 static int jtag_limit_queue_size(struct adiv5_dap *dap)
170 {
172  return ERROR_OK;
173 
174  return dap_run(dap);
175 }
176 
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)
181 {
182 
183  struct dap_cmd_pool *pool = NULL;
184 
185  if (list_empty(&dap->cmd_pool)) {
186  pool = calloc(1, sizeof(struct dap_cmd_pool));
187  if (!pool)
188  return NULL;
189  } else {
190  pool = list_first_entry(&dap->cmd_pool, struct dap_cmd_pool, lh);
191  list_del(&pool->lh);
192  }
193 
194  INIT_LIST_HEAD(&pool->lh);
195  dap->cmd_pool_size++;
196 
197  struct dap_cmd *cmd = &pool->cmd;
198  INIT_LIST_HEAD(&cmd->lh);
199  cmd->instr = instr;
200  cmd->reg_addr = reg_addr;
201  cmd->rnw = rnw;
202  if (outvalue)
203  memcpy(cmd->outvalue_buf, outvalue, 4);
204  cmd->invalue = (invalue) ? invalue : cmd->invalue_buf;
205  cmd->memaccess_tck = memaccess_tck;
206 
207  return cmd;
208 }
209 
210 static void dap_cmd_release(struct adiv5_dap *dap, struct dap_cmd *cmd)
211 {
212  struct dap_cmd_pool *pool = container_of(cmd, struct dap_cmd_pool, cmd);
214  free(pool);
215  else
216  list_add(&pool->lh, &dap->cmd_pool);
217 
218  dap->cmd_pool_size--;
219 }
220 
221 static void flush_journal(struct adiv5_dap *dap, struct list_head *lh)
222 {
223  struct dap_cmd *el, *tmp;
224 
225  list_for_each_entry_safe(el, tmp, lh, lh) {
226  list_del(&el->lh);
227  dap_cmd_release(dap, el);
228  }
229 }
230 
231 static void jtag_quit(struct adiv5_dap *dap)
232 {
233  struct dap_cmd_pool *el, *tmp;
234  struct list_head *lh = &dap->cmd_pool;
235 
236  list_for_each_entry_safe(el, tmp, lh, lh) {
237  list_del(&el->lh);
238  free(el);
239  }
240 }
241 
242 /***************************************************************************
243  *
244  * DPACC and APACC scanchain access through JTAG-DP (or SWJ-DP)
245  *
246 ***************************************************************************/
247 
248 static int adi_jtag_dp_scan_cmd(struct adiv5_dap *dap, struct dap_cmd *cmd, uint8_t *ack)
249 {
250  struct jtag_tap *tap = dap->tap;
251  int retval;
252 
253  retval = arm_jtag_set_instr(tap, cmd->instr, NULL, TAP_IDLE);
254  if (retval != ERROR_OK)
255  return retval;
256 
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.
259  */
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;
264 
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.
268  */
269 
270  cmd->fields[1].num_bits = 32;
271  cmd->fields[1].out_value = cmd->outvalue_buf;
272  cmd->fields[1].in_value = cmd->invalue;
273 
274  jtag_add_dr_scan(tap, 2, cmd->fields, TAP_IDLE);
275 
276  /* Add specified number of tck clocks after starting AP register
277  * access or memory bus access, giving the hardware time to complete
278  * the access.
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.
281  */
282  if (cmd->instr == JTAG_DP_APACC && cmd->memaccess_tck != 0)
283  jtag_add_runtest(cmd->memaccess_tck, TAP_IDLE);
284 
285  return ERROR_OK;
286 }
287 
288 static int adi_jtag_dp_scan_cmd_sync(struct adiv5_dap *dap, struct dap_cmd *cmd, uint8_t *ack)
289 {
290  int retval;
291 
292  retval = adi_jtag_dp_scan_cmd(dap, cmd, ack);
293  if (retval != ERROR_OK)
294  return retval;
295 
296  return jtag_execute_queue();
297 }
298 
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)
323 {
324  struct dap_cmd *cmd;
325  int retval;
326 
327  cmd = dap_cmd_new(dap, instr, reg_addr, rnw, outvalue, invalue, memaccess_tck);
328  if (cmd)
329  cmd->dp_select = dap->select;
330  else
332 
333  retval = adi_jtag_dp_scan_cmd(dap, cmd, ack);
334  if (retval == ERROR_OK)
335  list_add_tail(&cmd->lh, &dap->cmd_journal);
336 
337  return retval;
338 }
339 
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)
350 {
351  uint8_t out_value_buf[4];
352  int retval;
353  uint64_t sel = (reg_addr >> 4) & 0xf;
354 
355  /* No need to change SELECT or RDBUFF as they are not banked */
357  sel != (dap->select & 0xf)) {
358  if (dap->select != DP_SELECT_INVALID)
359  sel |= dap->select & ~0xfull;
360  dap->select = sel;
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)
366  return retval;
367  }
368  buf_set_u32(out_value_buf, 0, 32, outvalue);
369 
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)
373  return retval;
374 
375  if (invalue)
378 
379  return retval;
380 }
381 
382 static int adi_jtag_finish_read(struct adiv5_dap *dap)
383 {
384  int retval = ERROR_OK;
385 
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;
390  }
391 
392  return retval;
393 }
394 
396  uint8_t instr, uint16_t reg_addr, uint8_t rnw,
397  uint32_t outvalue, uint32_t *invalue, uint32_t memaccess_tck)
398 {
399  int retval;
400 
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)
405  return retval;
406 
407  /* For reads, collect posted value; RDBUFF has no other effect.
408  * Assumes read gets acked with OK/FAULT, and CTRL_STAT says "OK".
409  */
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)
414  return retval;
415  }
416 
417  return jtag_execute_queue();
418 }
419 
420 static int jtagdp_overrun_check(struct adiv5_dap *dap)
421 {
422  int retval;
423  struct dap_cmd *el, *tmp, *prev = NULL;
424  int found_wait = 0;
425  int64_t time_now;
426  LIST_HEAD(replay_list);
427 
428  /* make sure all queued transactions are complete */
429  retval = jtag_execute_queue();
430  if (retval != ERROR_OK)
431  goto done;
432 
433  /* skip all completed transactions up to the first WAIT */
434  list_for_each_entry(el, &dap->cmd_journal, lh) {
435  /*
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
439  */
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) {
443  found_wait = 1;
444  break;
445  } else {
446  LOG_ERROR("Invalid ACK (%1x) in DAP response", el->ack);
447  log_dap_cmd(dap, "ERR", el);
448  retval = ERROR_JTAG_DEVICE_ERROR;
449  goto done;
450  }
451  }
452 
453  /*
454  * If we found a stalled transaction and a previous transaction
455  * exists, check if it's a READ access.
456  */
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 */
463  tmp = el;
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));
472  }
473  prev = NULL;
474  break;
475  }
476  }
477 
478  if (prev) {
479  log_dap_cmd(dap, "LST", el);
480 
481  /*
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
488  */
489  tmp = dap_cmd_new(dap, JTAG_DP_DPACC,
490  DP_RDBUFF, DPAP_READ, NULL, NULL, 0);
491  if (!tmp) {
492  retval = ERROR_JTAG_DEVICE_ERROR;
493  goto done;
494  }
495  /* synchronously retry the command until it succeeds */
496  time_now = timeval_ms();
497  do {
498  retval = adi_jtag_dp_scan_cmd_sync(dap, tmp, NULL);
499  if (retval != ERROR_OK)
500  break;
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));
507  }
508  break;
509  }
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;
514  break;
515  }
516 
517  } while (timeval_ms() - time_now < 1000);
518 
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 */
528  dap->dp_ctrl_stat | SSTICKYORUN, NULL, 0);
529  retval = ERROR_JTAG_DEVICE_ERROR;
530  }
531  }
532 
533  /* we're done with this command, release it */
534  dap_cmd_release(dap, tmp);
535 
536  if (retval != ERROR_OK)
537  goto done;
538 
539  }
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;
544  }
545  }
546 
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);
551  }
552 
553  /* we're done with the journal, flush it */
554  flush_journal(dap, &dap->cmd_journal);
555 
556  /* check for overrun condition in the last batch of transactions */
557  if (found_wait) {
558  LOG_INFO("DAP transaction stalled (WAIT) - slowing down and resending");
559  /* clear the sticky overrun condition */
562  dap->dp_ctrl_stat | SSTICKYORUN, NULL, 0);
563  if (retval != ERROR_OK)
564  goto done;
565 
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);
571  if (!tmp) {
572  retval = ERROR_JTAG_DEVICE_ERROR;
573  goto done;
574  }
575  list_add(&tmp->lh, &replay_list);
576 
577  dap->select = DP_SELECT_INVALID;
578  }
579 
580  list_for_each_entry_safe(el, tmp, &replay_list, lh) {
581  time_now = timeval_ms();
582  do {
583  retval = adi_jtag_dp_scan_cmd_sync(dap, el, NULL);
584  if (retval != ERROR_OK)
585  break;
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));
591  }
592  break;
593  }
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;
598  break;
599  }
600  LOG_DEBUG("DAP transaction stalled during replay (WAIT) - resending");
601  /* clear the sticky overrun condition */
604  dap->dp_ctrl_stat | SSTICKYORUN, NULL, 0);
605  if (retval != ERROR_OK)
606  break;
607  } while (timeval_ms() - time_now < 1000);
608 
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 */
617  dap->dp_ctrl_stat | SSTICKYORUN, NULL, 0);
618  retval = ERROR_JTAG_DEVICE_ERROR;
619  break;
620  }
621  } else
622  break;
623  }
624  }
625 
626  done:
627  flush_journal(dap, &replay_list);
628  flush_journal(dap, &dap->cmd_journal);
629  return retval;
630 }
631 
632 static int jtagdp_transaction_endcheck(struct adiv5_dap *dap)
633 {
634  int retval;
635  uint32_t ctrlstat, pwrmask;
636 
637  /* too expensive to call keep_alive() here */
638 
639  /* Post CTRL/STAT read; discard any previous posted read value
640  * but collect its ACK status.
641  */
643  DP_CTRL_STAT, DPAP_READ, 0, &ctrlstat, 0);
644  if (retval != ERROR_OK)
645  goto done;
646 
647  /* REVISIT also STICKYCMP, for pushed comparisons (nyet used) */
648 
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;
659  }
660 
661  if (ctrlstat & SSTICKYERR)
662  LOG_ERROR("JTAG-DP STICKY ERROR");
663  if (ctrlstat & SSTICKYORUN)
664  LOG_DEBUG("JTAG-DP STICKY OVERRUN");
665 
666  /* Clear Sticky Error and Sticky Overrun Bits */
669  dap->dp_ctrl_stat | SSTICKYERR | SSTICKYORUN, NULL, 0);
670  if (retval != ERROR_OK)
671  goto done;
672 
673  retval = ERROR_JTAG_DEVICE_ERROR;
674  }
675 
676  done:
677  flush_journal(dap, &dap->cmd_journal);
678  return retval;
679 }
680 
681 /*--------------------------------------------------------------------------*/
682 
683 static int jtag_connect(struct adiv5_dap *dap)
684 {
685  dap->do_reconnect = false;
686  return dap_dp_init(dap);
687 }
688 
689 static int jtag_check_reconnect(struct adiv5_dap *dap)
690 {
691  if (dap->do_reconnect)
692  return jtag_connect(dap);
693 
694  return ERROR_OK;
695 }
696 
697 static int jtag_send_sequence(struct adiv5_dap *dap, enum swd_special_seq seq)
698 {
699  int retval;
700 
701  switch (seq) {
702  case JTAG_TO_SWD:
705  break;
706  case SWD_TO_JTAG:
709  break;
710  default:
711  LOG_ERROR("Sequence %d not supported", seq);
712  return ERROR_FAIL;
713  }
714  if (retval == ERROR_OK)
715  retval = jtag_execute_queue();
716  return retval;
717 }
718 
719 static int jtag_dp_q_read(struct adiv5_dap *dap, unsigned reg,
720  uint32_t *data)
721 {
722  int retval = jtag_limit_queue_size(dap);
723  if (retval != ERROR_OK)
724  return retval;
725 
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;
729  return retval;
730 }
731 
732 static int jtag_dp_q_write(struct adiv5_dap *dap, unsigned reg,
733  uint32_t data)
734 {
735  int retval = jtag_limit_queue_size(dap);
736  if (retval != ERROR_OK)
737  return retval;
738 
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;
742  return retval;
743 }
744 
746 static int jtag_ap_q_bankselect(struct adiv5_ap *ap, unsigned reg)
747 {
748  int retval;
749  struct adiv5_dap *dap = ap->dap;
750  uint64_t sel;
751 
752  if (is_adiv6(dap)) {
753  sel = ap->ap_num | (reg & 0x00000FF0);
754  if (sel == (dap->select & ~0xfull))
755  return ERROR_OK;
756 
757  if (dap->select != DP_SELECT_INVALID)
758  sel |= dap->select & 0xf;
759  dap->select = sel;
760  LOG_DEBUG("AP BANKSEL: %" PRIx64, sel);
761 
762  retval = jtag_dp_q_write(dap, DP_SELECT, (uint32_t)sel);
763  if (retval != ERROR_OK)
764  return retval;
765 
766  if (dap->asize > 32)
767  return jtag_dp_q_write(dap, DP_SELECT1, (uint32_t)(sel >> 32));
768  return ERROR_OK;
769  }
770 
771  /* ADIv5 */
772  sel = (ap->ap_num << 24) | (reg & 0x000000F0);
773 
774  if (sel == dap->select)
775  return ERROR_OK;
776 
777  dap->select = sel;
778 
779  return jtag_dp_q_write(dap, DP_SELECT, (uint32_t)sel);
780 }
781 
782 static int jtag_ap_q_read(struct adiv5_ap *ap, unsigned reg,
783  uint32_t *data)
784 {
785  int retval = jtag_limit_queue_size(ap->dap);
786  if (retval != ERROR_OK)
787  return retval;
788 
789  retval = jtag_check_reconnect(ap->dap);
790  if (retval != ERROR_OK)
791  return retval;
792 
793  retval = jtag_ap_q_bankselect(ap, reg);
794  if (retval != ERROR_OK)
795  return retval;
796 
799  ap->dap->last_read = data;
800 
801  return retval;
802 }
803 
804 static int jtag_ap_q_write(struct adiv5_ap *ap, unsigned reg,
805  uint32_t data)
806 {
807  int retval = jtag_limit_queue_size(ap->dap);
808  if (retval != ERROR_OK)
809  return retval;
810 
811  retval = jtag_check_reconnect(ap->dap);
812  if (retval != ERROR_OK)
813  return retval;
814 
815  retval = jtag_ap_q_bankselect(ap, reg);
816  if (retval != ERROR_OK)
817  return retval;
818 
821  ap->dap->last_read = NULL;
822  return retval;
823 }
824 
825 static int jtag_ap_q_abort(struct adiv5_dap *dap, uint8_t *ack)
826 {
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)
831  return retval;
832 
833  return jtag_execute_queue();
834 }
835 
836 static int jtag_dp_run(struct adiv5_dap *dap)
837 {
838  int retval;
839  int retval2 = ERROR_OK;
840 
841  retval = adi_jtag_finish_read(dap);
842  if (retval != ERROR_OK)
843  goto done;
844  retval2 = jtagdp_overrun_check(dap);
845  retval = jtagdp_transaction_endcheck(dap);
846 
847  done:
848  return (retval2 != ERROR_OK) ? retval2 : retval;
849 }
850 
851 static int jtag_dp_sync(struct adiv5_dap *dap)
852 {
853  return jtagdp_overrun_check(dap);
854 }
855 
856 /* FIXME don't export ... just initialize as
857  * part of DAP setup
858 */
859 const struct dap_ops jtag_dp_ops = {
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,
867  .run = jtag_dp_run,
868  .sync = jtag_dp_sync,
869  .quit = jtag_quit,
870 };
const struct dap_ops jtag_dp_ops
Definition: adi_v5_jtag.c:859
#define JTAG_ACK_OK_FAULT
Definition: adi_v5_jtag.c:44
static int jtag_dp_sync(struct adiv5_dap *dap)
Definition: adi_v5_jtag.c:851
static int jtagdp_overrun_check(struct adiv5_dap *dap)
Definition: adi_v5_jtag.c:420
#define JTAG_DP_APACC
Definition: adi_v5_jtag.c:39
static int jtag_send_sequence(struct adiv5_dap *dap, enum swd_special_seq seq)
Definition: adi_v5_jtag.c:697
#define JTAG_DP_DPACC
Definition: adi_v5_jtag.c:38
static int jtag_ap_q_write(struct adiv5_ap *ap, unsigned reg, uint32_t data)
Definition: adi_v5_jtag.c:804
static int adi_jtag_scan_inout_check_u32(struct adiv5_dap *dap, uint8_t instr, uint16_t reg_addr, uint8_t rnw, uint32_t outvalue, uint32_t *invalue, uint32_t memaccess_tck)
Definition: adi_v5_jtag.c:395
static struct dap_cmd * dap_cmd_new(struct adiv5_dap *dap, uint8_t instr, uint16_t reg_addr, uint8_t rnw, uint8_t *outvalue, uint8_t *invalue, uint32_t memaccess_tck)
Definition: adi_v5_jtag.c:177
static int adi_jtag_dp_scan_u32(struct adiv5_dap *dap, uint8_t instr, uint16_t reg_addr, uint8_t rnw, uint32_t outvalue, uint32_t *invalue, uint32_t memaccess_tck, uint8_t *ack)
Scan DPACC or APACC out and in from host ordered uint32_t buffers.
Definition: adi_v5_jtag.c:346
#define JTAG_DP_ABORT
Definition: adi_v5_jtag.c:37
static void flush_journal(struct adiv5_dap *dap, struct list_head *lh)
Definition: adi_v5_jtag.c:221
#define MAX_DAP_COMMAND_NUM
Definition: adi_v5_jtag.c:127
static void dap_cmd_release(struct adiv5_dap *dap, struct dap_cmd *cmd)
Definition: adi_v5_jtag.c:210
static int jtag_connect(struct adiv5_dap *dap)
Definition: adi_v5_jtag.c:683
static int jtag_dp_q_read(struct adiv5_dap *dap, unsigned reg, uint32_t *data)
Definition: adi_v5_jtag.c:719
static void jtag_quit(struct adiv5_dap *dap)
Definition: adi_v5_jtag.c:231
static int adi_jtag_dp_scan_cmd_sync(struct adiv5_dap *dap, struct dap_cmd *cmd, uint8_t *ack)
Definition: adi_v5_jtag.c:288
static int jtagdp_transaction_endcheck(struct adiv5_dap *dap)
Definition: adi_v5_jtag.c:632
static int adi_jtag_finish_read(struct adiv5_dap *dap)
Definition: adi_v5_jtag.c:382
static int jtag_limit_queue_size(struct adiv5_dap *dap)
Definition: adi_v5_jtag.c:169
static int adi_jtag_dp_scan_cmd(struct adiv5_dap *dap, struct dap_cmd *cmd, uint8_t *ack)
Definition: adi_v5_jtag.c:248
static int jtag_ap_q_bankselect(struct adiv5_ap *ap, unsigned reg)
Select the AP register bank matching bits 7:4 of reg.
Definition: adi_v5_jtag.c:746
static int jtag_ap_q_abort(struct adiv5_dap *dap, uint8_t *ack)
Definition: adi_v5_jtag.c:825
static int jtag_ap_q_read(struct adiv5_ap *ap, unsigned reg, uint32_t *data)
Definition: adi_v5_jtag.c:782
static int adi_jtag_dp_scan(struct adiv5_dap *dap, uint8_t instr, uint16_t reg_addr, uint8_t rnw, uint8_t *outvalue, uint8_t *invalue, uint32_t memaccess_tck, uint8_t *ack)
Scan DPACC or APACC using target ordered uint8_t buffers.
Definition: adi_v5_jtag.c:319
#define JTAG_ACK_WAIT
Definition: adi_v5_jtag.c:43
static int jtag_dp_run(struct adiv5_dap *dap)
Definition: adi_v5_jtag.c:836
static int jtag_check_reconnect(struct adiv5_dap *dap)
Definition: adi_v5_jtag.c:689
#define JTAG_ACK_OK
Definition: adi_v5_jtag.c:46
static void log_dap_cmd(struct adiv5_dap *dap, const char *header, struct dap_cmd *el)
Definition: adi_v5_jtag.c:134
static int jtag_dp_q_write(struct adiv5_dap *dap, unsigned reg, uint32_t data)
Definition: adi_v5_jtag.c:732
Holds the interface to ARM cores.
int dap_dp_init(struct adiv5_dap *dap)
Initialize a DAP.
Definition: arm_adi_v5.c:675
This defines formats and data structures used to talk to ADIv5 entities.
#define MEM_AP_REG_CSW(dap)
Definition: arm_adi_v5.h:141
#define SSTICKYERR
Definition: arm_adi_v5.h:86
#define DPAP_WRITE
Definition: arm_adi_v5.h:35
#define MEM_AP_REG_CFG(dap)
Definition: arm_adi_v5.h:151
#define CDBGPWRUPREQ
Definition: arm_adi_v5.h:93
#define MEM_AP_REG_TAR(dap)
Definition: arm_adi_v5.h:142
#define MEM_AP_REG_BD3(dap)
Definition: arm_adi_v5.h:148
#define DP_ABORT
Definition: arm_adi_v5.h:46
#define DP_SELECT
Definition: arm_adi_v5.h:57
#define DP_CTRL_STAT
Definition: arm_adi_v5.h:50
#define DP_SELECT1
Definition: arm_adi_v5.h:55
#define CDBGPWRUPACK
Definition: arm_adi_v5.h:94
#define DP_DLCR
Definition: arm_adi_v5.h:51
#define MEM_AP_REG_BD1(dap)
Definition: arm_adi_v5.h:146
#define SSTICKYORUN
Definition: arm_adi_v5.h:83
#define DP_SELECT_INVALID
Definition: arm_adi_v5.h:103
#define CSYSPWRUPACK
Definition: arm_adi_v5.h:96
#define DP_RDBUFF
Definition: arm_adi_v5.h:58
#define MEM_AP_REG_DRW(dap)
Definition: arm_adi_v5.h:144
#define MEM_AP_REG_BASE(dap)
Definition: arm_adi_v5.h:152
#define MEM_AP_REG_BD2(dap)
Definition: arm_adi_v5.h:147
swd_special_seq
Definition: arm_adi_v5.h:229
@ JTAG_TO_SWD
Definition: arm_adi_v5.h:231
@ SWD_TO_JTAG
Definition: arm_adi_v5.h:233
#define CSYSPWRUPREQ
Definition: arm_adi_v5.h:95
#define MEM_AP_REG_BASE64(dap)
Definition: arm_adi_v5.h:150
#define MEM_AP_REG_BD0(dap)
Definition: arm_adi_v5.h:145
static bool is_adiv6(const struct adiv5_dap *dap)
Check if DAP is ADIv6.
Definition: arm_adi_v5.h:479
#define MEM_AP_REG_TAR64(dap)
Definition: arm_adi_v5.h:143
#define DPAP_READ
Definition: arm_adi_v5.h:36
static int dap_run(struct adiv5_dap *dap)
Perform all queued DAP operations, and clear any errors posted in the CTRL_STAT register when they ar...
Definition: arm_adi_v5.h:604
#define AP_REG_IDR(dap)
Definition: arm_adi_v5.h:157
static int arm_jtag_set_instr(struct jtag_tap *tap, uint32_t new_instr, void *no_verify_capture, tap_state_t end_state)
Definition: arm_jtag.h:31
static void arm_le_to_h_u32(jtag_callback_data_t arg)
Definition: arm_jtag.h:63
static uint32_t buf_get_u32(const uint8_t *_buffer, unsigned first, unsigned num)
Retrieves num bits from _buffer, starting at the first bit, returning the bits in a 32-bit word.
Definition: binarybuffer.h:98
static void buf_set_u32(uint8_t *_buffer, unsigned first, unsigned num, uint32_t value)
Sets num bits in _buffer, starting at the first bit, using the bits in value.
Definition: binarybuffer.h:30
int jtag_add_tms_seq(unsigned nbits, const uint8_t *seq, enum tap_state state)
If supported by the underlying adapter, this clocks a raw bit sequence onto TMS for switching between...
Definition: jtag/core.c:502
int jtag_execute_queue(void)
For software FIFO implementations, the queued commands can be executed during this call or earlier.
Definition: jtag/core.c:1037
void jtag_add_runtest(int num_cycles, tap_state_t state)
Goes to TAP_IDLE (if we're not already there), cycle precisely num_cycles in the TAP_IDLE state,...
Definition: jtag/core.c:592
void jtag_add_dr_scan(struct jtag_tap *active, int in_num_fields, const struct scan_field *in_fields, tap_state_t state)
Generate a DR SCAN using the fields passed to the function.
Definition: jtag/core.c:451
void jtag_add_callback(jtag_callback1_t f, jtag_callback_data_t data0)
A simpler version of jtag_add_callback4().
#define ERROR_JTAG_DEVICE_ERROR
Definition: jtag.h:555
@ TAP_RESET
Definition: jtag.h:55
@ TAP_IDLE
Definition: jtag.h:52
@ TAP_INVALID
Definition: jtag.h:37
intptr_t jtag_callback_data_t
Defines the type of data passed to the jtag_callback_t interface.
Definition: jtag.h:333
static void list_add(struct list_head *new, struct list_head *head)
list_add - add a new entry
Definition: list.h:112
static void list_move_tail(struct list_head *list, struct list_head *head)
list_move_tail - delete from one list and add as another's tail
Definition: list.h:240
#define list_entry(ptr, type, member)
list_entry - get the struct for this entry
Definition: list.h:526
#define list_first_entry(ptr, type, member)
list_first_entry - get the first element from a list
Definition: list.h:537
#define list_for_each_entry_from(pos, head, member)
list_for_each_entry_from - iterate over list of given type from the current point
Definition: list.h:720
#define LIST_HEAD(name)
Definition: list.h:51
static void list_add_tail(struct list_head *new, struct list_head *head)
list_add_tail - add a new entry
Definition: list.h:126
static int list_empty(const struct list_head *head)
list_empty - tests whether a list is empty
Definition: list.h:296
#define list_for_each_entry(pos, head, member)
list_for_each_entry - iterate over list of given type
Definition: list.h:643
static void list_del(struct list_head *entry)
list_del - deletes entry from list.
Definition: list.h:160
#define list_for_each_entry_safe_from(pos, n, head, member)
list_for_each_entry_safe_from - iterate over list from current point safe against removal
Definition: list.h:776
#define list_for_each_entry_safe(pos, n, head, member)
list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
Definition: list.h:744
static void INIT_LIST_HEAD(struct list_head *list)
INIT_LIST_HEAD - Initialize a list_head structure.
Definition: list.h:61
#define ERROR_FAIL
Definition: log.h:161
#define LOG_ERROR(expr ...)
Definition: log.h:123
#define LOG_INFO(expr ...)
Definition: log.h:117
#define LOG_DEBUG(expr ...)
Definition: log.h:109
#define ERROR_OK
Definition: log.h:155
static uint32_t lh(unsigned int rd, unsigned int base, uint16_t offset) __attribute__((unused))
Definition: opcodes.h:117
This represents an ARM Debug Interface (v5) Access Port (AP).
Definition: arm_adi_v5.h:243
uint64_t ap_num
ADIv5: Number of this AP (0~255) ADIv6: Base address of this AP (4k aligned) TODO: to be more coheren...
Definition: arm_adi_v5.h:254
struct adiv5_dap * dap
DAP this AP belongs to.
Definition: arm_adi_v5.h:247
uint32_t memaccess_tck
Configures how many extra tck clocks are added after starting a MEM-AP access before we try to read i...
Definition: arm_adi_v5.h:279
This represents an ARM Debug Interface (v5) Debug Access Port (DAP).
Definition: arm_adi_v5.h:320
uint8_t ack
Definition: arm_adi_v5.h:348
struct list_head cmd_journal
Definition: arm_adi_v5.h:324
struct adiv5_ap ap[DP_APSEL_MAX+1]
Definition: arm_adi_v5.h:336
size_t cmd_pool_size
Definition: arm_adi_v5.h:330
uint32_t dp_ctrl_stat
Definition: arm_adi_v5.h:334
bool do_reconnect
Signals that an attempt to reestablish communication afresh should be performed before the next acces...
Definition: arm_adi_v5.h:376
uint32_t * last_read
Holds the pointer to the destination word for the last queued read, for use with posted AP read seque...
Definition: arm_adi_v5.h:354
struct jtag_tap * tap
Definition: arm_adi_v5.h:332
uint64_t select
Cache for DP_SELECT register.
Definition: arm_adi_v5.h:345
struct list_head cmd_pool
Definition: arm_adi_v5.h:327
unsigned int asize
Definition: arm_adi_v5.h:398
bool ignore_syspwrupack
Flag saying whether to ignore the syspwrupack flag in DAP.
Definition: arm_adi_v5.h:380
struct dap_cmd cmd
Definition: adi_v5_jtag.c:131
struct list_head lh
Definition: adi_v5_jtag.c:130
uint16_t reg_addr
Definition: adi_v5_jtag.c:114
uint8_t invalue_buf[4]
Definition: adi_v5_jtag.c:123
uint8_t * invalue
Definition: adi_v5_jtag.c:116
uint64_t dp_select
Definition: adi_v5_jtag.c:119
struct scan_field fields[2]
Definition: adi_v5_jtag.c:121
uint8_t rnw
Definition: adi_v5_jtag.c:115
uint8_t ack
Definition: adi_v5_jtag.c:117
uint8_t out_addr_buf
Definition: adi_v5_jtag.c:122
uint8_t outvalue_buf[4]
Definition: adi_v5_jtag.c:124
struct list_head lh
Definition: adi_v5_jtag.c:112
uint8_t instr
Definition: adi_v5_jtag.c:113
uint32_t memaccess_tck
Definition: adi_v5_jtag.c:118
Transport-neutral representation of queued DAP transactions, supporting both JTAG and SWD transports.
Definition: arm_adi_v5.h:408
int(* connect)(struct adiv5_dap *dap)
connect operation for SWD
Definition: arm_adi_v5.h:410
Definition: jtag.h:100
Definition: list.h:26
struct list_head * prev
Definition: list.h:27
Definition: register.h:111
This structure defines a single scan field in the scan.
Definition: jtag.h:86
static const unsigned swd_seq_swd_to_jtag_len
Definition: swd.h:144
static const unsigned swd_seq_jtag_to_swd_len
Definition: swd.h:125
static const uint8_t swd_seq_jtag_to_swd[]
JTAG-to-SWD sequence.
Definition: swd.h:115
static const uint8_t swd_seq_swd_to_jtag[]
SWD-to-JTAG sequence.
Definition: swd.h:136
int64_t timeval_ms(void)
static uint32_t le_to_h_u32(const uint8_t *buf)
Definition: types.h:112
#define container_of(ptr, type, member)
Cast a member of a structure out to the containing structure.
Definition: types.h:68
#define NULL
Definition: usb.h:16
uint8_t cmd
Definition: vdebug.c:1