1 /***************************************************************************
2 * Copyright (C) 2009 by Mathias Kuester *
3 * mkdorg@users.sourceforge.net *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
24 #include <helper/jim.h>
27 #include "target_type.h"
30 #include "dsp563xx_once.h"
32 #define DSP563XX_JTAG_INS_LEN 4
34 #define JTAG_STATUS_NORMAL 0x01
35 #define JTAG_STATUS_STOPWAIT 0x05
36 #define JTAG_STATUS_BUSY 0x09
37 #define JTAG_STATUS_DEBUG 0x0d
39 #define JTAG_INSTR_EXTEST 0x00
40 #define JTAG_INSTR_SAMPLE_PRELOAD 0x01
41 #define JTAG_INSTR_IDCODE 0x02
42 #define JTAG_INSTR_CLAMP 0x03
43 #define JTAG_INSTR_HIZ 0x04
44 #define JTAG_INSTR_ENABLE_ONCE 0x06
45 #define JTAG_INSTR_DEBUG_REQUEST 0x07
46 #define JTAG_INSTR_BYPASS 0x0F
48 /* forward declarations */
49 int dsp563xx_target_create(struct target
*target
, Jim_Interp
* interp
);
50 int dsp563xx_init_target(struct command_context
*cmd_ctx
, struct target
*target
);
52 int dsp563xx_arch_state(struct target
*target
);
53 int dsp563xx_poll(struct target
*target
);
54 int dsp563xx_halt(struct target
*target
);
55 int dsp563xx_resume(struct target
*target
, int current
, uint32_t address
,
56 int handle_breakpoints
, int debug_execution
);
57 int dsp563xx_step(struct target
*target
, int current
, uint32_t address
,
58 int handle_breakpoints
);
60 int dsp563xx_assert_reset(struct target
*target
);
61 int dsp563xx_deassert_reset(struct target
*target
);
62 int dsp563xx_soft_reset_halt(struct target
*target
);
64 /* IR and DR functions */
65 int dsp563xx_jtag_sendinstr(struct jtag_tap
*tap
, uint8_t * ir_in
, uint8_t ir_out
);
66 int dsp563xx_jtag_senddat(struct jtag_tap
*tap
, uint32_t * dr_in
, uint32_t dr_out
,
69 int dsp563xx_read_memory_p(struct target
*target
, uint32_t address
, uint32_t size
,
70 uint32_t count
, uint8_t * buffer
);
71 int dsp563xx_write_memory_p(struct target
*target
, uint32_t address
, uint32_t size
,
72 uint32_t count
, uint8_t * buffer
);
74 #define ASM_REG_R_R0 0x607000
75 #define ASM_REG_R_R1 0x617000
76 #define ASM_REG_R_R2 0x627000
77 #define ASM_REG_R_R3 0x637000
78 #define ASM_REG_R_R4 0x647000
79 #define ASM_REG_R_R5 0x657000
80 #define ASM_REG_R_R6 0x667000
81 #define ASM_REG_R_R7 0x677000
83 #define ASM_REG_W_R0 0x60F400
84 #define ASM_REG_W_R1 0x61F400
85 #define ASM_REG_W_R2 0x62F400
86 #define ASM_REG_W_R3 0x63F400
87 #define ASM_REG_W_R4 0x64F400
88 #define ASM_REG_W_R5 0x65F400
89 #define ASM_REG_W_R6 0x66F400
90 #define ASM_REG_W_R7 0x67F400
92 #define ASM_REG_R_N0 0x707000
93 #define ASM_REG_R_N1 0x717000
94 #define ASM_REG_R_N2 0x727000
95 #define ASM_REG_R_N3 0x737000
96 #define ASM_REG_R_N4 0x747000
97 #define ASM_REG_R_N5 0x757000
98 #define ASM_REG_R_N6 0x767000
99 #define ASM_REG_R_N7 0x777000
101 #define ASM_REG_W_N0 0x70F400
102 #define ASM_REG_W_N1 0x71F400
103 #define ASM_REG_W_N2 0x72F400
104 #define ASM_REG_W_N3 0x73F400
105 #define ASM_REG_W_N4 0x74F400
106 #define ASM_REG_W_N5 0x75F400
107 #define ASM_REG_W_N6 0x76F400
108 #define ASM_REG_W_N7 0x77F400
110 #define ASM_REG_R_M0 0x057020 /* control register m[0..7] */
111 #define ASM_REG_R_M1 0x057021
112 #define ASM_REG_R_M2 0x057022
113 #define ASM_REG_R_M3 0x057023
114 #define ASM_REG_R_M4 0x057024
115 #define ASM_REG_R_M5 0x057025
116 #define ASM_REG_R_M6 0x057026
117 #define ASM_REG_R_M7 0x057027
119 #define ASM_REG_W_M0 0x05F420
120 #define ASM_REG_W_M1 0x05F421
121 #define ASM_REG_W_M2 0x05F422
122 #define ASM_REG_W_M3 0x05F423
123 #define ASM_REG_W_M4 0x05F424
124 #define ASM_REG_W_M5 0x05F425
125 #define ASM_REG_W_M6 0x05F426
126 #define ASM_REG_W_M7 0x05F427
128 #define ASM_REG_R_X0 0x447000
129 #define ASM_REG_R_X1 0x457000
131 #define ASM_REG_W_X0 0x44F400
132 #define ASM_REG_W_X1 0x45F400
134 #define ASM_REG_R_Y0 0x467000
135 #define ASM_REG_R_Y1 0x477000
137 #define ASM_REG_W_Y0 0x46F400
138 #define ASM_REG_W_Y1 0x47F400
140 #define ASM_REG_R_A0 0x507000
141 #define ASM_REG_R_A1 0x547000
142 #define ASM_REG_R_A2 0x527000
144 #define ASM_REG_W_A0 0x50F400
145 #define ASM_REG_W_A1 0x54F400
146 #define ASM_REG_W_A2 0x52F400
148 #define ASM_REG_R_B0 0x517000
149 #define ASM_REG_R_B1 0x557000
150 #define ASM_REG_R_B2 0x537000
152 #define ASM_REG_W_B0 0x51F400
153 #define ASM_REG_W_B1 0x55F400
154 #define ASM_REG_W_B2 0x53F400
156 #define ASM_REG_R_VBA 0x057030 /* control register */
157 #define ASM_REG_W_VBA 0x05F430
159 #define ASM_REG_R_OMR 0x05703A /* control register */
160 #define ASM_REG_W_OMR 0x05F43A
162 #define ASM_REG_R_EP 0x05702A
163 #define ASM_REG_W_EP 0x05F42A
165 #define ASM_REG_R_SC 0x057031 /* stack counter */
166 #define ASM_REG_W_SC 0x05F431
168 #define ASM_REG_R_SZ 0x057038 /* stack size */
169 #define ASM_REG_W_SZ 0x05F438
171 #define ASM_REG_R_SR 0x057039 /* control register, status register */
172 #define ASM_REG_W_SR 0x05F439
174 #define ASM_REG_R_SP 0x05703B /* control register, stack pointer */
175 #define ASM_REG_W_SP 0x05F43B
177 #define ASM_REG_R_SSH 0x05703C /* control register, system stack high */
178 #define ASM_REG_W_SSH 0x05743C
180 #define ASM_REG_R_SSL 0x05703D /* control register, system stack low */
181 #define ASM_REG_W_SSL 0x05F43D
183 #define ASM_REG_R_LA 0x05703E /* control register, loop address */
184 #define ASM_REG_W_LA 0x05F43E
186 #define ASM_REG_R_LC 0x05703F /* control register, loop count */
187 #define ASM_REG_W_LC 0x05F43F
189 #define ASM_REG_R_PC 0x000000
190 #define ASM_REG_W_PC 0x000000
202 {0, "r0", 24, ASM_REG_R_R0
, ASM_REG_W_R0
},
203 {1, "r1", 24, ASM_REG_R_R1
, ASM_REG_W_R1
},
204 {2, "r2", 24, ASM_REG_R_R2
, ASM_REG_W_R2
},
205 {3, "r3", 24, ASM_REG_R_R3
, ASM_REG_W_R3
},
206 {4, "r4", 24, ASM_REG_R_R4
, ASM_REG_W_R4
},
207 {5, "r5", 24, ASM_REG_R_R5
, ASM_REG_W_R5
},
208 {6, "r6", 24, ASM_REG_R_R6
, ASM_REG_W_R6
},
209 {7, "r7", 24, ASM_REG_R_R7
, ASM_REG_W_R7
},
210 {8, "n0", 24, ASM_REG_R_N0
, ASM_REG_W_N0
},
211 {9, "n1", 24, ASM_REG_R_N1
, ASM_REG_W_N1
},
212 {10, "n2", 24, ASM_REG_R_N2
, ASM_REG_W_N2
},
213 {11, "n3", 24, ASM_REG_R_N3
, ASM_REG_W_N3
},
214 {12, "n4", 24, ASM_REG_R_N4
, ASM_REG_W_N4
},
215 {13, "n5", 24, ASM_REG_R_N5
, ASM_REG_W_N5
},
216 {14, "n6", 24, ASM_REG_R_N6
, ASM_REG_W_N6
},
217 {15, "n7", 24, ASM_REG_R_N7
, ASM_REG_W_N7
},
218 {16, "m0", 24, ASM_REG_R_M0
, ASM_REG_W_M0
},
219 {17, "m1", 24, ASM_REG_R_M1
, ASM_REG_W_M1
},
220 {18, "m2", 24, ASM_REG_R_M2
, ASM_REG_W_M2
},
221 {19, "m3", 24, ASM_REG_R_M3
, ASM_REG_W_M3
},
222 {20, "m4", 24, ASM_REG_R_M4
, ASM_REG_W_M4
},
223 {21, "m5", 24, ASM_REG_R_M5
, ASM_REG_W_M5
},
224 {22, "m6", 24, ASM_REG_R_M6
, ASM_REG_W_M6
},
225 {23, "m7", 24, ASM_REG_R_M7
, ASM_REG_W_M7
},
226 {24, "x0", 24, ASM_REG_R_X0
, ASM_REG_W_X0
},
227 {25, "x1", 24, ASM_REG_R_X1
, ASM_REG_W_X1
},
228 {26, "y0", 24, ASM_REG_R_Y0
, ASM_REG_W_Y0
},
229 {27, "y1", 24, ASM_REG_R_Y1
, ASM_REG_W_Y1
},
230 {28, "a0", 24, ASM_REG_R_A0
, ASM_REG_W_A0
},
231 {29, "a1", 24, ASM_REG_R_A1
, ASM_REG_W_A1
},
232 {30, "a2", 8, ASM_REG_R_A2
, ASM_REG_W_A2
},
233 {31, "b0", 24, ASM_REG_R_B0
, ASM_REG_W_B0
},
234 {32, "b1", 24, ASM_REG_R_B1
, ASM_REG_W_B1
},
235 {33, "b2", 8, ASM_REG_R_B2
, ASM_REG_W_B2
},
236 {34, "omr", 24, ASM_REG_R_OMR
, ASM_REG_W_OMR
},
237 {35, "vba", 24, ASM_REG_R_VBA
, ASM_REG_W_VBA
},
238 {36, "ep", 24, ASM_REG_R_EP
, ASM_REG_W_EP
},
239 {37, "sc", 24, ASM_REG_R_SC
, ASM_REG_W_SC
},
240 {38, "sz", 24, ASM_REG_R_SZ
, ASM_REG_W_SZ
},
241 {39, "sr", 24, ASM_REG_R_SR
, ASM_REG_W_SR
},
242 {40, "sp", 24, ASM_REG_R_SP
, ASM_REG_W_SP
},
243 {41, "la", 24, ASM_REG_R_LA
, ASM_REG_W_LA
},
244 {42, "lc", 24, ASM_REG_R_LC
, ASM_REG_W_LC
},
245 {43, "pc", 24, ASM_REG_R_PC
, ASM_REG_W_PC
}
249 int dsp563xx_read_core_reg(struct target
*target
, int num
)
252 struct dsp563xx_core_reg
*dsp563xx_core_reg
;
253 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
255 if ((num
< 0) || (num
>= DSP563XX_NUMCOREREGS
))
256 return ERROR_INVALID_ARGUMENTS
;
258 dsp563xx_core_reg
= dsp563xx
->core_cache
->reg_list
[num
].arch_info
;
259 reg_value
= dsp563xx
->core_regs
[num
];
260 buf_set_u32(dsp563xx
->core_cache
->reg_list
[num
].value
, 0, 32, reg_value
);
261 dsp563xx
->core_cache
->reg_list
[num
].valid
= 1;
262 dsp563xx
->core_cache
->reg_list
[num
].dirty
= 0;
267 int dsp563xx_write_core_reg(struct target
*target
, int num
)
270 struct dsp563xx_core_reg
*dsp563xx_core_reg
;
271 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
273 if ((num
< 0) || (num
>= DSP563XX_NUMCOREREGS
))
274 return ERROR_INVALID_ARGUMENTS
;
276 reg_value
= buf_get_u32(dsp563xx
->core_cache
->reg_list
[num
].value
, 0, 32);
277 dsp563xx_core_reg
= dsp563xx
->core_cache
->reg_list
[num
].arch_info
;
278 dsp563xx
->core_regs
[num
] = reg_value
;
279 dsp563xx
->core_cache
->reg_list
[num
].valid
= 1;
280 dsp563xx
->core_cache
->reg_list
[num
].dirty
= 0;
285 int dsp563xx_target_create(struct target
*target
, Jim_Interp
* interp
)
287 struct dsp563xx_common
*dsp563xx
= calloc(1, sizeof(struct dsp563xx_common
));
289 dsp563xx
->jtag_info
.tap
= target
->tap
;
290 target
->arch_info
= dsp563xx
;
291 dsp563xx
->read_core_reg
= dsp563xx_read_core_reg
;
292 dsp563xx
->write_core_reg
= dsp563xx_write_core_reg
;
297 int dsp563xx_get_core_reg(struct reg
*reg
)
301 LOG_DEBUG("%s", __FUNCTION__
);
303 struct dsp563xx_core_reg
*dsp563xx_reg
= reg
->arch_info
;
304 struct target
*target
= dsp563xx_reg
->target
;
305 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
307 if (target
->state
!= TARGET_HALTED
)
309 return ERROR_TARGET_NOT_HALTED
;
312 retval
= dsp563xx
->read_core_reg(target
, dsp563xx_reg
->num
);
317 int dsp563xx_set_core_reg(struct reg
*reg
, uint8_t * buf
)
319 LOG_DEBUG("%s", __FUNCTION__
);
321 struct dsp563xx_core_reg
*dsp563xx_reg
= reg
->arch_info
;
322 struct target
*target
= dsp563xx_reg
->target
;
323 uint32_t value
= buf_get_u32(buf
, 0, 32);
325 if (target
->state
!= TARGET_HALTED
)
327 return ERROR_TARGET_NOT_HALTED
;
330 buf_set_u32(reg
->value
, 0, reg
->size
, value
);
337 int dsp563xx_save_context(struct target
*target
)
341 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
342 struct dsp563xx_core_reg
*arch_info
;
344 for (i
= 0; i
< DSP563XX_NUMCOREREGS
- 1; i
++)
347 // if (!dsp563xx->core_cache->reg_list[i].valid)
349 arch_info
= dsp563xx
->core_cache
->reg_list
[i
].arch_info
;
350 dsp563xx_once_execute_dw_ir(target
->tap
, arch_info
->r_cmd
,
352 dsp563xx_once_execute_sw_ir(target
->tap
, 0x000000);
353 dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OGDBR
,
355 dsp563xx
->core_regs
[i
] = data
;
356 dsp563xx
->read_core_reg(target
, i
);
361 dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPABEX
, &data
);
362 dsp563xx
->core_regs
[i
] = data
;
363 dsp563xx
->read_core_reg(target
, i
);
368 int dsp563xx_restore_context(struct target
*target
)
371 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
372 struct dsp563xx_core_reg
*arch_info
;
374 for (i
= 0; i
< DSP563XX_NUMCOREREGS
- 1; i
++)
376 if (dsp563xx
->core_cache
->reg_list
[i
].dirty
)
378 arch_info
= dsp563xx
->core_cache
->reg_list
[i
].arch_info
;
380 dsp563xx
->write_core_reg(target
, i
);
382 dsp563xx_once_execute_dw_ir(target
->tap
, arch_info
->w_cmd
,
383 dsp563xx
->core_regs
[i
]);
384 dsp563xx_once_execute_sw_ir(target
->tap
, 0x000000);
391 static const struct reg_arch_type dsp563xx_reg_type
= {
392 .get
= dsp563xx_get_core_reg
,
393 .set
= dsp563xx_set_core_reg
,
396 int dsp563xx_init_target(struct command_context
*cmd_ctx
, struct target
*target
)
398 /* get pointers to arch-specific information */
399 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
401 struct reg_cache
**cache_p
= register_get_last_cache_p(&target
->reg_cache
);
402 struct reg_cache
*cache
= malloc(sizeof(struct reg_cache
));
403 struct reg
*reg_list
= malloc(sizeof(struct reg
) * DSP563XX_NUMCOREREGS
);
404 struct dsp563xx_core_reg
*arch_info
=
405 malloc(sizeof(struct dsp563xx_core_reg
) * DSP563XX_NUMCOREREGS
);
408 LOG_DEBUG("%s", __FUNCTION__
);
410 /* Build the process context cache */
411 cache
->name
= "dsp563xx registers";
413 cache
->reg_list
= reg_list
;
414 cache
->num_regs
= DSP563XX_NUMCOREREGS
;
416 dsp563xx
->core_cache
= cache
;
418 for (i
= 0; i
< DSP563XX_NUMCOREREGS
; i
++)
420 arch_info
[i
].num
= dsp563xx_regs
[i
].id
;
421 arch_info
[i
].name
= dsp563xx_regs
[i
].name
;
422 arch_info
[i
].size
= dsp563xx_regs
[i
].bits
;
423 arch_info
[i
].r_cmd
= dsp563xx_regs
[i
].r_cmd
;
424 arch_info
[i
].w_cmd
= dsp563xx_regs
[i
].w_cmd
;
425 arch_info
[i
].target
= target
;
426 arch_info
[i
].dsp563xx_common
= dsp563xx
;
427 reg_list
[i
].name
= dsp563xx_regs
[i
].name
;
428 reg_list
[i
].size
= dsp563xx_regs
[i
].bits
;
429 reg_list
[i
].value
= calloc(1, 4);
430 reg_list
[i
].dirty
= 0;
431 reg_list
[i
].valid
= 0;
432 reg_list
[i
].type
= &dsp563xx_reg_type
;
433 reg_list
[i
].arch_info
= &arch_info
[i
];
439 int dsp563xx_arch_state(struct target
*target
)
441 LOG_DEBUG("%s", __FUNCTION__
);
445 int dsp563xx_jtag_status(struct target
*target
, uint8_t * status
)
451 dsp563xx_jtag_sendinstr(target
->tap
, &ir_in
, JTAG_INSTR_ENABLE_ONCE
);
452 dsp563xx_execute_queue();
459 int dsp563xx_jtag_debug_request(struct target
*target
)
464 while (ir_in
!= JTAG_STATUS_DEBUG
)
466 dsp563xx_jtag_sendinstr(target
->tap
, &ir_in
,
467 JTAG_INSTR_DEBUG_REQUEST
);
468 dsp563xx_execute_queue();
469 LOG_DEBUG("JTAG CMD 7 res: %02X", ir_in
);
470 dsp563xx_jtag_sendinstr(target
->tap
, &ir_in
, JTAG_INSTR_ENABLE_ONCE
);
471 dsp563xx_execute_queue();
472 LOG_DEBUG("JTAG CMD 6 res: %02X", ir_in
);
475 return ERROR_TARGET_FAILURE
;
478 if (ir_in
!= JTAG_STATUS_DEBUG
)
480 return ERROR_TARGET_FAILURE
;
486 int dsp563xx_poll(struct target
*target
)
489 uint32_t once_status
;
491 dsp563xx_jtag_status(target
, &jtag_status
);
493 if ((jtag_status
& 1) != 1)
495 target
->state
= TARGET_UNKNOWN
;
497 ("jtag status contains invalid mode value - communication failure");
498 return ERROR_TARGET_FAILURE
;
501 if (jtag_status
!= JTAG_STATUS_DEBUG
)
503 target
->state
= TARGET_RUNNING
;
506 dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OSCR
, &once_status
);
508 if ((once_status
& DSP563XX_ONCE_OSCR_DEBUG_M
) == DSP563XX_ONCE_OSCR_DEBUG_M
)
510 target
->state
= TARGET_HALTED
;
517 int dsp563xx_halt(struct target
*target
)
520 uint32_t once_status
;
521 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
523 if (target
->state
== TARGET_HALTED
)
525 LOG_DEBUG("target was already halted");
529 if (target
->state
== TARGET_UNKNOWN
)
531 LOG_WARNING("target was in unknown state when halt was requested");
534 // if ( jtag_status != 0x0d )
536 dsp563xx_jtag_debug_request(target
);
538 /* store pipeline register */
539 dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPILR
,
540 &dsp563xx
->pipeline_context
.once_opilr
);
541 dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPDBR
,
542 &dsp563xx
->pipeline_context
.once_opdbr
);
544 dsp563xx_save_context(target
);
546 dsp563xx_jtag_status(target
, &jtag_status
);
547 LOG_DEBUG("%02X", jtag_status
);
548 dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OSCR
,
550 LOG_DEBUG("%02X", (unsigned) once_status
);
553 LOG_DEBUG("target->state: %s", target_state_name(target
));
555 LOG_DEBUG("%s", __FUNCTION__
);
560 #define DSP563XX_ASM_CMD_JUMP 0x0AF080
562 int dsp563xx_resume(struct target
*target
, int current
, uint32_t address
,
563 int handle_breakpoints
, int debug_execution
)
565 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
567 LOG_DEBUG("%s", __FUNCTION__
);
569 dsp563xx_restore_context(target
);
573 /* restore pipeline registers and go */
574 dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OPILR
,
575 dsp563xx
->pipeline_context
.once_opilr
);
576 dsp563xx_once_reg_write(target
->tap
,
577 DSP563XX_ONCE_OPDBR
| DSP563XX_ONCE_OCR_EX
|
578 DSP563XX_ONCE_OCR_GO
,
579 dsp563xx
->pipeline_context
.once_opdbr
);
583 /* set to go register and jump */
584 dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OPDBR
,
585 DSP563XX_ASM_CMD_JUMP
);
586 dsp563xx_once_reg_write(target
->tap
,
587 DSP563XX_ONCE_PDBGOTO
| DSP563XX_ONCE_OCR_EX
588 | DSP563XX_ONCE_OCR_GO
, address
);
591 target
->state
= TARGET_RUNNING
;
596 int dsp563xx_step(struct target
*target
, int current
, uint32_t address
,
597 int handle_breakpoints
)
599 uint32_t once_status
;
601 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
603 if (target
->state
!= TARGET_HALTED
)
605 LOG_DEBUG("target was not halted");
609 LOG_DEBUG("%s %08X %08X", __FUNCTION__
, current
, (unsigned) address
);
611 dsp563xx_jtag_debug_request(target
);
613 dsp563xx_restore_context(target
);
615 /* reset trace mode */
616 dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OSCR
, 0x000000);
617 /* enable trace mode */
618 dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OSCR
,
619 DSP563XX_ONCE_OSCR_TME
);
623 /* on JUMP we need one extra cycle */
627 /* load step counter with N-1 */
628 dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OTC
, cnt
);
632 /* restore pipeline registers and go */
633 dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OPILR
,
634 dsp563xx
->pipeline_context
.once_opilr
);
635 dsp563xx_once_reg_write(target
->tap
,
636 DSP563XX_ONCE_OPDBR
| DSP563XX_ONCE_OCR_EX
|
637 DSP563XX_ONCE_OCR_GO
,
638 dsp563xx
->pipeline_context
.once_opdbr
);
642 /* set to go register and jump */
643 dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OPDBR
,
644 DSP563XX_ASM_CMD_JUMP
);
645 dsp563xx_once_reg_write(target
->tap
,
646 DSP563XX_ONCE_PDBGOTO
| DSP563XX_ONCE_OCR_EX
647 | DSP563XX_ONCE_OCR_GO
, address
);
652 dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OSCR
,
655 if (once_status
& DSP563XX_ONCE_OSCR_TO
)
657 /* store pipeline register */
658 dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPILR
,
659 &dsp563xx
->pipeline_context
.
661 dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPDBR
,
662 &dsp563xx
->pipeline_context
.
665 dsp563xx_save_context(target
);
667 dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPABFR
,
669 LOG_DEBUG("%08X", (unsigned) dr_in
);
670 dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPABDR
,
672 LOG_DEBUG("%08X", (unsigned) dr_in
);
673 dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPABEX
,
675 LOG_DEBUG("%08X", (unsigned) dr_in
);
677 /* reset trace mode */
678 dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OSCR
,
688 int dsp563xx_assert_reset(struct target
*target
)
690 target
->state
= TARGET_RESET
;
692 LOG_DEBUG("%s", __FUNCTION__
);
696 int dsp563xx_deassert_reset(struct target
*target
)
698 target
->state
= TARGET_RUNNING
;
700 LOG_DEBUG("%s", __FUNCTION__
);
704 int dsp563xx_soft_reset_halt(struct target
*target
)
706 LOG_DEBUG("%s", __FUNCTION__
);
712 * 46F400 AABBCC move #$aabbcc,y0
713 * 60F400 AABBCC move #$aabbcc,r0
714 * 467000 AABBCC move y0,x:AABBCC
715 * 607000 AABBCC move r0,x:AABBCC
717 * 46E000 move x:(r0),y0
718 * 4EE000 move y:(r0),y0
719 * 07E086 move p:(r0),y0
728 * 61F000 AABBCC move x:AABBCC,r1
729 * 076190 movem r0,p:(r1)
732 int dsp563xx_read_memory_p(struct target
*target
, uint32_t address
,
733 uint32_t size
, uint32_t count
, uint8_t * buffer
)
739 LOG_DEBUG("address: 0x%8.8" PRIx32
", size: 0x%8.8" PRIx32
", count: 0x%8.8"
740 PRIx32
, address
, size
, count
);
742 if (target
->state
!= TARGET_HALTED
)
744 LOG_WARNING("target not halted");
745 return ERROR_TARGET_NOT_HALTED
;
750 for (i
= 0; i
< x
; i
++)
752 dsp563xx_once_execute_dw_ir_nq(target
->tap
, 0x60F400, address
+ i
);
753 dsp563xx_once_execute_sw_ir_nq(target
->tap
, 0x07E086);
754 dsp563xx_once_execute_dw_ir_nq(target
->tap
, 0x467000, 0xfffffc);
755 dsp563xx_execute_queue();
757 dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OGDBR
, &data
);
773 int dsp563xx_write_memory_p(struct target
*target
, uint32_t address
, uint32_t size
,
774 uint32_t count
, uint8_t * buffer
)
780 LOG_DEBUG("address: 0x%8.8" PRIx32
", size: 0x%8.8" PRIx32
", count: 0x%8.8"
781 PRIx32
"", address
, size
, count
);
783 if (target
->state
!= TARGET_HALTED
)
785 LOG_WARNING("target not halted");
786 return ERROR_TARGET_NOT_HALTED
;
791 for (i
= 0; i
< x
; i
++)
799 data
|= (*buffer
++) << 8;
801 data
|= (*buffer
++) << 16;
803 data
|= (*buffer
++) << 24;
805 // LOG_DEBUG("%08X", data);
807 dsp563xx_once_execute_dw_ir_nq(target
->tap
, 0x61F400, address
+ i
);
808 dsp563xx_once_execute_dw_ir_nq(target
->tap
, 0x60F400, data
);
809 dsp563xx_once_execute_sw_ir_nq(target
->tap
, 0x076190);
810 dsp563xx_execute_queue();
816 int dsp563xx_jtag_senddat(struct jtag_tap
*tap
, uint32_t * dr_in
, uint32_t dr_out
,
819 return dsp563xx_write_dr_u32(tap
, dr_in
, dr_out
, len
, 1);
822 int dsp563xx_jtag_sendinstr(struct jtag_tap
*tap
, uint8_t * ir_in
, uint8_t ir_out
)
824 return dsp563xx_write_ir_u8(tap
, ir_in
, ir_out
, DSP563XX_JTAG_INS_LEN
, 1);
827 /* IR and DR functions */
828 int dsp563xx_write_ir(struct jtag_tap
*tap
, uint8_t * ir_in
, uint8_t * ir_out
,
833 LOG_ERROR("invalid tap");
836 if (ir_len
!= tap
->ir_length
)
838 LOG_ERROR("invalid ir_len");
843 struct scan_field field
[1];
846 field
[0].num_bits
= tap
->ir_length
;
847 field
[0].out_value
= ir_out
;
848 field
[0].in_value
= ir_in
;
849 jtag_add_plain_ir_scan(ARRAY_SIZE(field
), field
,
850 jtag_set_end_state(TAP_IDLE
));
856 int dsp563xx_write_dr(struct jtag_tap
*tap
, uint8_t * dr_in
, uint8_t * dr_out
,
861 LOG_ERROR("invalid tap");
866 struct scan_field field
[1];
869 field
[0].num_bits
= dr_len
;
870 field
[0].out_value
= dr_out
;
871 field
[0].in_value
= dr_in
;
872 jtag_add_plain_dr_scan(ARRAY_SIZE(field
), field
,
873 jtag_set_end_state(TAP_IDLE
));
879 int dsp563xx_write_ir_u8(struct jtag_tap
*tap
, uint8_t * ir_in
, uint8_t ir_out
,
884 LOG_ERROR("ir_len overflow, maxium is 8");
888 dsp563xx_write_ir(tap
, ir_in
, &ir_out
, ir_len
, rti
);
893 int dsp563xx_write_dr_u8(struct jtag_tap
*tap
, uint8_t * dr_in
, uint8_t dr_out
,
898 LOG_ERROR("dr_len overflow, maxium is 8");
902 dsp563xx_write_dr(tap
, dr_in
, &dr_out
, dr_len
, rti
);
907 int dsp563xx_write_ir_u16(struct jtag_tap
*tap
, uint16_t * ir_in
, uint16_t ir_out
,
912 LOG_ERROR("ir_len overflow, maxium is 16");
916 dsp563xx_write_ir(tap
, (uint8_t *) ir_in
, (uint8_t *) & ir_out
, ir_len
, rti
);
921 int dsp563xx_write_dr_u16(struct jtag_tap
*tap
, uint16_t * dr_in
, uint16_t dr_out
,
926 LOG_ERROR("dr_len overflow, maxium is 16");
930 dsp563xx_write_dr(tap
, (uint8_t *) dr_in
, (uint8_t *) & dr_out
, dr_len
, rti
);
935 int dsp563xx_write_ir_u32(struct jtag_tap
*tap
, uint32_t * ir_in
, uint32_t ir_out
,
940 LOG_ERROR("ir_len overflow, maxium is 32");
944 dsp563xx_write_ir(tap
, (uint8_t *) ir_in
, (uint8_t *) & ir_out
, ir_len
, rti
);
949 int dsp563xx_write_dr_u32(struct jtag_tap
*tap
, uint32_t * dr_in
, uint32_t dr_out
,
954 LOG_ERROR("dr_len overflow, maxium is 32");
958 dsp563xx_write_dr(tap
, (uint8_t *) dr_in
, (uint8_t *) & dr_out
, dr_len
, rti
);
963 int dsp563xx_execute_queue(void)
965 return jtag_execute_queue();
968 /** Holds methods for DSP563XX targets. */
969 struct target_type dsp563xx_target
= {
972 .poll
= dsp563xx_poll
,
973 .arch_state
= dsp563xx_arch_state
,
975 .target_request_data
= NULL
,
977 .halt
= dsp563xx_halt
,
978 .resume
= dsp563xx_resume
,
979 .step
= dsp563xx_step
,
981 .assert_reset
= dsp563xx_assert_reset
,
982 .deassert_reset
= dsp563xx_deassert_reset
,
983 .soft_reset_halt
= dsp563xx_soft_reset_halt
,
985 .read_memory
= dsp563xx_read_memory_p
,
986 .write_memory
= dsp563xx_write_memory_p
,
988 .target_create
= dsp563xx_target_create
,
989 .init_target
= dsp563xx_init_target
,
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)