?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
disable polling continuous polling during reset
[openocd.git] / src / target / arm_adi_v5.c
blob609518526acaf423366a43999ef2460c69b534ef
1 /***************************************************************************
2 * Copyright (C) 2006 by Magnus Lundin *
3 * lundin@mlu.mine.nu *
4 * *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
7 * *
8 * Copyright (C) 2009 by Oyvind Harboe *
9 * oyvind.harboe@zylin.com *
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
20 * *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
26 /***************************************************************************
27 * *
28 * This file implements support for the ARM Debug Interface v5 (ADI_V5) *
29 * *
30 * ARM(tm) Debug Interface v5 Architecture Specification ARM IHI 0031A *
31 * *
32 * CoreSight(tm) DAP-Lite TRM, ARM DDI 0316A *
33 * Cortex-M3(tm) TRM, ARM DDI 0337C *
34 * *
35 ***************************************************************************/
36
37 #ifdef HAVE_CONFIG_H
38 #include "config.h"
39 #endif
40
41 #include "arm_adi_v5.h"
42 #include "time_support.h"
43
44 /*
45 * Transaction Mode:
46 * swjdp->trans_mode = TRANS_MODE_COMPOSITE;
47 * Uses Overrun checking mode and does not do actual JTAG send/receive or transaction
48 * result checking until swjdp_end_transaction()
49 * This must be done before using or deallocating any return variables.
50 * swjdp->trans_mode == TRANS_MODE_ATOMIC
51 * All reads and writes to the AHB bus are checked for valid completion, and return values
52 * are immediatley available.
53 */
54
55
56 /* ARM ADI Specification requires at least 10 bits used for TAR autoincrement */
57
58 /*
59 u32 tar_block_size(u32 address)
60 Return the largest block starting at address that does not cross a tar block size alignment boundary
61 */
62 static u32 max_tar_block_size(u32 tar_autoincr_block, u32 address)
63 {
64 return (tar_autoincr_block - ((tar_autoincr_block - 1) & address)) >> 2;
65 }
66
67 /***************************************************************************
68 * *
69 * DPACC and APACC scanchain access through JTAG-DP *
70 * *
71 ***************************************************************************/
72
73 /* Scan out and in from target ordered u8 buffers */
74 int adi_jtag_dp_scan(swjdp_common_t *swjdp, u8 instr, u8 reg_addr, u8 RnW, u8 *outvalue, u8 *invalue, u8 *ack)
75 {
76 arm_jtag_t *jtag_info = swjdp->jtag_info;
77 scan_field_t fields[2];
78 u8 out_addr_buf;
79
80 jtag_set_end_state(TAP_IDLE);
81 arm_jtag_set_instr(jtag_info, instr, NULL);
82
83 /* Add specified number of tck clocks before accessing memory bus */
84 if ((instr == DAP_IR_APACC) && ((reg_addr == AP_REG_DRW)||((reg_addr&0xF0) == AP_REG_BD0) )&& (swjdp->memaccess_tck != 0))
85 jtag_add_runtest(swjdp->memaccess_tck, jtag_set_end_state(TAP_IDLE));
86
87 fields[0].tap = jtag_info->tap;
88 fields[0].num_bits = 3;
89 buf_set_u32(&out_addr_buf, 0, 3, ((reg_addr >> 1) & 0x6) | (RnW & 0x1));
90 fields[0].out_value = &out_addr_buf;
91 fields[0].in_value = ack;
92
93 fields[1].tap = jtag_info->tap;
94 fields[1].num_bits = 32;
95 fields[1].out_value = outvalue;
96 fields[1].in_value = invalue;
97
98 jtag_add_dr_scan(2, fields, jtag_get_end_state());
99
100 return ERROR_OK;
101 }
102
103 /* Scan out and in from host ordered u32 variables */
104 int adi_jtag_dp_scan_u32(swjdp_common_t *swjdp, u8 instr, u8 reg_addr, u8 RnW, u32 outvalue, u32 *invalue, u8 *ack)
105 {
106 arm_jtag_t *jtag_info = swjdp->jtag_info;
107 scan_field_t fields[2];
108 u8 out_value_buf[4];
109 u8 out_addr_buf;
110
111 jtag_set_end_state(TAP_IDLE);
112 arm_jtag_set_instr(jtag_info, instr, NULL);
113
114 /* Add specified number of tck clocks before accessing memory bus */
115 if ((instr == DAP_IR_APACC) && ((reg_addr == AP_REG_DRW)||((reg_addr&0xF0) == AP_REG_BD0) )&& (swjdp->memaccess_tck != 0))
116 jtag_add_runtest(swjdp->memaccess_tck, jtag_set_end_state(TAP_IDLE));
117
118 fields[0].tap = jtag_info->tap;
119 fields[0].num_bits = 3;
120 buf_set_u32(&out_addr_buf, 0, 3, ((reg_addr >> 1) & 0x6) | (RnW & 0x1));
121 fields[0].out_value = &out_addr_buf;
122 fields[0].in_value = ack;
123
124 fields[1].tap = jtag_info->tap;
125 fields[1].num_bits = 32;
126 buf_set_u32(out_value_buf, 0, 32, outvalue);
127 fields[1].out_value = out_value_buf;
128 fields[1].in_value = NULL;
129
130 if (invalue)
131 {
132 fields[1].in_value = (u8 *)invalue;
133 jtag_add_dr_scan(2, fields, jtag_get_end_state());
134
135 jtag_add_callback(arm_le_to_h_u32, (u8 *)invalue);
136 } else
137 {
138
139 jtag_add_dr_scan(2, fields, jtag_get_end_state());
140 }
141
142 return ERROR_OK;
143 }
144
145 /* scan_inout_check adds one extra inscan for DPAP_READ commands to read variables */
146 int scan_inout_check(swjdp_common_t *swjdp, u8 instr, u8 reg_addr, u8 RnW, u8 *outvalue, u8 *invalue)
147 {
148 adi_jtag_dp_scan(swjdp, instr, reg_addr, RnW, outvalue, NULL, NULL);
149
150 if ((RnW == DPAP_READ) && (invalue != NULL))
151 {
152 adi_jtag_dp_scan(swjdp, DAP_IR_DPACC, DP_RDBUFF, DPAP_READ, 0, invalue, &swjdp->ack);
153 }
154
155 /* In TRANS_MODE_ATOMIC all DAP_IR_APACC transactions wait for ack=OK/FAULT and the check CTRL_STAT */
156 if ((instr == DAP_IR_APACC) && (swjdp->trans_mode == TRANS_MODE_ATOMIC))
157 {
158 return swjdp_transaction_endcheck(swjdp);
159 }
160
161 return ERROR_OK;
162 }
163
164 int scan_inout_check_u32(swjdp_common_t *swjdp, u8 instr, u8 reg_addr, u8 RnW, u32 outvalue, u32 *invalue)
165 {
166 adi_jtag_dp_scan_u32(swjdp, instr, reg_addr, RnW, outvalue, NULL, NULL);
167
168 if ((RnW==DPAP_READ) && (invalue != NULL))
169 {
170 adi_jtag_dp_scan_u32(swjdp, DAP_IR_DPACC, DP_RDBUFF, DPAP_READ, 0, invalue, &swjdp->ack);
171 }
172
173 /* In TRANS_MODE_ATOMIC all DAP_IR_APACC transactions wait for ack=OK/FAULT and then check CTRL_STAT */
174 if ((instr == DAP_IR_APACC) && (swjdp->trans_mode == TRANS_MODE_ATOMIC))
175 {
176 return swjdp_transaction_endcheck(swjdp);
177 }
178
179 return ERROR_OK;
180 }
181
182 int swjdp_transaction_endcheck(swjdp_common_t *swjdp)
183 {
184 int retval;
185 u32 ctrlstat;
186
187 /* too expensive to call keep_alive() here */
188
189 #if 0
190 /* Danger!!!! BROKEN!!!! */
191 scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_READ, 0, &ctrlstat);
192 /* Danger!!!! BROKEN!!!! Why will jtag_execute_queue() fail here????
193 R956 introduced the check on return value here and now Michael Schwingen reports
194 that this code no longer works....
195
196 https://lists.berlios.de/pipermail/openocd-development/2008-September/003107.html
197 */
198 if ((retval=jtag_execute_queue())!=ERROR_OK)
199 {
200 LOG_ERROR("BUG: Why does this fail the first time????");
201 }
202 /* Why??? second time it works??? */
203 #endif
204
205 scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_READ, 0, &ctrlstat);
206 if ((retval=jtag_execute_queue())!=ERROR_OK)
207 return retval;
208
209 swjdp->ack = swjdp->ack & 0x7;
210
211 if (swjdp->ack != 2)
212 {
213 long long then=timeval_ms();
214 while (swjdp->ack != 2)
215 {
216 if (swjdp->ack == 1)
217 {
218 if ((timeval_ms()-then) > 1000)
219 {
220 LOG_WARNING("Timeout (1000ms) waiting for ACK = OK/FAULT in SWJDP transaction");
221 return ERROR_JTAG_DEVICE_ERROR;
222 }
223 }
224 else
225 {
226 LOG_WARNING("Invalid ACK in SWJDP transaction");
227 return ERROR_JTAG_DEVICE_ERROR;
228 }
229
230 scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_READ, 0, &ctrlstat);
231 if ((retval=jtag_execute_queue())!=ERROR_OK)
232 return retval;
233 swjdp->ack = swjdp->ack & 0x7;
234 }
235 } else
236 {
237 /* common code path avoids fn to timeval_ms() */
238 }
239
240 /* Check for STICKYERR and STICKYORUN */
241 if (ctrlstat & (SSTICKYORUN | SSTICKYERR))
242 {
243 LOG_DEBUG("swjdp: CTRL/STAT error 0x%x", ctrlstat);
244 /* Check power to debug regions */
245 if ((ctrlstat & 0xf0000000) != 0xf0000000)
246 {
247 ahbap_debugport_init(swjdp);
248 }
249 else
250 {
251 u32 mem_ap_csw, mem_ap_tar;
252
253 /* Print information about last AHBAP access */
254 LOG_ERROR("AHBAP Cached values: dp_select 0x%x, ap_csw 0x%x, ap_tar 0x%x", swjdp->dp_select_value, swjdp->ap_csw_value, swjdp->ap_tar_value);
255 if (ctrlstat & SSTICKYORUN)
256 LOG_ERROR("SWJ-DP OVERRUN - check clock or reduce jtag speed");
257
258 if (ctrlstat & SSTICKYERR)
259 LOG_ERROR("SWJ-DP STICKY ERROR");
260
261 /* Clear Sticky Error Bits */
262 scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_WRITE, swjdp->dp_ctrl_stat | SSTICKYORUN | SSTICKYERR, NULL);
263 scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_READ, 0, &ctrlstat);
264 if ((retval=jtag_execute_queue())!=ERROR_OK)
265 return retval;
266
267 LOG_DEBUG("swjdp: status 0x%x", ctrlstat);
268
269 dap_ap_read_reg_u32(swjdp, AP_REG_CSW, &mem_ap_csw);
270 dap_ap_read_reg_u32(swjdp, AP_REG_TAR, &mem_ap_tar);
271 if ((retval=jtag_execute_queue())!=ERROR_OK)
272 return retval;
273 LOG_ERROR("Read MEM_AP_CSW 0x%x, MEM_AP_TAR 0x%x", mem_ap_csw, mem_ap_tar);
274
275 }
276 if ((retval=jtag_execute_queue())!=ERROR_OK)
277 return retval;
278 return ERROR_JTAG_DEVICE_ERROR;
279 }
280
281 return ERROR_OK;
282 }
283
284 /***************************************************************************
285 * *
286 * DP and MEM-AP register access through APACC and DPACC *
287 * *
288 ***************************************************************************/
289
290 int dap_dp_write_reg(swjdp_common_t *swjdp, u32 value, u8 reg_addr)
291 {
292 return scan_inout_check_u32(swjdp, DAP_IR_DPACC, reg_addr, DPAP_WRITE, value, NULL);
293 }
294
295 int dap_dp_read_reg(swjdp_common_t *swjdp, u32 *value, u8 reg_addr)
296 {
297 return scan_inout_check_u32(swjdp, DAP_IR_DPACC, reg_addr, DPAP_READ, 0, value);
298 }
299
300 int dap_ap_select(swjdp_common_t *swjdp,u8 apsel)
301 {
302 u32 select;
303 select = (apsel<<24) & 0xFF000000;
304
305 if (select != swjdp->apsel)
306 {
307 swjdp->apsel = select;
308 /* Switching AP invalidates cached values */
309 swjdp->dp_select_value = -1;
310 swjdp->ap_csw_value = -1;
311 swjdp->ap_tar_value = -1;
312 }
313
314 return ERROR_OK;
315 }
316
317 int dap_dp_bankselect(swjdp_common_t *swjdp,u32 ap_reg)
318 {
319 u32 select;
320 select = (ap_reg & 0x000000F0);
321
322 if (select != swjdp->dp_select_value)
323 {
324 dap_dp_write_reg(swjdp, select | swjdp->apsel, DP_SELECT);
325 swjdp->dp_select_value = select;
326 }
327
328 return ERROR_OK;
329 }
330
331 int dap_ap_write_reg(swjdp_common_t *swjdp, u32 reg_addr, u8* out_value_buf)
332 {
333 dap_dp_bankselect(swjdp, reg_addr);
334 scan_inout_check(swjdp, DAP_IR_APACC, reg_addr, DPAP_WRITE, out_value_buf, NULL);
335
336 return ERROR_OK;
337 }
338
339 int dap_ap_read_reg(swjdp_common_t *swjdp, u32 reg_addr, u8 *in_value_buf)
340 {
341 dap_dp_bankselect(swjdp, reg_addr);
342 scan_inout_check(swjdp, DAP_IR_APACC, reg_addr, DPAP_READ, 0, in_value_buf);
343
344 return ERROR_OK;
345 }
346 int dap_ap_write_reg_u32(swjdp_common_t *swjdp, u32 reg_addr, u32 value)
347 {
348 u8 out_value_buf[4];
349
350 buf_set_u32(out_value_buf, 0, 32, value);
351 dap_dp_bankselect(swjdp, reg_addr);
352 scan_inout_check(swjdp, DAP_IR_APACC, reg_addr, DPAP_WRITE, out_value_buf, NULL);
353
354 return ERROR_OK;
355 }
356
357 int dap_ap_read_reg_u32(swjdp_common_t *swjdp, u32 reg_addr, u32 *value)
358 {
359 dap_dp_bankselect(swjdp, reg_addr);
360 scan_inout_check_u32(swjdp, DAP_IR_APACC, reg_addr, DPAP_READ, 0, value);
361
362 return ERROR_OK;
363 }
364
365 /***************************************************************************
366 * *
367 * AHB-AP access to memory and system registers on AHB bus *
368 * *
369 ***************************************************************************/
370
371 int dap_setup_accessport(swjdp_common_t *swjdp, u32 csw, u32 tar)
372 {
373 csw = csw | CSW_DBGSWENABLE | CSW_MASTER_DEBUG | CSW_HPROT;
374 if (csw != swjdp->ap_csw_value)
375 {
376 /* LOG_DEBUG("swjdp : Set CSW %x",csw); */
377 dap_ap_write_reg_u32(swjdp, AP_REG_CSW, csw );
378 swjdp->ap_csw_value = csw;
379 }
380 if (tar != swjdp->ap_tar_value)
381 {
382 /* LOG_DEBUG("swjdp : Set TAR %x",tar); */
383 dap_ap_write_reg_u32(swjdp, AP_REG_TAR, tar );
384 swjdp->ap_tar_value = tar;
385 }
386 if (csw & CSW_ADDRINC_MASK)
387 {
388 /* Do not cache TAR value when autoincrementing */
389 swjdp->ap_tar_value = -1;
390 }
391 return ERROR_OK;
392 }
393
394 /*****************************************************************************
395 * *
396 * mem_ap_read_u32(swjdp_common_t *swjdp, u32 address, u32 *value) *
397 * *
398 * Read a u32 value from memory or system register *
399 * Functionally equivalent to target_read_u32(target, address, u32 *value), *
400 * but with less overhead *
401 *****************************************************************************/
402 int mem_ap_read_u32(swjdp_common_t *swjdp, u32 address, u32 *value)
403 {
404 swjdp->trans_mode = TRANS_MODE_COMPOSITE;
405
406 dap_setup_accessport(swjdp, CSW_32BIT | CSW_ADDRINC_OFF, address & 0xFFFFFFF0);
407 dap_ap_read_reg_u32(swjdp, AP_REG_BD0 | (address & 0xC), value );
408
409 return ERROR_OK;
410 }
411
412 int mem_ap_read_atomic_u32(swjdp_common_t *swjdp, u32 address, u32 *value)
413 {
414 mem_ap_read_u32(swjdp, address, value);
415
416 return swjdp_transaction_endcheck(swjdp);
417 }
418
419 /*****************************************************************************
420 * *
421 * mem_ap_write_u32(swjdp_common_t *swjdp, u32 address, u32 value) *
422 * *
423 * Write a u32 value to memory or memory mapped register *
424 * *
425 *****************************************************************************/
426 int mem_ap_write_u32(swjdp_common_t *swjdp, u32 address, u32 value)
427 {
428 swjdp->trans_mode = TRANS_MODE_COMPOSITE;
429
430 dap_setup_accessport(swjdp, CSW_32BIT | CSW_ADDRINC_OFF, address & 0xFFFFFFF0);
431 dap_ap_write_reg_u32(swjdp, AP_REG_BD0 | (address & 0xC), value );
432
433 return ERROR_OK;
434 }
435
436 int mem_ap_write_atomic_u32(swjdp_common_t *swjdp, u32 address, u32 value)
437 {
438 mem_ap_write_u32(swjdp, address, value);
439
440 return swjdp_transaction_endcheck(swjdp);
441 }
442
443 /*****************************************************************************
444 * *
445 * mem_ap_write_buf(swjdp_common_t *swjdp, u8 *buffer, int count, u32 address) *
446 * *
447 * Write a buffer in target order (little endian) *
448 * *
449 *****************************************************************************/
450 int mem_ap_write_buf_u32(swjdp_common_t *swjdp, u8 *buffer, int count, u32 address)
451 {
452 int wcount, blocksize, writecount, errorcount = 0, retval = ERROR_OK;
453 u32 adr = address;
454 u8* pBuffer = buffer;
455
456 swjdp->trans_mode = TRANS_MODE_COMPOSITE;
457
458 count >>= 2;
459 wcount = count;
460
461 /* if we have an unaligned access - reorder data */
462 if (adr & 0x3u)
463 {
464 for (writecount = 0; writecount < count; writecount++)
465 {
466 int i;
467 u32 outvalue;
468 memcpy(&outvalue, pBuffer, sizeof(u32));
469
470 for (i = 0; i < 4; i++ )
471 {
472 *((u8*)pBuffer + (adr & 0x3)) = outvalue;
473 outvalue >>= 8;
474 adr++;
475 }
476 pBuffer += sizeof(u32);
477 }
478 }
479
480 while (wcount > 0)
481 {
482 /* Adjust to write blocks within boundaries aligned to the TAR autoincremnent size*/
483 blocksize = max_tar_block_size(swjdp->tar_autoincr_block, address);
484 if (wcount < blocksize)
485 blocksize = wcount;
486
487 /* handle unaligned data at 4k boundary */
488 if (blocksize == 0)
489 blocksize = 1;
490
491 dap_setup_accessport(swjdp, CSW_32BIT | CSW_ADDRINC_SINGLE, address);
492
493 for (writecount = 0; writecount < blocksize; writecount++)
494 {
495 dap_ap_write_reg(swjdp, AP_REG_DRW, buffer + 4 * writecount );
496 }
497
498 if (swjdp_transaction_endcheck(swjdp) == ERROR_OK)
499 {
500 wcount = wcount - blocksize;
501 address = address + 4 * blocksize;
502 buffer = buffer + 4 * blocksize;
503 }
504 else
505 {
506 errorcount++;
507 }
508
509 if (errorcount > 1)
510 {
511 LOG_WARNING("Block write error address 0x%x, wcount 0x%x", address, wcount);
512 return ERROR_JTAG_DEVICE_ERROR;
513 }
514 }
515
516 return retval;
517 }
518
519 int mem_ap_write_buf_packed_u16(swjdp_common_t *swjdp, u8 *buffer, int count, u32 address)
520 {
521 int retval = ERROR_OK;
522 int wcount, blocksize, writecount, i;
523
524 swjdp->trans_mode = TRANS_MODE_COMPOSITE;
525
526 wcount = count >> 1;
527
528 while (wcount > 0)
529 {
530 int nbytes;
531
532 /* Adjust to write blocks within boundaries aligned to the TAR autoincremnent size*/
533 blocksize = max_tar_block_size(swjdp->tar_autoincr_block, address);
534
535 if (wcount < blocksize)
536 blocksize = wcount;
537
538 /* handle unaligned data at 4k boundary */
539 if (blocksize == 0)
540 blocksize = 1;
541
542 dap_setup_accessport(swjdp, CSW_16BIT | CSW_ADDRINC_PACKED, address);
543 writecount = blocksize;
544
545 do
546 {
547 nbytes = MIN((writecount << 1), 4);
548
549 if (nbytes < 4 )
550 {
551 if (mem_ap_write_buf_u16(swjdp, buffer, nbytes, address) != ERROR_OK)
552 {
553 LOG_WARNING("Block read error address 0x%x, count 0x%x", address, count);
554 return ERROR_JTAG_DEVICE_ERROR;
555 }
556
557 address += nbytes >> 1;
558 }
559 else
560 {
561 u32 outvalue;
562 memcpy(&outvalue, buffer, sizeof(u32));
563
564 for (i = 0; i < nbytes; i++ )
565 {
566 *((u8*)buffer + (address & 0x3)) = outvalue;
567 outvalue >>= 8;
568 address++;
569 }
570
571 memcpy(&outvalue, buffer, sizeof(u32));
572 dap_ap_write_reg_u32(swjdp, AP_REG_DRW, outvalue);
573 if (swjdp_transaction_endcheck(swjdp) != ERROR_OK)
574 {
575 LOG_WARNING("Block read error address 0x%x, count 0x%x", address, count);
576 return ERROR_JTAG_DEVICE_ERROR;
577 }
578 }
579
580 buffer += nbytes >> 1;
581 writecount -= nbytes >> 1;
582
583 } while (writecount);
584 wcount -= blocksize;
585 }
586
587 return retval;
588 }
589
590 int mem_ap_write_buf_u16(swjdp_common_t *swjdp, u8 *buffer, int count, u32 address)
591 {
592 int retval = ERROR_OK;
593
594 if (count >= 4)
595 return mem_ap_write_buf_packed_u16(swjdp, buffer, count, address);
596
597 swjdp->trans_mode = TRANS_MODE_COMPOSITE;
598
599 while (count > 0)
600 {
601 dap_setup_accessport(swjdp, CSW_16BIT | CSW_ADDRINC_SINGLE, address);
602 u16 svalue;
603 memcpy(&svalue, buffer, sizeof(u16));
604 u32 outvalue = (u32)svalue << 8 * (address & 0x3);
605 dap_ap_write_reg_u32(swjdp, AP_REG_DRW, outvalue );
606 retval = swjdp_transaction_endcheck(swjdp);
607 count -= 2;
608 address += 2;
609 buffer += 2;
610 }
611
612 return retval;
613 }
614
615 int mem_ap_write_buf_packed_u8(swjdp_common_t *swjdp, u8 *buffer, int count, u32 address)
616 {
617 int retval = ERROR_OK;
618 int wcount, blocksize, writecount, i;
619
620 swjdp->trans_mode = TRANS_MODE_COMPOSITE;
621
622 wcount = count;
623
624 while (wcount > 0)
625 {
626 int nbytes;
627
628 /* Adjust to write blocks within boundaries aligned to the TAR autoincremnent size*/
629 blocksize = max_tar_block_size(swjdp->tar_autoincr_block, address);
630
631 if (wcount < blocksize)
632 blocksize = wcount;
633
634 dap_setup_accessport(swjdp, CSW_8BIT | CSW_ADDRINC_PACKED, address);
635 writecount = blocksize;
636
637 do
638 {
639 nbytes = MIN(writecount, 4);
640
641 if (nbytes < 4 )
642 {
643 if (mem_ap_write_buf_u8(swjdp, buffer, nbytes, address) != ERROR_OK)
644 {
645 LOG_WARNING("Block read error address 0x%x, count 0x%x", address, count);
646 return ERROR_JTAG_DEVICE_ERROR;
647 }
648
649 address += nbytes;
650 }
651 else
652 {
653 u32 outvalue;
654 memcpy(&outvalue, buffer, sizeof(u32));
655
656 for (i = 0; i < nbytes; i++ )
657 {
658 *((u8*)buffer + (address & 0x3)) = outvalue;
659 outvalue >>= 8;
660 address++;
661 }
662
663 memcpy(&outvalue, buffer, sizeof(u32));
664 dap_ap_write_reg_u32(swjdp, AP_REG_DRW, outvalue);
665 if (swjdp_transaction_endcheck(swjdp) != ERROR_OK)
666 {
667 LOG_WARNING("Block read error address 0x%x, count 0x%x", address, count);
668 return ERROR_JTAG_DEVICE_ERROR;
669 }
670 }
671
672 buffer += nbytes;
673 writecount -= nbytes;
674
675 } while (writecount);
676 wcount -= blocksize;
677 }
678
679 return retval;
680 }
681
682 int mem_ap_write_buf_u8(swjdp_common_t *swjdp, u8 *buffer, int count, u32 address)
683 {
684 int retval = ERROR_OK;
685
686 if (count >= 4)
687 return mem_ap_write_buf_packed_u8(swjdp, buffer, count, address);
688
689 swjdp->trans_mode = TRANS_MODE_COMPOSITE;
690
691 while (count > 0)
692 {
693 dap_setup_accessport(swjdp, CSW_8BIT | CSW_ADDRINC_SINGLE, address);
694 u32 outvalue = (u32)*buffer << 8 * (address & 0x3);
695 dap_ap_write_reg_u32(swjdp, AP_REG_DRW, outvalue );
696 retval = swjdp_transaction_endcheck(swjdp);
697 count--;
698 address++;
699 buffer++;
700 }
701
702 return retval;
703 }
704
705 /*********************************************************************************
706 * *
707 * mem_ap_read_buf_u32(swjdp_common_t *swjdp, u8 *buffer, int count, u32 address) *
708 * *
709 * Read block fast in target order (little endian) into a buffer *
710 * *
711 **********************************************************************************/
712 int mem_ap_read_buf_u32(swjdp_common_t *swjdp, u8 *buffer, int count, u32 address)
713 {
714 int wcount, blocksize, readcount, errorcount = 0, retval = ERROR_OK;
715 u32 adr = address;
716 u8* pBuffer = buffer;
717
718 swjdp->trans_mode = TRANS_MODE_COMPOSITE;
719
720 count >>= 2;
721 wcount = count;
722
723 while (wcount > 0)
724 {
725 /* Adjust to read blocks within boundaries aligned to the TAR autoincremnent size*/
726 blocksize = max_tar_block_size(swjdp->tar_autoincr_block, address);
727 if (wcount < blocksize)
728 blocksize = wcount;
729
730 /* handle unaligned data at 4k boundary */
731 if (blocksize == 0)
732 blocksize = 1;
733
734 dap_setup_accessport(swjdp, CSW_32BIT | CSW_ADDRINC_SINGLE, address);
735
736 /* Scan out first read */
737 adi_jtag_dp_scan(swjdp, DAP_IR_APACC, AP_REG_DRW, DPAP_READ, 0, NULL, NULL);
738 for (readcount = 0; readcount < blocksize - 1; readcount++)
739 {
740 /* Scan out read instruction and scan in previous value */
741 adi_jtag_dp_scan(swjdp, DAP_IR_APACC, AP_REG_DRW, DPAP_READ, 0, buffer + 4 * readcount, &swjdp->ack);
742 }
743
744 /* Scan in last value */
745 adi_jtag_dp_scan(swjdp, DAP_IR_DPACC, DP_RDBUFF, DPAP_READ, 0, buffer + 4 * readcount, &swjdp->ack);
746 if (swjdp_transaction_endcheck(swjdp) == ERROR_OK)
747 {
748 wcount = wcount - blocksize;
749 address += 4 * blocksize;
750 buffer += 4 * blocksize;
751 }
752 else
753 {
754 errorcount++;
755 }
756
757 if (errorcount > 1)
758 {
759 LOG_WARNING("Block read error address 0x%x, count 0x%x", address, count);
760 return ERROR_JTAG_DEVICE_ERROR;
761 }
762 }
763
764 /* if we have an unaligned access - reorder data */
765 if (adr & 0x3u)
766 {
767 for (readcount = 0; readcount < count; readcount++)
768 {
769 int i;
770 u32 data;
771 memcpy(&data, pBuffer, sizeof(u32));
772
773 for (i = 0; i < 4; i++ )
774 {
775 *((u8*)pBuffer) = (data >> 8 * (adr & 0x3));
776 pBuffer++;
777 adr++;
778 }
779 }
780 }
781
782 return retval;
783 }
784
785 int mem_ap_read_buf_packed_u16(swjdp_common_t *swjdp, u8 *buffer, int count, u32 address)
786 {
787 u32 invalue;
788 int retval = ERROR_OK;
789 int wcount, blocksize, readcount, i;
790
791 swjdp->trans_mode = TRANS_MODE_COMPOSITE;
792
793 wcount = count >> 1;
794
795 while (wcount > 0)
796 {
797 int nbytes;
798
799 /* Adjust to read blocks within boundaries aligned to the TAR autoincremnent size*/
800 blocksize = max_tar_block_size(swjdp->tar_autoincr_block, address);
801 if (wcount < blocksize)
802 blocksize = wcount;
803
804 dap_setup_accessport(swjdp, CSW_16BIT | CSW_ADDRINC_PACKED, address);
805
806 /* handle unaligned data at 4k boundary */
807 if (blocksize == 0)
808 blocksize = 1;
809 readcount = blocksize;
810
811 do
812 {
813 dap_ap_read_reg_u32(swjdp, AP_REG_DRW, &invalue );
814 if (swjdp_transaction_endcheck(swjdp) != ERROR_OK)
815 {
816 LOG_WARNING("Block read error address 0x%x, count 0x%x", address, count);
817 return ERROR_JTAG_DEVICE_ERROR;
818 }
819
820 nbytes = MIN((readcount << 1), 4);
821
822 for (i = 0; i < nbytes; i++ )
823 {
824 *((u8*)buffer) = (invalue >> 8 * (address & 0x3));
825 buffer++;
826 address++;
827 }
828
829 readcount -= (nbytes >> 1);
830 } while (readcount);
831 wcount -= blocksize;
832 }
833
834 return retval;
835 }
836
837 int mem_ap_read_buf_u16(swjdp_common_t *swjdp, u8 *buffer, int count, u32 address)
838 {
839 u32 invalue, i;
840 int retval = ERROR_OK;
841
842 if (count >= 4)
843 return mem_ap_read_buf_packed_u16(swjdp, buffer, count, address);
844
845 swjdp->trans_mode = TRANS_MODE_COMPOSITE;
846
847 while (count > 0)
848 {
849 dap_setup_accessport(swjdp, CSW_16BIT | CSW_ADDRINC_SINGLE, address);
850 dap_ap_read_reg_u32(swjdp, AP_REG_DRW, &invalue );
851 retval = swjdp_transaction_endcheck(swjdp);
852 if (address & 0x1)
853 {
854 for (i = 0; i < 2; i++ )
855 {
856 *((u8*)buffer) = (invalue >> 8 * (address & 0x3));
857 buffer++;
858 address++;
859 }
860 }
861 else
862 {
863 u16 svalue = (invalue >> 8 * (address & 0x3));
864 memcpy(buffer, &svalue, sizeof(u16));
865 address += 2;
866 buffer += 2;
867 }
868 count -= 2;
869 }
870
871 return retval;
872 }
873
874 /* FIX!!! is this a potential performance bottleneck w.r.t. requiring too many
875 * roundtrips when jtag_execute_queue() has a large overhead(e.g. for USB)s?
876 *
877 * The solution is to arrange for a large out/in scan in this loop and
878 * and convert data afterwards.
879 */
880 int mem_ap_read_buf_packed_u8(swjdp_common_t *swjdp, u8 *buffer, int count, u32 address)
881 {
882 u32 invalue;
883 int retval = ERROR_OK;
884 int wcount, blocksize, readcount, i;
885
886 swjdp->trans_mode = TRANS_MODE_COMPOSITE;
887
888 wcount = count;
889
890 while (wcount > 0)
891 {
892 int nbytes;
893
894 /* Adjust to read blocks within boundaries aligned to the TAR autoincremnent size*/
895 blocksize = max_tar_block_size(swjdp->tar_autoincr_block, address);
896
897 if (wcount < blocksize)
898 blocksize = wcount;
899
900 dap_setup_accessport(swjdp, CSW_8BIT | CSW_ADDRINC_PACKED, address);
901 readcount = blocksize;
902
903 do
904 {
905 dap_ap_read_reg_u32(swjdp, AP_REG_DRW, &invalue );
906 if (swjdp_transaction_endcheck(swjdp) != ERROR_OK)
907 {
908 LOG_WARNING("Block read error address 0x%x, count 0x%x", address, count);
909 return ERROR_JTAG_DEVICE_ERROR;
910 }
911
912 nbytes = MIN(readcount, 4);
913
914 for (i = 0; i < nbytes; i++ )
915 {
916 *((u8*)buffer) = (invalue >> 8 * (address & 0x3));
917 buffer++;
918 address++;
919 }
920
921 readcount -= nbytes;
922 } while (readcount);
923 wcount -= blocksize;
924 }
925
926 return retval;
927 }
928
929 int mem_ap_read_buf_u8(swjdp_common_t *swjdp, u8 *buffer, int count, u32 address)
930 {
931 u32 invalue;
932 int retval = ERROR_OK;
933
934 if (count >= 4)
935 return mem_ap_read_buf_packed_u8(swjdp, buffer, count, address);
936
937 swjdp->trans_mode = TRANS_MODE_COMPOSITE;
938
939 while (count > 0)
940 {
941 dap_setup_accessport(swjdp, CSW_8BIT | CSW_ADDRINC_SINGLE, address);
942 dap_ap_read_reg_u32(swjdp, AP_REG_DRW, &invalue );
943 retval = swjdp_transaction_endcheck(swjdp);
944 *((u8*)buffer) = (invalue >> 8 * (address & 0x3));
945 count--;
946 address++;
947 buffer++;
948 }
949
950 return retval;
951 }
952
953 int ahbap_debugport_init(swjdp_common_t *swjdp)
954 {
955 u32 idreg, romaddr, dummy;
956 u32 ctrlstat;
957 int cnt = 0;
958 int retval;
959
960 LOG_DEBUG(" ");
961
962 swjdp->apsel = 0;
963 swjdp->ap_csw_value = -1;
964 swjdp->ap_tar_value = -1;
965 swjdp->trans_mode = TRANS_MODE_ATOMIC;
966 dap_dp_read_reg(swjdp, &dummy, DP_CTRL_STAT);
967 dap_dp_write_reg(swjdp, SSTICKYERR, DP_CTRL_STAT);
968 dap_dp_read_reg(swjdp, &dummy, DP_CTRL_STAT);
969
970 swjdp->dp_ctrl_stat = CDBGPWRUPREQ | CSYSPWRUPREQ;
971
972 dap_dp_write_reg(swjdp, swjdp->dp_ctrl_stat, DP_CTRL_STAT);
973 dap_dp_read_reg(swjdp, &ctrlstat, DP_CTRL_STAT);
974 if ((retval=jtag_execute_queue())!=ERROR_OK)
975 return retval;
976
977 /* Check that we have debug power domains activated */
978 while (!(ctrlstat & CDBGPWRUPACK) && (cnt++ < 10))
979 {
980 LOG_DEBUG("swjdp: wait CDBGPWRUPACK");
981 dap_dp_read_reg(swjdp, &ctrlstat, DP_CTRL_STAT);
982 if ((retval=jtag_execute_queue())!=ERROR_OK)
983 return retval;
984 alive_sleep(10);
985 }
986
987 while (!(ctrlstat & CSYSPWRUPACK) && (cnt++ < 10))
988 {
989 LOG_DEBUG("swjdp: wait CSYSPWRUPACK");
990 dap_dp_read_reg(swjdp, &ctrlstat, DP_CTRL_STAT);
991 if ((retval=jtag_execute_queue())!=ERROR_OK)
992 return retval;
993 alive_sleep(10);
994 }
995
996 dap_dp_read_reg(swjdp, &dummy, DP_CTRL_STAT);
997 /* With debug power on we can activate OVERRUN checking */
998 swjdp->dp_ctrl_stat = CDBGPWRUPREQ | CSYSPWRUPREQ | CORUNDETECT;
999 dap_dp_write_reg(swjdp, swjdp->dp_ctrl_stat, DP_CTRL_STAT);
1000 dap_dp_read_reg(swjdp, &dummy, DP_CTRL_STAT);
1001
1002 dap_ap_read_reg_u32(swjdp, 0xFC, &idreg);
1003 dap_ap_read_reg_u32(swjdp, 0xF8, &romaddr);
1004
1005 LOG_DEBUG("AHB-AP ID Register 0x%x, Debug ROM Address 0x%x", idreg, romaddr);
1006
1007 return ERROR_OK;
1008 }
1009
1010
1011 char * class_description[16] ={
1012 "Reserved",
1013 "ROM table","Reserved","Reserved","Reserved","Reserved","Reserved","Reserved","Reserved",
1014 "CoreSight component","Reserved","Peripheral Test Block","Reserved","DESS","Generic IP component","Non standard layout"};
1015
1016 int dap_info_command(struct command_context_s *cmd_ctx, swjdp_common_t *swjdp, int apsel)
1017 {
1018
1019 u32 dbgbase,apid;
1020 int romtable_present = 0;
1021 u8 mem_ap;
1022 u32 apselold;
1023
1024 apselold = swjdp->apsel;
1025 dap_ap_select(swjdp, apsel);
1026 dap_ap_read_reg_u32(swjdp, 0xF8, &dbgbase);
1027 dap_ap_read_reg_u32(swjdp, 0xFC, &apid);
1028 swjdp_transaction_endcheck(swjdp);
1029 /* Now we read ROM table ID registers, ref. ARM IHI 0029B sec */
1030 mem_ap = ((apid&0x10000)&&((apid&0x0F)!=0));
1031 command_print(cmd_ctx, "ap identification register 0x%8.8x", apid);
1032 if (apid)
1033 {
1034 switch (apid&0x0F)
1035 {
1036 case 0:
1037 command_print(cmd_ctx, "\tType is jtag-ap");
1038 break;
1039 case 1:
1040 command_print(cmd_ctx, "\tType is mem-ap AHB");
1041 break;
1042 case 2:
1043 command_print(cmd_ctx, "\tType is mem-ap APB");
1044 break;
1045 default:
1046 command_print(cmd_ctx, "\tUnknown AP-type");
1047 break;
1048 }
1049 command_print(cmd_ctx, "ap debugbase 0x%8.8x", dbgbase);
1050 }
1051 else
1052 {
1053 command_print(cmd_ctx, "No AP found at this apsel 0x%x", apsel);
1054 }
1055
1056 romtable_present = ((mem_ap)&&(dbgbase != 0xFFFFFFFF));
1057 if (romtable_present)
1058 {
1059 u32 cid0,cid1,cid2,cid3,memtype,romentry;
1060 u16 entry_offset;
1061 /* bit 16 of apid indicates a memory access port */
1062 if (dbgbase&0x02)
1063 {
1064 command_print(cmd_ctx, "\tValid ROM table present");
1065 }
1066 else
1067 {
1068 command_print(cmd_ctx, "\tROM table in legacy format" );
1069 }
1070 /* Now we read ROM table ID registers, ref. ARM IHI 0029B sec */
1071 mem_ap_read_u32(swjdp, (dbgbase&0xFFFFF000)|0xFF0, &cid0);
1072 mem_ap_read_u32(swjdp, (dbgbase&0xFFFFF000)|0xFF4, &cid1);
1073 mem_ap_read_u32(swjdp, (dbgbase&0xFFFFF000)|0xFF8, &cid2);
1074 mem_ap_read_u32(swjdp, (dbgbase&0xFFFFF000)|0xFFC, &cid3);
1075 mem_ap_read_u32(swjdp, (dbgbase&0xFFFFF000)|0xFCC, &memtype);
1076 swjdp_transaction_endcheck(swjdp);
1077 command_print(cmd_ctx, "\tCID3 0x%x, CID2 0x%x, CID1 0x%x, CID0, 0x%x",cid3,cid2,cid1,cid0);
1078 if (memtype&0x01)
1079 {
1080 command_print(cmd_ctx, "\tMEMTYPE system memory present on bus");
1081 }
1082 else
1083 {
1084 command_print(cmd_ctx, "\tMEMTYPE system memory not present. Dedicated debug bus" );
1085 }
1086
1087 /* Now we read ROM table entries from dbgbase&0xFFFFF000)|0x000 until we get 0x00000000 */
1088 entry_offset = 0;
1089 do
1090 {
1091 mem_ap_read_atomic_u32(swjdp, (dbgbase&0xFFFFF000)|entry_offset, &romentry);
1092 command_print(cmd_ctx, "\tROMTABLE[0x%x] = 0x%x",entry_offset,romentry);
1093 if (romentry&0x01)
1094 {
1095 u32 c_cid0,c_cid1,c_cid2,c_cid3,c_pid0,c_pid1,c_pid2,c_pid3,c_pid4,component_start;
1096 u32 component_base = (u32)((dbgbase&0xFFFFF000)+(int)(romentry&0xFFFFF000));
1097 mem_ap_read_atomic_u32(swjdp, (component_base&0xFFFFF000)|0xFE0, &c_pid0);
1098 mem_ap_read_atomic_u32(swjdp, (component_base&0xFFFFF000)|0xFE4, &c_pid1);
1099 mem_ap_read_atomic_u32(swjdp, (component_base&0xFFFFF000)|0xFE8, &c_pid2);
1100 mem_ap_read_atomic_u32(swjdp, (component_base&0xFFFFF000)|0xFEC, &c_pid3);
1101 mem_ap_read_atomic_u32(swjdp, (component_base&0xFFFFF000)|0xFD0, &c_pid4);
1102 mem_ap_read_atomic_u32(swjdp, (component_base&0xFFFFF000)|0xFF0, &c_cid0);
1103 mem_ap_read_atomic_u32(swjdp, (component_base&0xFFFFF000)|0xFF4, &c_cid1);
1104 mem_ap_read_atomic_u32(swjdp, (component_base&0xFFFFF000)|0xFF8, &c_cid2);
1105 mem_ap_read_atomic_u32(swjdp, (component_base&0xFFFFF000)|0xFFC, &c_cid3);
1106 component_start = component_base - 0x1000*(c_pid4>>4);
1107 command_print(cmd_ctx, "\t\tComponent base address 0x%x, pid4 0x%x, start address 0x%x",component_base,c_pid4,component_start);
1108 command_print(cmd_ctx, "\t\tComponent cid1 0x%x, class is %s",c_cid1,class_description[(c_cid1>>4)&0xF]); /* Se ARM DDI 0314 C Table 2.2 */
1109 command_print(cmd_ctx, "\t\tCID3 0x%x, CID2 0x%x, CID1 0x%x, CID0, 0x%x",c_cid3,c_cid2,c_cid1,c_cid0);
1110 command_print(cmd_ctx, "\t\tPID3 0x%x, PID2 0x%x, PID1 0x%x, PID0, 0x%x",c_pid3,c_pid2,c_pid1,c_pid0);
1111 /* For CoreSight components, (c_cid1>>4)&0xF==9 , we also read 0xFC8 DevId and 0xFCC DevType */
1112 }
1113 else
1114 {
1115 if (romentry)
1116 command_print(cmd_ctx, "\t\tComponent not present");
1117 else
1118 command_print(cmd_ctx, "\t\tEnd of ROM table");
1119 }
1120 entry_offset += 4;
1121 } while (romentry>0);
1122 }
1123 else
1124 {
1125 command_print(cmd_ctx, "\tNo ROM table present");
1126 }
1127 dap_ap_select(swjdp, apselold);
1128
1129 return ERROR_OK;
1130 }
1131
Official OpenOCD Mirror