1 /***************************************************************************
2 * Copyright (C) 2009-2011 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 ***************************************************************************/
27 #include "target_type.h"
30 #include "dsp563xx_once.h"
32 //#define DSP563XX_JTAG_INS_LEN 4
34 #define ASM_REG_W_R0 0x60F400
35 #define ASM_REG_W_R1 0x61F400
36 #define ASM_REG_W_R2 0x62F400
37 #define ASM_REG_W_R3 0x63F400
38 #define ASM_REG_W_R4 0x64F400
39 #define ASM_REG_W_R5 0x65F400
40 #define ASM_REG_W_R6 0x66F400
41 #define ASM_REG_W_R7 0x67F400
43 #define ASM_REG_W_N0 0x70F400
44 #define ASM_REG_W_N1 0x71F400
45 #define ASM_REG_W_N2 0x72F400
46 #define ASM_REG_W_N3 0x73F400
47 #define ASM_REG_W_N4 0x74F400
48 #define ASM_REG_W_N5 0x75F400
49 #define ASM_REG_W_N6 0x76F400
50 #define ASM_REG_W_N7 0x77F400
52 #define ASM_REG_W_M0 0x05F420
53 #define ASM_REG_W_M1 0x05F421
54 #define ASM_REG_W_M2 0x05F422
55 #define ASM_REG_W_M3 0x05F423
56 #define ASM_REG_W_M4 0x05F424
57 #define ASM_REG_W_M5 0x05F425
58 #define ASM_REG_W_M6 0x05F426
59 #define ASM_REG_W_M7 0x05F427
61 #define ASM_REG_W_X0 0x44F400
62 #define ASM_REG_W_X1 0x45F400
64 #define ASM_REG_W_Y0 0x46F400
65 #define ASM_REG_W_Y1 0x47F400
67 #define ASM_REG_W_A0 0x50F400
68 #define ASM_REG_W_A1 0x54F400
69 #define ASM_REG_W_A2 0x52F400
71 #define ASM_REG_W_B0 0x51F400
72 #define ASM_REG_W_B1 0x55F400
73 #define ASM_REG_W_B2 0x53F400
75 #define ASM_REG_W_VBA 0x05F430
76 #define ASM_REG_W_OMR 0x05F43A
77 #define ASM_REG_W_EP 0x05F42A
78 #define ASM_REG_W_SC 0x05F431
79 #define ASM_REG_W_SZ 0x05F438
80 #define ASM_REG_W_SR 0x05F439
81 #define ASM_REG_W_SP 0x05F43B
82 #define ASM_REG_W_SSH 0x05F43C
83 #define ASM_REG_W_SSL 0x05F43D
84 #define ASM_REG_W_LA 0x05F43E
85 #define ASM_REG_W_LC 0x05F43F
86 #define ASM_REG_W_PC 0x000000
87 #define ASM_REG_W_IPRC 0xFFFFFF
88 #define ASM_REG_W_IPRP 0xFFFFFE
90 #define ASM_REG_W_BCR 0xFFFFFB
91 #define ASM_REG_W_DCR 0xFFFFFA
92 #define ASM_REG_W_AAR0 0xFFFFF9
93 #define ASM_REG_W_AAR1 0xFFFFF8
94 #define ASM_REG_W_AAR2 0xFFFFF7
95 #define ASM_REG_W_AAR3 0xFFFFF6
97 static struct once_reg once_regs
[] = {
98 {0, 0x00, 24, "OSCR", 0},
99 {1, 0x01, 24, "OMBC", 0},
100 {2, 0x02, 24, "OBCR", 0},
101 {3, 0x05, 24, "OMLR0", 0},
102 {4, 0x06, 24, "OMLR1", 0},
103 {5, 0x09, 24, "OGDBR", 0},
104 {6, 0x0a, 24, "OPDBR", 0},
105 {7, 0x0b, 24, "OPILR", 0},
106 {8, 0x0c, 24, "PDB", 0},
107 {9, 0x0d, 24, "OTC", 0},
108 {10, 0x0f, 24, "OPABFR", 0},
109 {11, 0x10, 24, "OPABDR", 0},
110 {12, 0x11, 24, "OPABEX", 0},
111 {13, 0x12, 25, "OPABF0", 0},
112 {14, 0x12, 25, "OPABF1", 0},
113 {15, 0x12, 25, "OPABF2", 0},
114 {16, 0x12, 25, "OPABF3", 0},
115 {17, 0x12, 25, "OPABF4", 0},
116 {18, 0x12, 25, "OPABF5", 0},
117 {19, 0x12, 25, "OPABF6", 0},
118 {20, 0x12, 25, "OPABF7", 0},
119 {21, 0x12, 25, "OPABF8", 0},
120 {22, 0x12, 25, "OPABF9", 0},
121 {23, 0x12, 25, "OPABF10", 0},
122 {24, 0x12, 25, "OPABF11", 0},
123 // {25,0x1f,24,"NRSEL",0},
131 /* effective addressing mode encoding */
137 /* address registers */
138 { 0, "r0", 24, 0x10, ASM_REG_W_R0
},
139 { 1, "r1", 24, 0x11, ASM_REG_W_R1
},
140 { 2, "r2", 24, 0x12, ASM_REG_W_R2
},
141 { 3, "r3", 24, 0x13, ASM_REG_W_R3
},
142 { 4, "r4", 24, 0x14, ASM_REG_W_R4
},
143 { 5, "r5", 24, 0x15, ASM_REG_W_R5
},
144 { 6, "r6", 24, 0x16, ASM_REG_W_R6
},
145 { 7, "r7", 24, 0x17, ASM_REG_W_R7
},
146 /* offset registers */
147 { 8, "n0", 24, 0x18, ASM_REG_W_N0
},
148 { 9, "n1", 24, 0x19, ASM_REG_W_N1
},
149 {10, "n2", 24, 0x1a, ASM_REG_W_N2
},
150 {11, "n3", 24, 0x1b, ASM_REG_W_N3
},
151 {12, "n4", 24, 0x1c, ASM_REG_W_N4
},
152 {13, "n5", 24, 0x1d, ASM_REG_W_N5
},
153 {14, "n6", 24, 0x1e, ASM_REG_W_N6
},
154 {15, "n7", 24, 0x1f, ASM_REG_W_N7
},
155 /* modifier registers */
156 {16, "m0", 24, 0x20, ASM_REG_W_M0
},
157 {17, "m1", 24, 0x21, ASM_REG_W_M1
},
158 {18, "m2", 24, 0x22, ASM_REG_W_M2
},
159 {19, "m3", 24, 0x23, ASM_REG_W_M3
},
160 {20, "m4", 24, 0x24, ASM_REG_W_M4
},
161 {21, "m5", 24, 0x25, ASM_REG_W_M5
},
162 {22, "m6", 24, 0x26, ASM_REG_W_M6
},
163 {23, "m7", 24, 0x27, ASM_REG_W_M7
},
164 /* data alu input register */
165 {24, "x0", 24, 0x04, ASM_REG_W_X0
},
166 {25, "x1", 24, 0x05, ASM_REG_W_X1
},
167 {26, "y0", 24, 0x06, ASM_REG_W_Y0
},
168 {27, "y1", 24, 0x07, ASM_REG_W_Y1
},
169 /* data alu accumulator register */
170 {28, "a0", 24, 0x08, ASM_REG_W_A0
},
171 {29, "a1", 24, 0x0c, ASM_REG_W_A1
},
172 {30, "a2", 8, 0x0a, ASM_REG_W_A2
},
173 {31, "b0", 24, 0x09, ASM_REG_W_B0
},
174 {32, "b1", 24, 0x0d, ASM_REG_W_B1
},
175 {33, "b2", 8, 0x0b, ASM_REG_W_B2
},
177 {34, "ssh",24, 0x3c, ASM_REG_W_SSH
},
178 {35, "ssl",24, 0x3d, ASM_REG_W_SSL
},
179 {36, "sp", 24, 0x3b, ASM_REG_W_SP
},
180 {37, "ep", 24, 0x2a, ASM_REG_W_EP
},
181 {38, "sz", 24, 0x38, ASM_REG_W_SZ
},
182 {39, "sc", 24, 0x31, ASM_REG_W_SC
},
184 {40, "pc", 24, 0x00, ASM_REG_W_PC
},
185 {41, "sr", 24, 0x39, ASM_REG_W_SR
},
186 {42, "omr",24, 0x3a, ASM_REG_W_OMR
},
187 {43, "la", 24, 0x3e, ASM_REG_W_LA
},
188 {44, "lc", 24, 0x3f, ASM_REG_W_LC
},
190 {45, "vba", 24, 0x30, ASM_REG_W_VBA
},
191 {46, "iprc",24, 0x00, ASM_REG_W_IPRC
},
192 {47, "iprp",24, 0x00, ASM_REG_W_IPRP
},
194 {48, "bcr", 24, 0x00, ASM_REG_W_BCR
},
195 {49, "dcr", 24, 0x00, ASM_REG_W_DCR
},
196 {50, "aar0",24, 0x00, ASM_REG_W_AAR0
},
197 {51, "aar1",24, 0x00, ASM_REG_W_AAR1
},
198 {52, "aar2",24, 0x00, ASM_REG_W_AAR2
},
199 {53, "aar3",24, 0x00, ASM_REG_W_AAR3
},
206 #define REG_NUM_M0 16
207 #define REG_NUM_M1 17
208 #define REG_NUM_SSH 34
209 #define REG_NUM_SSL 35
210 #define REG_NUM_SP 36
211 #define REG_NUM_EP 37
212 #define REG_NUM_SC 39
213 #define REG_NUM_PC 40
214 #define REG_NUM_SR 41
215 #define REG_NUM_IPRC 46
216 #define REG_NUM_IPRP 47
217 #define REG_NUM_BCR 48
218 #define REG_NUM_DCR 49
219 #define REG_NUM_AAR0 50
220 #define REG_NUM_AAR1 51
221 #define REG_NUM_AAR2 52
222 #define REG_NUM_AAR3 53
224 #define INSTR_JUMP 0x0AF080
225 /* Effective Addressing Mode Encoding */
227 /* instrcution encoder */
229 * s - peripheral space X/Y (X=0,Y=1)
231 * d - source/destination register
232 * p - IO short address
234 #define INSTR_MOVEP_REG_HIO(s,w,d,p) (0x084000 | ((s & 1)<<16) | ((w&1)<<15) | ((d & 0x3f)<<8) | (p & 0x3f))
236 static int dsp563xx_get_gdb_reg_list(struct target
*target
, struct reg
**reg_list
[], int *reg_list_size
)
239 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
241 if (target
->state
!= TARGET_HALTED
)
243 return ERROR_TARGET_NOT_HALTED
;
246 *reg_list_size
= DSP563XX_NUMCOREREGS
;
247 *reg_list
= malloc(sizeof(struct reg
*) * (*reg_list_size
));
250 return ERROR_INVALID_ARGUMENTS
;
252 for (i
= 0; i
< DSP563XX_NUMCOREREGS
; i
++)
254 (*reg_list
)[i
] = &dsp563xx
->core_cache
->reg_list
[i
];
261 static int dsp563xx_read_core_reg(struct target
*target
, int num
)
264 struct dsp563xx_core_reg
*dsp563xx_core_reg
;
265 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
267 if ((num
< 0) || (num
>= DSP563XX_NUMCOREREGS
))
268 return ERROR_INVALID_ARGUMENTS
;
270 dsp563xx_core_reg
= dsp563xx
->core_cache
->reg_list
[num
].arch_info
;
271 reg_value
= dsp563xx
->core_regs
[num
];
272 buf_set_u32(dsp563xx
->core_cache
->reg_list
[num
].value
, 0, 32, reg_value
);
273 dsp563xx
->core_cache
->reg_list
[num
].valid
= 1;
274 dsp563xx
->core_cache
->reg_list
[num
].dirty
= 0;
279 static int dsp563xx_write_core_reg(struct target
*target
, int num
)
282 struct dsp563xx_core_reg
*dsp563xx_core_reg
;
283 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
285 if ((num
< 0) || (num
>= DSP563XX_NUMCOREREGS
))
286 return ERROR_INVALID_ARGUMENTS
;
288 reg_value
= buf_get_u32(dsp563xx
->core_cache
->reg_list
[num
].value
, 0, 32);
289 dsp563xx_core_reg
= dsp563xx
->core_cache
->reg_list
[num
].arch_info
;
290 dsp563xx
->core_regs
[num
] = reg_value
;
291 dsp563xx
->core_cache
->reg_list
[num
].valid
= 1;
292 dsp563xx
->core_cache
->reg_list
[num
].dirty
= 0;
297 static int dsp563xx_target_create(struct target
*target
, Jim_Interp
* interp
)
299 struct dsp563xx_common
*dsp563xx
= calloc(1, sizeof(struct dsp563xx_common
));
302 return ERROR_INVALID_ARGUMENTS
;
304 dsp563xx
->jtag_info
.tap
= target
->tap
;
305 target
->arch_info
= dsp563xx
;
306 dsp563xx
->read_core_reg
= dsp563xx_read_core_reg
;
307 dsp563xx
->write_core_reg
= dsp563xx_write_core_reg
;
312 static int dsp563xx_get_core_reg(struct reg
*reg
)
314 struct dsp563xx_core_reg
*dsp563xx_reg
= reg
->arch_info
;
315 struct target
*target
= dsp563xx_reg
->target
;
316 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
318 LOG_DEBUG("%s", __FUNCTION__
);
320 if (target
->state
!= TARGET_HALTED
)
322 return ERROR_TARGET_NOT_HALTED
;
325 return dsp563xx
->read_core_reg(target
, dsp563xx_reg
->num
);
328 static int dsp563xx_set_core_reg(struct reg
*reg
, uint8_t * buf
)
330 LOG_DEBUG("%s", __FUNCTION__
);
332 struct dsp563xx_core_reg
*dsp563xx_reg
= reg
->arch_info
;
333 struct target
*target
= dsp563xx_reg
->target
;
334 uint32_t value
= buf_get_u32(buf
, 0, 32);
336 if (target
->state
!= TARGET_HALTED
)
338 return ERROR_TARGET_NOT_HALTED
;
341 buf_set_u32(reg
->value
, 0, reg
->size
, value
);
348 static int dsp563xx_read_register(struct target
*target
, int num
, int force
);
349 static int dsp563xx_write_register(struct target
*target
, int num
, int force
);
351 static int dsp563xx_reg_read_high_io(struct target
*target
, uint32_t instr_mask
, uint32_t * data
)
355 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
357 /* we use r0 to store temporary data */
358 if (!dsp563xx
->core_cache
->reg_list
[REG_NUM_R0
].valid
)
359 dsp563xx
->read_core_reg(target
, REG_NUM_R0
);
361 /* move source memory to r0 */
362 instr
= INSTR_MOVEP_REG_HIO(0, 0, EAME_R0
, instr_mask
);
363 if ((err
= dsp563xx_once_execute_sw_ir_nq(target
->tap
, instr
)) != ERROR_OK
)
365 /* move r0 to debug register */
366 instr
= INSTR_MOVEP_REG_HIO(0, 1, EAME_R0
, 0xfffffc);
367 if ((err
= dsp563xx_once_execute_sw_ir(target
->tap
, instr
)) != ERROR_OK
)
369 /* read debug register */
370 if ((err
= dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OGDBR
, data
)) != ERROR_OK
)
372 /* r0 is no longer valid on target */
373 dsp563xx
->core_cache
->reg_list
[REG_NUM_R0
].dirty
= 1;
378 static int dsp563xx_reg_write_high_io(struct target
*target
, uint32_t instr_mask
, uint32_t data
)
382 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
384 /* we use r0 to store temporary data */
385 if (!dsp563xx
->core_cache
->reg_list
[REG_NUM_R0
].valid
)
386 dsp563xx
->read_core_reg(target
, REG_NUM_R0
);
388 /* move data to r0 */
389 if ((err
= dsp563xx_once_execute_dw_ir_nq(target
->tap
, 0x60F400, data
)) != ERROR_OK
)
391 /* move r0 to destination memory */
392 instr
= INSTR_MOVEP_REG_HIO(0, 1, EAME_R0
, instr_mask
);
393 if ((err
= dsp563xx_once_execute_sw_ir(target
->tap
, instr
)) != ERROR_OK
)
396 /* r0 is no longer valid on target */
397 dsp563xx
->core_cache
->reg_list
[REG_NUM_R0
].dirty
= 1;
402 static int dsp563xx_reg_read(struct target
*target
, uint32_t eame
, uint32_t * data
)
407 instr
= INSTR_MOVEP_REG_HIO(0, 1, eame
, 0xfffffc);
408 if ((err
= dsp563xx_once_execute_sw_ir_nq(target
->tap
, instr
)) != ERROR_OK
)
411 if ((err
= dsp563xx_once_execute_sw_ir(target
->tap
, 0x000000)) != ERROR_OK
)
413 /* read debug register */
414 return dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OGDBR
, data
);
417 static int dsp563xx_reg_write(struct target
*target
, uint32_t instr_mask
, uint32_t data
)
421 if ((err
= dsp563xx_once_execute_dw_ir_nq(target
->tap
, instr_mask
, data
)) != ERROR_OK
)
424 return dsp563xx_once_execute_sw_ir(target
->tap
, 0x000000);
427 static int dsp563xx_reg_pc_read(struct target
*target
)
430 uint32_t opabdr
, opabex
;
431 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
433 /* pc was changed, nothing todo */
434 if (dsp563xx
->core_cache
->reg_list
[REG_NUM_PC
].dirty
)
437 if ((err
= dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPABDR
, &opabdr
)) != ERROR_OK
)
439 if ((err
= dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPABEX
, &opabex
)) != ERROR_OK
)
442 /* conditional branch check */
443 if (opabdr
== opabex
)
445 /* TODO: check the trace buffer and if a
446 * conditional branch is detected then decode
447 * the branch command and add the relative
448 * address to the current pc
450 LOG_DEBUG("%s conditional branch not supported yet", __FUNCTION__
);
454 dsp563xx
->core_regs
[REG_NUM_PC
] = opabex
;
455 dsp563xx
->read_core_reg(target
, REG_NUM_PC
);
461 static int dsp563xx_reg_ssh_read(struct target
*target
)
465 struct dsp563xx_core_reg
*arch_info
;
466 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
468 arch_info
= dsp563xx
->core_cache
->reg_list
[REG_NUM_SSH
].arch_info
;
470 /* get a valid stack pointer */
471 if ((err
= dsp563xx_read_register(target
, REG_NUM_SP
, 0)) != ERROR_OK
)
473 sp
= dsp563xx
->core_regs
[REG_NUM_SP
];
474 if ((err
= dsp563xx_write_register(target
, REG_NUM_SP
, 0)) != ERROR_OK
)
477 /* get a valid stack count */
478 if ((err
= dsp563xx_read_register(target
, REG_NUM_SC
, 0)) != ERROR_OK
)
480 sc
= dsp563xx
->core_regs
[REG_NUM_SC
];
481 if ((err
= dsp563xx_write_register(target
, REG_NUM_SC
, 0)) != ERROR_OK
)
484 /* get a valid extended pointer */
485 if ((err
= dsp563xx_read_register(target
, REG_NUM_EP
, 0)) != ERROR_OK
)
487 ep
= dsp563xx
->core_regs
[REG_NUM_EP
];
488 if ((err
= dsp563xx_write_register(target
, REG_NUM_EP
, 0)) != ERROR_OK
)
497 if ((err
= dsp563xx_reg_read(target
, arch_info
->eame
, &sp
)) != ERROR_OK
)
500 if ((err
= dsp563xx_write_register(target
, REG_NUM_SC
, 1)) != ERROR_OK
)
502 if ((err
= dsp563xx_write_register(target
, REG_NUM_SP
, 1)) != ERROR_OK
)
504 if ((err
= dsp563xx_write_register(target
, REG_NUM_EP
, 1)) != ERROR_OK
)
508 dsp563xx
->core_regs
[REG_NUM_SSH
] = sp
;
509 dsp563xx
->read_core_reg(target
, REG_NUM_SSH
);
514 static int dsp563xx_reg_ssh_write(struct target
*target
)
518 struct dsp563xx_core_reg
*arch_info
;
519 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
521 arch_info
= dsp563xx
->core_cache
->reg_list
[REG_NUM_SSH
].arch_info
;
523 /* get a valid stack pointer */
524 if ((err
= dsp563xx_read_register(target
, REG_NUM_SP
, 0)) != ERROR_OK
)
526 sp
= dsp563xx
->core_regs
[REG_NUM_SP
];
531 /* write new stackpointer */
532 dsp563xx
->core_regs
[REG_NUM_SP
] = sp
;
533 if ((err
= dsp563xx
->read_core_reg(target
, REG_NUM_SP
)) != ERROR_OK
)
535 if ((err
= dsp563xx_write_register(target
, REG_NUM_SP
, 1)) != ERROR_OK
)
538 if ((err
= dsp563xx_reg_write(target
, arch_info
->instr_mask
, dsp563xx
->core_regs
[REG_NUM_SSH
])) != ERROR_OK
)
541 if ((err
= dsp563xx_read_register(target
, REG_NUM_SP
, 1)) != ERROR_OK
)
543 if ((err
= dsp563xx_read_register(target
, REG_NUM_SSH
, 1)) != ERROR_OK
)
550 static int dsp563xx_reg_ssl_read(struct target
*target
)
554 struct dsp563xx_core_reg
*arch_info
;
555 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
557 arch_info
= dsp563xx
->core_cache
->reg_list
[REG_NUM_SSL
].arch_info
;
559 /* get a valid stack pointer */
560 if ((err
= dsp563xx_read_register(target
, REG_NUM_SP
, 0)) != ERROR_OK
)
562 sp
= dsp563xx
->core_regs
[REG_NUM_SP
];
570 if ((err
= dsp563xx_reg_read(target
, arch_info
->eame
, &sp
)) != ERROR_OK
)
574 dsp563xx
->core_regs
[REG_NUM_SSL
] = sp
;
575 dsp563xx
->read_core_reg(target
, REG_NUM_SSL
);
580 static int dsp563xx_read_register(struct target
*target
, int num
, int force
)
584 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
585 struct dsp563xx_core_reg
*arch_info
;
588 dsp563xx
->core_cache
->reg_list
[num
].valid
= 0;
590 if (!dsp563xx
->core_cache
->reg_list
[num
].valid
)
592 arch_info
= dsp563xx
->core_cache
->reg_list
[num
].arch_info
;
594 switch (arch_info
->num
)
597 err
= dsp563xx_reg_ssh_read(target
);
600 err
= dsp563xx_reg_ssl_read(target
);
603 err
= dsp563xx_reg_pc_read(target
);
613 err
= dsp563xx_reg_read_high_io(target
, arch_info
->instr_mask
, &data
);
616 dsp563xx
->core_regs
[num
] = data
;
617 dsp563xx
->read_core_reg(target
, num
);
621 err
= dsp563xx_reg_read(target
, arch_info
->eame
, &data
);
624 dsp563xx
->core_regs
[num
] = data
;
625 dsp563xx
->read_core_reg(target
, num
);
635 static int dsp563xx_write_register(struct target
*target
, int num
, int force
)
638 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
639 struct dsp563xx_core_reg
*arch_info
;
642 dsp563xx
->core_cache
->reg_list
[num
].dirty
= 1;
644 if (dsp563xx
->core_cache
->reg_list
[num
].dirty
)
646 arch_info
= dsp563xx
->core_cache
->reg_list
[num
].arch_info
;
648 dsp563xx
->write_core_reg(target
, num
);
650 switch (arch_info
->num
)
653 err
= dsp563xx_reg_ssh_write(target
);
656 /* pc is updated on resume, no need to write it here */
666 err
= dsp563xx_reg_write_high_io(target
, arch_info
->instr_mask
, dsp563xx
->core_regs
[num
]);
669 err
= dsp563xx_reg_write(target
, arch_info
->instr_mask
, dsp563xx
->core_regs
[num
]);
671 if ((err
== ERROR_OK
) && (arch_info
->num
== REG_NUM_SP
))
673 dsp563xx
->core_cache
->reg_list
[REG_NUM_SSH
].valid
= 0;
674 dsp563xx
->core_cache
->reg_list
[REG_NUM_SSL
].valid
= 0;
684 static int dsp563xx_save_context(struct target
*target
)
686 int i
, err
= ERROR_OK
;
688 for (i
= 0; i
< DSP563XX_NUMCOREREGS
; i
++)
690 if ((err
= dsp563xx_read_register(target
, i
, 0)) != ERROR_OK
)
697 static int dsp563xx_restore_context(struct target
*target
)
699 int i
, err
= ERROR_OK
;
701 for (i
= 0; i
< DSP563XX_NUMCOREREGS
; i
++)
703 if ((err
= dsp563xx_write_register(target
, i
, 0)) != ERROR_OK
)
710 static const struct reg_arch_type dsp563xx_reg_type
= {
711 .get
= dsp563xx_get_core_reg
,
712 .set
= dsp563xx_set_core_reg
,
715 static int dsp563xx_init_target(struct command_context
*cmd_ctx
, struct target
*target
)
717 /* get pointers to arch-specific information */
718 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
720 struct reg_cache
**cache_p
= register_get_last_cache_p(&target
->reg_cache
);
721 struct reg_cache
*cache
= malloc(sizeof(struct reg_cache
));
722 struct reg
*reg_list
= malloc(sizeof(struct reg
) * DSP563XX_NUMCOREREGS
);
723 struct dsp563xx_core_reg
*arch_info
= malloc(sizeof(struct dsp563xx_core_reg
) * DSP563XX_NUMCOREREGS
);
726 LOG_DEBUG("%s", __FUNCTION__
);
728 /* Build the process context cache */
729 cache
->name
= "dsp563xx registers";
731 cache
->reg_list
= reg_list
;
732 cache
->num_regs
= DSP563XX_NUMCOREREGS
;
734 dsp563xx
->core_cache
= cache
;
736 for (i
= 0; i
< DSP563XX_NUMCOREREGS
; i
++)
738 arch_info
[i
].num
= dsp563xx_regs
[i
].id
;
739 arch_info
[i
].name
= dsp563xx_regs
[i
].name
;
740 arch_info
[i
].size
= dsp563xx_regs
[i
].bits
;
741 arch_info
[i
].eame
= dsp563xx_regs
[i
].eame
;
742 arch_info
[i
].instr_mask
= dsp563xx_regs
[i
].instr_mask
;
743 arch_info
[i
].target
= target
;
744 arch_info
[i
].dsp563xx_common
= dsp563xx
;
745 reg_list
[i
].name
= dsp563xx_regs
[i
].name
;
746 reg_list
[i
].size
= dsp563xx_regs
[i
].bits
;
747 reg_list
[i
].value
= calloc(1, 4);
748 reg_list
[i
].dirty
= 0;
749 reg_list
[i
].valid
= 0;
750 reg_list
[i
].type
= &dsp563xx_reg_type
;
751 reg_list
[i
].arch_info
= &arch_info
[i
];
757 static int dsp563xx_arch_state(struct target
*target
)
759 LOG_DEBUG("%s", __FUNCTION__
);
763 #define DSP563XX_SR_SA (1<<17)
764 #define DSP563XX_SR_SC (1<<13)
766 static int dsp563xx_debug_once_init(struct target
*target
)
768 return dsp563xx_once_read_register(target
->tap
, once_regs
, DSP563XX_NUMONCEREGS
);
771 static int dsp563xx_debug_init(struct target
*target
)
775 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
776 struct dsp563xx_core_reg
*arch_info
;
778 if ((err
= dsp563xx_debug_once_init(target
)) != ERROR_OK
)
781 arch_info
= dsp563xx
->core_cache
->reg_list
[REG_NUM_SR
].arch_info
;
783 /* check 24bit mode */
784 if ((err
= dsp563xx_read_register(target
, REG_NUM_SR
, 0)) != ERROR_OK
)
787 sr
= dsp563xx
->core_regs
[REG_NUM_SR
];
789 if (sr
& (DSP563XX_SR_SA
| DSP563XX_SR_SC
))
791 sr
&= ~(DSP563XX_SR_SA
| DSP563XX_SR_SC
);
793 if ((err
= dsp563xx_once_execute_dw_ir(target
->tap
, arch_info
->instr_mask
, sr
)) != ERROR_OK
)
795 dsp563xx
->core_cache
->reg_list
[REG_NUM_SR
].dirty
= 1;
798 if ((err
= dsp563xx_read_register(target
, REG_NUM_N0
, 0)) != ERROR_OK
)
800 if ((err
= dsp563xx_read_register(target
, REG_NUM_N1
, 0)) != ERROR_OK
)
802 if ((err
= dsp563xx_read_register(target
, REG_NUM_M0
, 0)) != ERROR_OK
)
804 if ((err
= dsp563xx_read_register(target
, REG_NUM_M1
, 0)) != ERROR_OK
)
807 if (dsp563xx
->core_regs
[REG_NUM_N0
] != 0x000000)
809 arch_info
= dsp563xx
->core_cache
->reg_list
[REG_NUM_N0
].arch_info
;
810 if ((err
= dsp563xx_reg_write(target
, arch_info
->instr_mask
, 0x000000)) != ERROR_OK
)
813 dsp563xx
->core_cache
->reg_list
[REG_NUM_N0
].dirty
= 1;
815 if (dsp563xx
->core_regs
[REG_NUM_N1
] != 0x000000)
817 arch_info
= dsp563xx
->core_cache
->reg_list
[REG_NUM_N1
].arch_info
;
818 if ((err
= dsp563xx_reg_write(target
, arch_info
->instr_mask
, 0x000000)) != ERROR_OK
)
821 dsp563xx
->core_cache
->reg_list
[REG_NUM_N1
].dirty
= 1;
823 if (dsp563xx
->core_regs
[REG_NUM_M0
] != 0xffffff)
825 arch_info
= dsp563xx
->core_cache
->reg_list
[REG_NUM_M0
].arch_info
;
826 if ((err
= dsp563xx_reg_write(target
, arch_info
->instr_mask
, 0xffffff)) != ERROR_OK
)
829 dsp563xx
->core_cache
->reg_list
[REG_NUM_M0
].dirty
= 1;
831 if (dsp563xx
->core_regs
[REG_NUM_M1
] != 0xffffff)
833 arch_info
= dsp563xx
->core_cache
->reg_list
[REG_NUM_M1
].arch_info
;
834 if ((err
= dsp563xx_reg_write(target
, arch_info
->instr_mask
, 0xffffff)) != ERROR_OK
)
837 dsp563xx
->core_cache
->reg_list
[REG_NUM_M1
].dirty
= 1;
839 if ((err
= dsp563xx_save_context(target
)) != ERROR_OK
)
845 static int dsp563xx_jtag_debug_request(struct target
*target
)
847 return dsp563xx_once_request_debug(target
->tap
, target
->state
== TARGET_RESET
);
850 static int dsp563xx_poll(struct target
*target
)
853 uint32_t once_status
;
856 state
= dsp563xx_once_target_status(target
->tap
);
858 if (state
== TARGET_UNKNOWN
)
860 target
->state
= state
;
861 LOG_ERROR("jtag status contains invalid mode value - communication failure");
862 return ERROR_TARGET_FAILURE
;
865 if ((err
= dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OSCR
, &once_status
)) != ERROR_OK
)
868 if ((once_status
& DSP563XX_ONCE_OSCR_DEBUG_M
) == DSP563XX_ONCE_OSCR_DEBUG_M
)
870 if (target
->state
!= TARGET_HALTED
)
872 target
->state
= TARGET_HALTED
;
873 if ((err
= dsp563xx_debug_init(target
)) != ERROR_OK
)
876 LOG_DEBUG("target->state: %s", target_state_name(target
));
883 static int dsp563xx_halt(struct target
*target
)
886 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
888 if (target
->state
== TARGET_HALTED
)
890 LOG_DEBUG("target was already halted");
894 if (target
->state
== TARGET_UNKNOWN
)
896 LOG_WARNING("target was in unknown state when halt was requested");
899 if ((err
= dsp563xx_jtag_debug_request(target
)) != ERROR_OK
)
902 /* store pipeline register */
903 if ((err
= dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPILR
, &dsp563xx
->pipeline_context
.once_opilr
)) != ERROR_OK
)
905 if ((err
= dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPDBR
, &dsp563xx
->pipeline_context
.once_opdbr
)) != ERROR_OK
)
908 LOG_DEBUG("%s", __FUNCTION__
);
913 static int dsp563xx_resume(struct target
*target
, int current
, uint32_t address
, int handle_breakpoints
, int debug_execution
)
916 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
918 LOG_DEBUG("%s", __FUNCTION__
);
920 if ((err
= dsp563xx_restore_context(target
)) != ERROR_OK
)
922 register_cache_invalidate(dsp563xx
->core_cache
);
926 /* restore pipeline registers and go */
927 if ((err
= dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OPILR
, dsp563xx
->pipeline_context
.once_opilr
)) != ERROR_OK
)
930 dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OPDBR
| DSP563XX_ONCE_OCR_EX
| DSP563XX_ONCE_OCR_GO
,
931 dsp563xx
->pipeline_context
.once_opdbr
)) != ERROR_OK
)
936 /* set to go register and jump */
937 if ((err
= dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OPDBR
, INSTR_JUMP
)) != ERROR_OK
)
939 if ((err
= dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_PDBGOTO
| DSP563XX_ONCE_OCR_EX
| DSP563XX_ONCE_OCR_GO
, address
)) != ERROR_OK
)
943 target
->state
= TARGET_RUNNING
;
948 static int dsp563xx_step_ex(struct target
*target
, int current
, uint32_t address
, int handle_breakpoints
, int steps
)
951 uint32_t once_status
;
953 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
955 if (target
->state
!= TARGET_HALTED
)
957 LOG_DEBUG("target was not halted");
961 LOG_DEBUG("%s %08X %08X", __FUNCTION__
, current
, (unsigned) address
);
963 if ((err
= dsp563xx_jtag_debug_request(target
)) != ERROR_OK
)
965 if ((err
= dsp563xx_restore_context(target
)) != ERROR_OK
)
968 /* reset trace mode */
969 if ((err
= dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OSCR
, 0x000000)) != ERROR_OK
)
971 /* enable trace mode */
972 if ((err
= dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OSCR
, DSP563XX_ONCE_OSCR_TME
)) != ERROR_OK
)
977 /* on JUMP we need one extra cycle */
981 /* load step counter with N-1 */
982 if ((err
= dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OTC
, cnt
)) != ERROR_OK
)
987 /* restore pipeline registers and go */
988 if ((err
= dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OPILR
, dsp563xx
->pipeline_context
.once_opilr
)) != ERROR_OK
)
991 dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OPDBR
| DSP563XX_ONCE_OCR_EX
| DSP563XX_ONCE_OCR_GO
,
992 dsp563xx
->pipeline_context
.once_opdbr
)) != ERROR_OK
)
997 /* set to go register and jump */
998 if ((err
= dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OPDBR
, INSTR_JUMP
)) != ERROR_OK
)
1000 if ((err
= dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_PDBGOTO
| DSP563XX_ONCE_OCR_EX
| DSP563XX_ONCE_OCR_GO
, address
)) != ERROR_OK
)
1006 if ((err
= dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OSCR
, &once_status
)) != ERROR_OK
)
1009 if (once_status
& DSP563XX_ONCE_OSCR_TO
)
1011 /* store pipeline register */
1012 if ((err
= dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPILR
, &dsp563xx
->pipeline_context
.once_opilr
)) != ERROR_OK
)
1014 if ((err
= dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPDBR
, &dsp563xx
->pipeline_context
.once_opdbr
)) != ERROR_OK
)
1017 if ((err
= dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPABFR
, &dr_in
)) != ERROR_OK
)
1019 LOG_DEBUG("fetch: %08X", (unsigned) dr_in
);
1020 if ((err
= dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPABDR
, &dr_in
)) != ERROR_OK
)
1022 LOG_DEBUG("decode: %08X", (unsigned) dr_in
);
1023 if ((err
= dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OPABEX
, &dr_in
)) != ERROR_OK
)
1025 LOG_DEBUG("execute: %08X", (unsigned) dr_in
);
1027 /* reset trace mode */
1028 if ((err
= dsp563xx_once_reg_write(target
->tap
, DSP563XX_ONCE_OSCR
, 0x000000)) != ERROR_OK
)
1031 register_cache_invalidate(dsp563xx
->core_cache
);
1032 if ((err
= dsp563xx_debug_init(target
)) != ERROR_OK
)
1042 static int dsp563xx_step(struct target
*target
, int current
, uint32_t address
, int handle_breakpoints
)
1044 return dsp563xx_step_ex(target
, current
, address
, handle_breakpoints
, 0);
1047 static int dsp563xx_assert_reset(struct target
*target
)
1050 struct dsp563xx_common
*dsp563xx
= target_to_dsp563xx(target
);
1051 enum reset_types jtag_reset_config
= jtag_get_reset_config();
1053 if (jtag_reset_config
& RESET_HAS_SRST
)
1055 /* default to asserting srst */
1056 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
1058 jtag_add_reset(1, 1);
1062 jtag_add_reset(0, 1);
1066 target
->state
= TARGET_RESET
;
1067 jtag_add_sleep(5000);
1069 /* registers are now invalid */
1070 register_cache_invalidate(dsp563xx
->core_cache
);
1072 if (target
->reset_halt
)
1074 if ((retval
= target_halt(target
)) != ERROR_OK
)
1078 LOG_DEBUG("%s", __FUNCTION__
);
1082 static int dsp563xx_deassert_reset(struct target
*target
)
1086 /* deassert reset lines */
1087 jtag_add_reset(0, 0);
1089 if ((err
= dsp563xx_poll(target
)) != ERROR_OK
)
1092 if (target
->reset_halt
)
1094 if (target
->state
== TARGET_HALTED
)
1096 /* after a reset the cpu jmp to the
1097 * reset vector and need 2 cycles to fill
1098 * the cache (fetch,decode,excecute)
1100 if ((err
= dsp563xx_step_ex(target
, 1, 0, 1, 1)) != ERROR_OK
)
1105 // target->state = TARGET_RUNNING;
1107 LOG_DEBUG("%s", __FUNCTION__
);
1111 static int dsp563xx_soft_reset_halt(struct target
*target
)
1113 LOG_DEBUG("%s", __FUNCTION__
);
1119 * 46F400 AABBCC move #$aabbcc,y0
1120 * 60F400 AABBCC move #$aabbcc,r0
1121 * 467000 AABBCC move y0,x:AABBCC
1122 * 607000 AABBCC move r0,x:AABBCC
1124 * 46E000 move x:(r0),y0
1125 * 4EE000 move y:(r0),y0
1126 * 07E086 move p:(r0),y0
1129 * 0446BA move omr,y0
1130 * 0446BC move ssh,y0
1131 * 0446BD move ssl,y0
1135 * 61F000 AABBCC move x:AABBCC,r1
1136 * 076190 movem r0,p:(r1)
1139 static int dsp563xx_read_memory_p(struct target
*target
, uint32_t address
, uint32_t size
, uint32_t count
, uint8_t * buffer
)
1146 LOG_DEBUG("address: 0x%8.8" PRIx32
", size: 0x%8.8" PRIx32
", count: 0x%8.8" PRIx32
, address
, size
, count
);
1148 if (target
->state
!= TARGET_HALTED
)
1150 LOG_WARNING("target not halted");
1151 return ERROR_TARGET_NOT_HALTED
;
1156 for (i
= 0; i
< x
; i
++)
1158 if ((err
= dsp563xx_once_execute_dw_ir_nq(target
->tap
, 0x60F400, address
+ i
)) != ERROR_OK
)
1160 if ((err
= dsp563xx_once_execute_sw_ir_nq(target
->tap
, 0x07E086)) != ERROR_OK
)
1162 if ((err
= dsp563xx_once_execute_dw_ir_nq(target
->tap
, 0x467000, 0xfffffc)) != ERROR_OK
)
1164 if ((err
= jtag_execute_queue()) != ERROR_OK
)
1167 if ((err
= dsp563xx_once_reg_read(target
->tap
, DSP563XX_ONCE_OGDBR
, &data
)) != ERROR_OK
)
1184 static int dsp563xx_write_memory_p(struct target
*target
, uint32_t address
, uint32_t size
, uint32_t count
, uint8_t * buffer
)
1191 LOG_DEBUG("address: 0x%8.8" PRIx32
", size: 0x%8.8" PRIx32
", count: 0x%8.8" PRIx32
"", address
, size
, count
);
1193 if (target
->state
!= TARGET_HALTED
)
1195 LOG_WARNING("target not halted");
1196 return ERROR_TARGET_NOT_HALTED
;
1201 for (i
= 0; i
< x
; i
++)
1209 data
|= (*buffer
++) << 8;
1211 data
|= (*buffer
++) << 16;
1213 data
|= (*buffer
++) << 24;
1215 // LOG_DEBUG("%08X", data);
1217 if ((err
= dsp563xx_once_execute_dw_ir_nq(target
->tap
, 0x61F400, address
+ i
)) != ERROR_OK
)
1219 if ((err
= dsp563xx_once_execute_dw_ir_nq(target
->tap
, 0x60F400, data
)) != ERROR_OK
)
1221 if ((err
= dsp563xx_once_execute_sw_ir_nq(target
->tap
, 0x076190)) != ERROR_OK
)
1223 if ((err
= jtag_execute_queue()) != ERROR_OK
)
1230 /** Holds methods for DSP563XX targets. */
1231 struct target_type dsp563xx_target
= {
1234 .poll
= dsp563xx_poll
,
1235 .arch_state
= dsp563xx_arch_state
,
1237 .target_request_data
= NULL
,
1239 .get_gdb_reg_list
= dsp563xx_get_gdb_reg_list
,
1241 .halt
= dsp563xx_halt
,
1242 .resume
= dsp563xx_resume
,
1243 .step
= dsp563xx_step
,
1245 .assert_reset
= dsp563xx_assert_reset
,
1246 .deassert_reset
= dsp563xx_deassert_reset
,
1247 .soft_reset_halt
= dsp563xx_soft_reset_halt
,
1249 .read_memory
= dsp563xx_read_memory_p
,
1250 .write_memory
= dsp563xx_write_memory_p
,
1252 .target_create
= dsp563xx_target_create
,
1253 .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)