Code Review / openocd.git / blob
? search:


bcb648c2788620e43b075c9929294a19b20e9b7e
[openocd.git] / src / target / openrisc / or1k.c
1 /***************************************************************************
2 * Copyright (C) 2011 by Julius Baxter *
3 * julius@opencores.org *
4 * *
5 * Copyright (C) 2013 by Marek Czerski *
6 * ma.czerski@gmail.com *
7 * *
8 * Copyright (C) 2013 by Franck Jullien *
9 * elec4fun@gmail.com *
10 * *
11 * *
12 * This program is free software; you can redistribute it and/or modify *
13 * it under the terms of the GNU General Public License as published by *
14 * the Free Software Foundation; either version 2 of the License, or *
15 * (at your option) any later version. *
16 * *
17 * This program is distributed in the hope that it will be useful, *
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
20 * GNU General Public License for more details. *
21 * *
22 * You should have received a copy of the GNU General Public License *
23 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
24 ***************************************************************************/
25
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29
30 #include <jtag/jtag.h>
31 #include <target/register.h>
32 #include <target/target.h>
33 #include <target/breakpoints.h>
34 #include <target/target_type.h>
35 #include <helper/time_support.h>
36 #include <helper/fileio.h>
37 #include "or1k_tap.h"
38 #include "or1k.h"
39 #include "or1k_du.h"
40
41 LIST_HEAD(tap_list);
42 LIST_HEAD(du_list);
43
44 static int or1k_remove_breakpoint(struct target *target,
45 struct breakpoint *breakpoint);
46
47 static int or1k_read_core_reg(struct target *target, int num);
48 static int or1k_write_core_reg(struct target *target, int num);
49
50 static struct or1k_core_reg *or1k_core_reg_list_arch_info;
51
52 static const struct or1k_core_reg_init or1k_init_reg_list[] = {
53 {"r0" , GROUP0 + 1024, "org.gnu.gdb.or1k.group0", NULL},
54 {"r1" , GROUP0 + 1025, "org.gnu.gdb.or1k.group0", NULL},
55 {"r2" , GROUP0 + 1026, "org.gnu.gdb.or1k.group0", NULL},
56 {"r3" , GROUP0 + 1027, "org.gnu.gdb.or1k.group0", NULL},
57 {"r4" , GROUP0 + 1028, "org.gnu.gdb.or1k.group0", NULL},
58 {"r5" , GROUP0 + 1029, "org.gnu.gdb.or1k.group0", NULL},
59 {"r6" , GROUP0 + 1030, "org.gnu.gdb.or1k.group0", NULL},
60 {"r7" , GROUP0 + 1031, "org.gnu.gdb.or1k.group0", NULL},
61 {"r8" , GROUP0 + 1032, "org.gnu.gdb.or1k.group0", NULL},
62 {"r9" , GROUP0 + 1033, "org.gnu.gdb.or1k.group0", NULL},
63 {"r10" , GROUP0 + 1034, "org.gnu.gdb.or1k.group0", NULL},
64 {"r11" , GROUP0 + 1035, "org.gnu.gdb.or1k.group0", NULL},
65 {"r12" , GROUP0 + 1036, "org.gnu.gdb.or1k.group0", NULL},
66 {"r13" , GROUP0 + 1037, "org.gnu.gdb.or1k.group0", NULL},
67 {"r14" , GROUP0 + 1038, "org.gnu.gdb.or1k.group0", NULL},
68 {"r15" , GROUP0 + 1039, "org.gnu.gdb.or1k.group0", NULL},
69 {"r16" , GROUP0 + 1040, "org.gnu.gdb.or1k.group0", NULL},
70 {"r17" , GROUP0 + 1041, "org.gnu.gdb.or1k.group0", NULL},
71 {"r18" , GROUP0 + 1042, "org.gnu.gdb.or1k.group0", NULL},
72 {"r19" , GROUP0 + 1043, "org.gnu.gdb.or1k.group0", NULL},
73 {"r20" , GROUP0 + 1044, "org.gnu.gdb.or1k.group0", NULL},
74 {"r21" , GROUP0 + 1045, "org.gnu.gdb.or1k.group0", NULL},
75 {"r22" , GROUP0 + 1046, "org.gnu.gdb.or1k.group0", NULL},
76 {"r23" , GROUP0 + 1047, "org.gnu.gdb.or1k.group0", NULL},
77 {"r24" , GROUP0 + 1048, "org.gnu.gdb.or1k.group0", NULL},
78 {"r25" , GROUP0 + 1049, "org.gnu.gdb.or1k.group0", NULL},
79 {"r26" , GROUP0 + 1050, "org.gnu.gdb.or1k.group0", NULL},
80 {"r27" , GROUP0 + 1051, "org.gnu.gdb.or1k.group0", NULL},
81 {"r28" , GROUP0 + 1052, "org.gnu.gdb.or1k.group0", NULL},
82 {"r29" , GROUP0 + 1053, "org.gnu.gdb.or1k.group0", NULL},
83 {"r30" , GROUP0 + 1054, "org.gnu.gdb.or1k.group0", NULL},
84 {"r31" , GROUP0 + 1055, "org.gnu.gdb.or1k.group0", NULL},
85 {"ppc" , GROUP0 + 18, "org.gnu.gdb.or1k.group0", NULL},
86 {"npc" , GROUP0 + 16, "org.gnu.gdb.or1k.group0", NULL},
87 {"sr" , GROUP0 + 17, "org.gnu.gdb.or1k.group0", NULL},
88 {"vr" , GROUP0 + 0, "org.gnu.gdb.or1k.group0", "system"},
89 {"upr" , GROUP0 + 1, "org.gnu.gdb.or1k.group0", "system"},
90 {"cpucfgr" , GROUP0 + 2, "org.gnu.gdb.or1k.group0", "system"},
91 {"dmmucfgr" , GROUP0 + 3, "org.gnu.gdb.or1k.group0", "system"},
92 {"immucfgr" , GROUP0 + 4, "org.gnu.gdb.or1k.group0", "system"},
93 {"dccfgr" , GROUP0 + 5, "org.gnu.gdb.or1k.group0", "system"},
94 {"iccfgr" , GROUP0 + 6, "org.gnu.gdb.or1k.group0", "system"},
95 {"dcfgr" , GROUP0 + 7, "org.gnu.gdb.or1k.group0", "system"},
96 {"pccfgr" , GROUP0 + 8, "org.gnu.gdb.or1k.group0", "system"},
97 {"fpcsr" , GROUP0 + 20, "org.gnu.gdb.or1k.group0", "system"},
98 {"epcr0" , GROUP0 + 32, "org.gnu.gdb.or1k.group0", "system"},
99 {"epcr1" , GROUP0 + 33, "org.gnu.gdb.or1k.group0", "system"},
100 {"epcr2" , GROUP0 + 34, "org.gnu.gdb.or1k.group0", "system"},
101 {"epcr3" , GROUP0 + 35, "org.gnu.gdb.or1k.group0", "system"},
102 {"epcr4" , GROUP0 + 36, "org.gnu.gdb.or1k.group0", "system"},
103 {"epcr5" , GROUP0 + 37, "org.gnu.gdb.or1k.group0", "system"},
104 {"epcr6" , GROUP0 + 38, "org.gnu.gdb.or1k.group0", "system"},
105 {"epcr7" , GROUP0 + 39, "org.gnu.gdb.or1k.group0", "system"},
106 {"epcr8" , GROUP0 + 40, "org.gnu.gdb.or1k.group0", "system"},
107 {"epcr9" , GROUP0 + 41, "org.gnu.gdb.or1k.group0", "system"},
108 {"epcr10" , GROUP0 + 42, "org.gnu.gdb.or1k.group0", "system"},
109 {"epcr11" , GROUP0 + 43, "org.gnu.gdb.or1k.group0", "system"},
110 {"epcr12" , GROUP0 + 44, "org.gnu.gdb.or1k.group0", "system"},
111 {"epcr13" , GROUP0 + 45, "org.gnu.gdb.or1k.group0", "system"},
112 {"epcr14" , GROUP0 + 46, "org.gnu.gdb.or1k.group0", "system"},
113 {"epcr15" , GROUP0 + 47, "org.gnu.gdb.or1k.group0", "system"},
114 {"eear0" , GROUP0 + 48, "org.gnu.gdb.or1k.group0", "system"},
115 {"eear1" , GROUP0 + 49, "org.gnu.gdb.or1k.group0", "system"},
116 {"eear2" , GROUP0 + 50, "org.gnu.gdb.or1k.group0", "system"},
117 {"eear3" , GROUP0 + 51, "org.gnu.gdb.or1k.group0", "system"},
118 {"eear4" , GROUP0 + 52, "org.gnu.gdb.or1k.group0", "system"},
119 {"eear5" , GROUP0 + 53, "org.gnu.gdb.or1k.group0", "system"},
120 {"eear6" , GROUP0 + 54, "org.gnu.gdb.or1k.group0", "system"},
121 {"eear7" , GROUP0 + 55, "org.gnu.gdb.or1k.group0", "system"},
122 {"eear8" , GROUP0 + 56, "org.gnu.gdb.or1k.group0", "system"},
123 {"eear9" , GROUP0 + 57, "org.gnu.gdb.or1k.group0", "system"},
124 {"eear10" , GROUP0 + 58, "org.gnu.gdb.or1k.group0", "system"},
125 {"eear11" , GROUP0 + 59, "org.gnu.gdb.or1k.group0", "system"},
126 {"eear12" , GROUP0 + 60, "org.gnu.gdb.or1k.group0", "system"},
127 {"eear13" , GROUP0 + 61, "org.gnu.gdb.or1k.group0", "system"},
128 {"eear14" , GROUP0 + 62, "org.gnu.gdb.or1k.group0", "system"},
129 {"eear15" , GROUP0 + 63, "org.gnu.gdb.or1k.group0", "system"},
130 {"esr0" , GROUP0 + 64, "org.gnu.gdb.or1k.group0", "system"},
131 {"esr1" , GROUP0 + 65, "org.gnu.gdb.or1k.group0", "system"},
132 {"esr2" , GROUP0 + 66, "org.gnu.gdb.or1k.group0", "system"},
133 {"esr3" , GROUP0 + 67, "org.gnu.gdb.or1k.group0", "system"},
134 {"esr4" , GROUP0 + 68, "org.gnu.gdb.or1k.group0", "system"},
135 {"esr5" , GROUP0 + 69, "org.gnu.gdb.or1k.group0", "system"},
136 {"esr6" , GROUP0 + 70, "org.gnu.gdb.or1k.group0", "system"},
137 {"esr7" , GROUP0 + 71, "org.gnu.gdb.or1k.group0", "system"},
138 {"esr8" , GROUP0 + 72, "org.gnu.gdb.or1k.group0", "system"},
139 {"esr9" , GROUP0 + 73, "org.gnu.gdb.or1k.group0", "system"},
140 {"esr10" , GROUP0 + 74, "org.gnu.gdb.or1k.group0", "system"},
141 {"esr11" , GROUP0 + 75, "org.gnu.gdb.or1k.group0", "system"},
142 {"esr12" , GROUP0 + 76, "org.gnu.gdb.or1k.group0", "system"},
143 {"esr13" , GROUP0 + 77, "org.gnu.gdb.or1k.group0", "system"},
144 {"esr14" , GROUP0 + 78, "org.gnu.gdb.or1k.group0", "system"},
145 {"esr15" , GROUP0 + 79, "org.gnu.gdb.or1k.group0", "system"},
146
147 {"dmmuucr" , GROUP1 + 0, "org.gnu.gdb.or1k.group1", "dmmu"},
148 {"dmmuupr" , GROUP1 + 1, "org.gnu.gdb.or1k.group1", "dmmu"},
149 {"dtlbeir" , GROUP1 + 2, "org.gnu.gdb.or1k.group1", "dmmu"},
150 {"datbmr0" , GROUP1 + 4, "org.gnu.gdb.or1k.group1", "dmmu"},
151 {"datbmr1" , GROUP1 + 5, "org.gnu.gdb.or1k.group1", "dmmu"},
152 {"datbmr2" , GROUP1 + 6, "org.gnu.gdb.or1k.group1", "dmmu"},
153 {"datbmr3" , GROUP1 + 7, "org.gnu.gdb.or1k.group1", "dmmu"},
154 {"datbtr0" , GROUP1 + 8, "org.gnu.gdb.or1k.group1", "dmmu"},
155 {"datbtr1" , GROUP1 + 9, "org.gnu.gdb.or1k.group1", "dmmu"},
156 {"datbtr2" , GROUP1 + 10, "org.gnu.gdb.or1k.group1", "dmmu"},
157 {"datbtr3" , GROUP1 + 11, "org.gnu.gdb.or1k.group1", "dmmu"},
158
159 {"immucr" , GROUP2 + 0, "org.gnu.gdb.or1k.group2", "immu"},
160 {"immupr" , GROUP2 + 1, "org.gnu.gdb.or1k.group2", "immu"},
161 {"itlbeir" , GROUP2 + 2, "org.gnu.gdb.or1k.group2", "immu"},
162 {"iatbmr0" , GROUP2 + 4, "org.gnu.gdb.or1k.group2", "immu"},
163 {"iatbmr1" , GROUP2 + 5, "org.gnu.gdb.or1k.group2", "immu"},
164 {"iatbmr2" , GROUP2 + 6, "org.gnu.gdb.or1k.group2", "immu"},
165 {"iatbmr3" , GROUP2 + 7, "org.gnu.gdb.or1k.group2", "immu"},
166 {"iatbtr0" , GROUP2 + 8, "org.gnu.gdb.or1k.group2", "immu"},
167 {"iatbtr1" , GROUP2 + 9, "org.gnu.gdb.or1k.group2", "immu"},
168 {"iatbtr2" , GROUP2 + 10, "org.gnu.gdb.or1k.group2", "immu"},
169 {"iatbtr3" , GROUP2 + 11, "org.gnu.gdb.or1k.group2", "immu"},
170
171 {"dccr" , GROUP3 + 0, "org.gnu.gdb.or1k.group3", "dcache"},
172 {"dcbpr" , GROUP3 + 1, "org.gnu.gdb.or1k.group3", "dcache"},
173 {"dcbfr" , GROUP3 + 2, "org.gnu.gdb.or1k.group3", "dcache"},
174 {"dcbir" , GROUP3 + 3, "org.gnu.gdb.or1k.group3", "dcache"},
175 {"dcbwr" , GROUP3 + 4, "org.gnu.gdb.or1k.group3", "dcache"},
176 {"dcblr" , GROUP3 + 5, "org.gnu.gdb.or1k.group3", "dcache"},
177
178 {"iccr" , GROUP4 + 0, "org.gnu.gdb.or1k.group4", "icache"},
179 {"icbpr" , GROUP4 + 1, "org.gnu.gdb.or1k.group4", "icache"},
180 {"icbir" , GROUP4 + 2, "org.gnu.gdb.or1k.group4", "icache"},
181 {"icblr" , GROUP4 + 3, "org.gnu.gdb.or1k.group4", "icache"},
182
183 {"maclo" , GROUP5 + 0, "org.gnu.gdb.or1k.group5", "mac"},
184 {"machi" , GROUP5 + 1, "org.gnu.gdb.or1k.group5", "mac"},
185
186 {"dvr0" , GROUP6 + 0, "org.gnu.gdb.or1k.group6", "debug"},
187 {"dvr1" , GROUP6 + 1, "org.gnu.gdb.or1k.group6", "debug"},
188 {"dvr2" , GROUP6 + 2, "org.gnu.gdb.or1k.group6", "debug"},
189 {"dvr3" , GROUP6 + 3, "org.gnu.gdb.or1k.group6", "debug"},
190 {"dvr4" , GROUP6 + 4, "org.gnu.gdb.or1k.group6", "debug"},
191 {"dvr5" , GROUP6 + 5, "org.gnu.gdb.or1k.group6", "debug"},
192 {"dvr6" , GROUP6 + 6, "org.gnu.gdb.or1k.group6", "debug"},
193 {"dvr7" , GROUP6 + 7, "org.gnu.gdb.or1k.group6", "debug"},
194 {"dcr0" , GROUP6 + 8, "org.gnu.gdb.or1k.group6", "debug"},
195 {"dcr1" , GROUP6 + 9, "org.gnu.gdb.or1k.group6", "debug"},
196 {"dcr2" , GROUP6 + 10, "org.gnu.gdb.or1k.group6", "debug"},
197 {"dcr3" , GROUP6 + 11, "org.gnu.gdb.or1k.group6", "debug"},
198 {"dcr4" , GROUP6 + 12, "org.gnu.gdb.or1k.group6", "debug"},
199 {"dcr5" , GROUP6 + 13, "org.gnu.gdb.or1k.group6", "debug"},
200 {"dcr6" , GROUP6 + 14, "org.gnu.gdb.or1k.group6", "debug"},
201 {"dcr7" , GROUP6 + 15, "org.gnu.gdb.or1k.group6", "debug"},
202 {"dmr1" , GROUP6 + 16, "org.gnu.gdb.or1k.group6", "debug"},
203 {"dmr2" , GROUP6 + 17, "org.gnu.gdb.or1k.group6", "debug"},
204 {"dcwr0" , GROUP6 + 18, "org.gnu.gdb.or1k.group6", "debug"},
205 {"dcwr1" , GROUP6 + 19, "org.gnu.gdb.or1k.group6", "debug"},
206 {"dsr" , GROUP6 + 20, "org.gnu.gdb.or1k.group6", "debug"},
207 {"drr" , GROUP6 + 21, "org.gnu.gdb.or1k.group6", "debug"},
208
209 {"pccr0" , GROUP7 + 0, "org.gnu.gdb.or1k.group7", "perf"},
210 {"pccr1" , GROUP7 + 1, "org.gnu.gdb.or1k.group7", "perf"},
211 {"pccr2" , GROUP7 + 2, "org.gnu.gdb.or1k.group7", "perf"},
212 {"pccr3" , GROUP7 + 3, "org.gnu.gdb.or1k.group7", "perf"},
213 {"pccr4" , GROUP7 + 4, "org.gnu.gdb.or1k.group7", "perf"},
214 {"pccr5" , GROUP7 + 5, "org.gnu.gdb.or1k.group7", "perf"},
215 {"pccr6" , GROUP7 + 6, "org.gnu.gdb.or1k.group7", "perf"},
216 {"pccr7" , GROUP7 + 7, "org.gnu.gdb.or1k.group7", "perf"},
217 {"pcmr0" , GROUP7 + 8, "org.gnu.gdb.or1k.group7", "perf"},
218 {"pcmr1" , GROUP7 + 9, "org.gnu.gdb.or1k.group7", "perf"},
219 {"pcmr2" , GROUP7 + 10, "org.gnu.gdb.or1k.group7", "perf"},
220 {"pcmr3" , GROUP7 + 11, "org.gnu.gdb.or1k.group7", "perf"},
221 {"pcmr4" , GROUP7 + 12, "org.gnu.gdb.or1k.group7", "perf"},
222 {"pcmr5" , GROUP7 + 13, "org.gnu.gdb.or1k.group7", "perf"},
223 {"pcmr6" , GROUP7 + 14, "org.gnu.gdb.or1k.group7", "perf"},
224 {"pcmr7" , GROUP7 + 15, "org.gnu.gdb.or1k.group7", "perf"},
225
226 {"pmr" , GROUP8 + 0, "org.gnu.gdb.or1k.group8", "power"},
227
228 {"picmr" , GROUP9 + 0, "org.gnu.gdb.or1k.group9", "pic"},
229 {"picsr" , GROUP9 + 2, "org.gnu.gdb.or1k.group9", "pic"},
230
231 {"ttmr" , GROUP10 + 0, "org.gnu.gdb.or1k.group10", "timer"},
232 {"ttcr" , GROUP10 + 1, "org.gnu.gdb.or1k.group10", "timer"},
233 };
234
235 static int or1k_add_reg(struct target *target, struct or1k_core_reg *new_reg)
236 {
237 struct or1k_common *or1k = target_to_or1k(target);
238 int reg_list_size = or1k->nb_regs * sizeof(struct or1k_core_reg);
239
240 or1k_core_reg_list_arch_info = realloc(or1k_core_reg_list_arch_info,
241 reg_list_size + sizeof(struct or1k_core_reg));
242
243 memcpy(&or1k_core_reg_list_arch_info[or1k->nb_regs], new_reg,
244 sizeof(struct or1k_core_reg));
245
246 or1k_core_reg_list_arch_info[or1k->nb_regs].list_num = or1k->nb_regs;
247
248 or1k->nb_regs++;
249
250 return ERROR_OK;
251 }
252
253 static int or1k_create_reg_list(struct target *target)
254 {
255 struct or1k_common *or1k = target_to_or1k(target);
256
257 LOG_DEBUG("-");
258
259 or1k_core_reg_list_arch_info = malloc(ARRAY_SIZE(or1k_init_reg_list) *
260 sizeof(struct or1k_core_reg));
261
262 for (int i = 0; i < (int)ARRAY_SIZE(or1k_init_reg_list); i++) {
263 or1k_core_reg_list_arch_info[i].name = or1k_init_reg_list[i].name;
264 or1k_core_reg_list_arch_info[i].spr_num = or1k_init_reg_list[i].spr_num;
265 or1k_core_reg_list_arch_info[i].group = or1k_init_reg_list[i].group;
266 or1k_core_reg_list_arch_info[i].feature = or1k_init_reg_list[i].feature;
267 or1k_core_reg_list_arch_info[i].list_num = i;
268 or1k_core_reg_list_arch_info[i].target = NULL;
269 or1k_core_reg_list_arch_info[i].or1k_common = NULL;
270 }
271
272 or1k->nb_regs = ARRAY_SIZE(or1k_init_reg_list);
273
274 struct or1k_core_reg new_reg;
275 new_reg.target = NULL;
276 new_reg.or1k_common = NULL;
277
278 char name[32];
279 for (int way = 0; way < 4; way++) {
280 for (int i = 0; i < 128; i++) {
281
282 sprintf(name, "dtlbw%dmr%d", way, i);
283 new_reg.name = strdup(name);
284 new_reg.spr_num = GROUP1 + 512 + i + (way * 256);
285 new_reg.feature = "org.gnu.gdb.or1k.group1";
286 new_reg.group = "dmmu";
287 or1k_add_reg(target, &new_reg);
288
289 sprintf(name, "dtlbw%dtr%d", way, i);
290 new_reg.name = strdup(name);
291 new_reg.spr_num = GROUP1 + 640 + i + (way * 256);
292 new_reg.feature = "org.gnu.gdb.or1k.group1";
293 new_reg.group = "dmmu";
294 or1k_add_reg(target, &new_reg);
295
296
297 sprintf(name, "itlbw%dmr%d", way, i);
298 new_reg.name = strdup(name);
299 new_reg.spr_num = GROUP2 + 512 + i + (way * 256);
300 new_reg.feature = "org.gnu.gdb.or1k.group2";
301 new_reg.group = "immu";
302 or1k_add_reg(target, &new_reg);
303
304
305 sprintf(name, "itlbw%dtr%d", way, i);
306 new_reg.name = strdup(name);
307 new_reg.spr_num = GROUP2 + 640 + i + (way * 256);
308 new_reg.feature = "org.gnu.gdb.or1k.group2";
309 new_reg.group = "immu";
310 or1k_add_reg(target, &new_reg);
311
312 }
313 }
314
315 return ERROR_OK;
316 }
317
318 static int or1k_jtag_read_regs(struct or1k_common *or1k, uint32_t *regs)
319 {
320 struct or1k_du *du_core = or1k_jtag_to_du(&or1k->jtag);
321
322 LOG_DEBUG("-");
323
324 return du_core->or1k_jtag_read_cpu(&or1k->jtag,
325 or1k->arch_info[OR1K_REG_R0].spr_num, OR1K_REG_R31 + 1,
326 regs + OR1K_REG_R0);
327 }
328
329 static int or1k_jtag_write_regs(struct or1k_common *or1k, uint32_t *regs)
330 {
331 struct or1k_du *du_core = or1k_jtag_to_du(&or1k->jtag);
332
333 LOG_DEBUG("-");
334
335 return du_core->or1k_jtag_write_cpu(&or1k->jtag,
336 or1k->arch_info[OR1K_REG_R0].spr_num, OR1K_REG_R31 + 1,
337 &regs[OR1K_REG_R0]);
338 }
339
340 static int or1k_save_context(struct target *target)
341 {
342 struct or1k_common *or1k = target_to_or1k(target);
343 struct or1k_du *du_core = or1k_to_du(or1k);
344 int regs_read = 0;
345 int retval;
346
347 LOG_DEBUG("-");
348
349 for (int i = 0; i < OR1KNUMCOREREGS; i++) {
350 if (!or1k->core_cache->reg_list[i].valid) {
351 if (i == OR1K_REG_PPC || i == OR1K_REG_NPC || i == OR1K_REG_SR) {
352 retval = du_core->or1k_jtag_read_cpu(&or1k->jtag,
353 or1k->arch_info[i].spr_num, 1,
354 &or1k->core_regs[i]);
355 if (retval != ERROR_OK)
356 return retval;
357 } else if (!regs_read) {
358 /* read gpr registers at once (but only one time in this loop) */
359 retval = or1k_jtag_read_regs(or1k, or1k->core_regs);
360 if (retval != ERROR_OK)
361 return retval;
362 /* prevent next reads in this loop */
363 regs_read = 1;
364 }
365 /* We've just updated the core_reg[i], now update
366 the core cache */
367 or1k_read_core_reg(target, i);
368 }
369 }
370
371 return ERROR_OK;
372 }
373
374 static int or1k_restore_context(struct target *target)
375 {
376 struct or1k_common *or1k = target_to_or1k(target);
377 struct or1k_du *du_core = or1k_to_du(or1k);
378 int reg_write = 0;
379 int retval;
380
381 LOG_DEBUG("-");
382
383 for (int i = 0; i < OR1KNUMCOREREGS; i++) {
384 if (or1k->core_cache->reg_list[i].dirty) {
385 or1k_write_core_reg(target, i);
386
387 if (i == OR1K_REG_PPC || i == OR1K_REG_NPC || i == OR1K_REG_SR) {
388 retval = du_core->or1k_jtag_write_cpu(&or1k->jtag,
389 or1k->arch_info[i].spr_num, 1,
390 &or1k->core_regs[i]);
391 if (retval != ERROR_OK) {
392 LOG_ERROR("Error while restoring context");
393 return retval;
394 }
395 } else
396 reg_write = 1;
397 }
398 }
399
400 if (reg_write) {
401 /* read gpr registers at once (but only one time in this loop) */
402 retval = or1k_jtag_write_regs(or1k, or1k->core_regs);
403 if (retval != ERROR_OK) {
404 LOG_ERROR("Error while restoring context");
405 return retval;
406 }
407 }
408
409 return ERROR_OK;
410 }
411
412 static int or1k_read_core_reg(struct target *target, int num)
413 {
414 struct or1k_common *or1k = target_to_or1k(target);
415 struct or1k_du *du_core = or1k_to_du(or1k);
416 uint32_t reg_value;
417
418 LOG_DEBUG("-");
419
420 if ((num < 0) || (num >= or1k->nb_regs))
421 return ERROR_COMMAND_SYNTAX_ERROR;
422
423 if ((num >= 0) && (num < OR1KNUMCOREREGS)) {
424 reg_value = or1k->core_regs[num];
425 buf_set_u32(or1k->core_cache->reg_list[num].value, 0, 32, reg_value);
426 LOG_DEBUG("Read core reg %i value 0x%08" PRIx32, num , reg_value);
427 or1k->core_cache->reg_list[num].valid = 1;
428 or1k->core_cache->reg_list[num].dirty = 0;
429 } else {
430 /* This is an spr, always read value from HW */
431 int retval = du_core->or1k_jtag_read_cpu(&or1k->jtag,
432 or1k->arch_info[num].spr_num, 1, &reg_value);
433 if (retval != ERROR_OK) {
434 LOG_ERROR("Error while reading spr 0x%08" PRIx32, or1k->arch_info[num].spr_num);
435 return retval;
436 }
437 buf_set_u32(or1k->core_cache->reg_list[num].value, 0, 32, reg_value);
438 LOG_DEBUG("Read spr reg %i value 0x%08" PRIx32, num , reg_value);
439 }
440
441 return ERROR_OK;
442 }
443
444 static int or1k_write_core_reg(struct target *target, int num)
445 {
446 struct or1k_common *or1k = target_to_or1k(target);
447
448 LOG_DEBUG("-");
449
450 if ((num < 0) || (num >= OR1KNUMCOREREGS))
451 return ERROR_COMMAND_SYNTAX_ERROR;
452
453 uint32_t reg_value = buf_get_u32(or1k->core_cache->reg_list[num].value, 0, 32);
454 or1k->core_regs[num] = reg_value;
455 LOG_DEBUG("Write core reg %i value 0x%08" PRIx32, num , reg_value);
456 or1k->core_cache->reg_list[num].valid = 1;
457 or1k->core_cache->reg_list[num].dirty = 0;
458
459 return ERROR_OK;
460 }
461
462 static int or1k_get_core_reg(struct reg *reg)
463 {
464 struct or1k_core_reg *or1k_reg = reg->arch_info;
465 struct target *target = or1k_reg->target;
466
467 LOG_DEBUG("-");
468
469 if (target->state != TARGET_HALTED)
470 return ERROR_TARGET_NOT_HALTED;
471
472 return or1k_read_core_reg(target, or1k_reg->list_num);
473 }
474
475 static int or1k_set_core_reg(struct reg *reg, uint8_t *buf)
476 {
477 struct or1k_core_reg *or1k_reg = reg->arch_info;
478 struct target *target = or1k_reg->target;
479 struct or1k_common *or1k = target_to_or1k(target);
480 struct or1k_du *du_core = or1k_to_du(or1k);
481 uint32_t value = buf_get_u32(buf, 0, 32);
482
483 LOG_DEBUG("-");
484
485 if (target->state != TARGET_HALTED)
486 return ERROR_TARGET_NOT_HALTED;
487
488 if (or1k_reg->list_num < OR1KNUMCOREREGS) {
489 buf_set_u32(reg->value, 0, 32, value);
490 reg->dirty = 1;
491 reg->valid = 1;
492 } else {
493 /* This is an spr, write it to the HW */
494 int retval = du_core->or1k_jtag_write_cpu(&or1k->jtag,
495 or1k_reg->spr_num, 1, &value);
496 if (retval != ERROR_OK) {
497 LOG_ERROR("Error while writing spr 0x%08" PRIx32, or1k_reg->spr_num);
498 return retval;
499 }
500 }
501
502 return ERROR_OK;
503 }
504
505 static const struct reg_arch_type or1k_reg_type = {
506 .get = or1k_get_core_reg,
507 .set = or1k_set_core_reg,
508 };
509
510 static struct reg_cache *or1k_build_reg_cache(struct target *target)
511 {
512 struct or1k_common *or1k = target_to_or1k(target);
513 struct reg_cache **cache_p = register_get_last_cache_p(&target->reg_cache);
514 struct reg_cache *cache = malloc(sizeof(struct reg_cache));
515 struct reg *reg_list = calloc(or1k->nb_regs, sizeof(struct reg));
516 struct or1k_core_reg *arch_info =
517 malloc((or1k->nb_regs) * sizeof(struct or1k_core_reg));
518 struct reg_feature *feature;
519
520 LOG_DEBUG("-");
521
522 /* Build the process context cache */
523 cache->name = "OpenRISC 1000 registers";
524 cache->next = NULL;
525 cache->reg_list = reg_list;
526 cache->num_regs = or1k->nb_regs;
527 (*cache_p) = cache;
528 or1k->core_cache = cache;
529 or1k->arch_info = arch_info;
530
531 for (int i = 0; i < or1k->nb_regs; i++) {
532 arch_info[i] = or1k_core_reg_list_arch_info[i];
533 arch_info[i].target = target;
534 arch_info[i].or1k_common = or1k;
535 reg_list[i].name = or1k_core_reg_list_arch_info[i].name;
536
537 feature = malloc(sizeof(struct reg_feature));
538 feature->name = or1k_core_reg_list_arch_info[i].feature;
539 reg_list[i].feature = feature;
540
541 reg_list[i].group = or1k_core_reg_list_arch_info[i].group;
542 reg_list[i].size = 32;
543 reg_list[i].value = calloc(1, 4);
544 reg_list[i].dirty = 0;
545 reg_list[i].valid = 0;
546 reg_list[i].type = &or1k_reg_type;
547 reg_list[i].arch_info = &arch_info[i];
548 reg_list[i].number = i;
549 reg_list[i].exist = true;
550 }
551
552 return cache;
553 }
554
555 static int or1k_debug_entry(struct target *target)
556 {
557 LOG_DEBUG("-");
558
559 int retval = or1k_save_context(target);
560 if (retval != ERROR_OK) {
561 LOG_ERROR("Error while calling or1k_save_context");
562 return retval;
563 }
564
565 struct or1k_common *or1k = target_to_or1k(target);
566 uint32_t addr = or1k->core_regs[OR1K_REG_NPC];
567
568 if (breakpoint_find(target, addr))
569 /* Halted on a breakpoint, step back to permit executing the instruction there */
570 retval = or1k_set_core_reg(&or1k->core_cache->reg_list[OR1K_REG_NPC],
571 (uint8_t *)&addr);
572
573 return retval;
574 }
575
576 static int or1k_halt(struct target *target)
577 {
578 struct or1k_common *or1k = target_to_or1k(target);
579 struct or1k_du *du_core = or1k_to_du(or1k);
580
581 LOG_DEBUG("target->state: %s",
582 target_state_name(target));
583
584 if (target->state == TARGET_HALTED) {
585 LOG_DEBUG("Target was already halted");
586 return ERROR_OK;
587 }
588
589 if (target->state == TARGET_UNKNOWN)
590 LOG_WARNING("Target was in unknown state when halt was requested");
591
592 if (target->state == TARGET_RESET) {
593 if ((jtag_get_reset_config() & RESET_SRST_PULLS_TRST) &&
594 jtag_get_srst()) {
595 LOG_ERROR("Can't request a halt while in reset if nSRST pulls nTRST");
596 return ERROR_TARGET_FAILURE;
597 } else {
598 target->debug_reason = DBG_REASON_DBGRQ;
599 return ERROR_OK;
600 }
601 }
602
603 int retval = du_core->or1k_cpu_stall(&or1k->jtag, CPU_STALL);
604 if (retval != ERROR_OK) {
605 LOG_ERROR("Impossible to stall the CPU");
606 return retval;
607 }
608
609 target->debug_reason = DBG_REASON_DBGRQ;
610
611 return ERROR_OK;
612 }
613
614 static int or1k_is_cpu_running(struct target *target, int *running)
615 {
616 struct or1k_common *or1k = target_to_or1k(target);
617 struct or1k_du *du_core = or1k_to_du(or1k);
618 int retval;
619 int tries = 0;
620 const int RETRIES_MAX = 5;
621
622 /* Have a retry loop to determine of the CPU is running.
623 If target has been hard reset for any reason, it might take a couple
624 of goes before it's ready again.
625 */
626 while (tries < RETRIES_MAX) {
627
628 tries++;
629
630 retval = du_core->or1k_is_cpu_running(&or1k->jtag, running);
631 if (retval != ERROR_OK) {
632 LOG_WARNING("Debug IF CPU control reg read failure.");
633 /* Try once to restart the JTAG infrastructure -
634 quite possibly the board has just been reset. */
635 LOG_WARNING("Resetting JTAG TAP state and reconnectiong to debug IF.");
636 du_core->or1k_jtag_init(&or1k->jtag);
637
638 LOG_WARNING("...attempt %d of %d", tries, RETRIES_MAX);
639
640 alive_sleep(2);
641
642 continue;
643 } else
644 return ERROR_OK;
645 }
646
647 LOG_ERROR("Could not re-establish communication with target");
648 return retval;
649 }
650
651 static int or1k_poll(struct target *target)
652 {
653 int retval;
654 int running;
655
656 retval = or1k_is_cpu_running(target, &running);
657 if (retval != ERROR_OK) {
658 LOG_ERROR("Error while calling or1k_is_cpu_running");
659 return retval;
660 }
661
662 /* check for processor halted */
663 if (!running) {
664 /* It's actually stalled, so update our software's state */
665 if ((target->state == TARGET_RUNNING) ||
666 (target->state == TARGET_RESET)) {
667
668 target->state = TARGET_HALTED;
669
670 retval = or1k_debug_entry(target);
671 if (retval != ERROR_OK) {
672 LOG_ERROR("Error while calling or1k_debug_entry");
673 return retval;
674 }
675
676 target_call_event_callbacks(target,
677 TARGET_EVENT_HALTED);
678 } else if (target->state == TARGET_DEBUG_RUNNING) {
679 target->state = TARGET_HALTED;
680
681 retval = or1k_debug_entry(target);
682 if (retval != ERROR_OK) {
683 LOG_ERROR("Error while calling or1k_debug_entry");
684 return retval;
685 }
686
687 target_call_event_callbacks(target,
688 TARGET_EVENT_DEBUG_HALTED);
689 }
690 } else { /* ... target is running */
691
692 /* If target was supposed to be stalled, stall it again */
693 if (target->state == TARGET_HALTED) {
694
695 target->state = TARGET_RUNNING;
696
697 retval = or1k_halt(target);
698 if (retval != ERROR_OK) {
699 LOG_ERROR("Error while calling or1k_halt");
700 return retval;
701 }
702
703 retval = or1k_debug_entry(target);
704 if (retval != ERROR_OK) {
705 LOG_ERROR("Error while calling or1k_debug_entry");
706 return retval;
707 }
708
709 target_call_event_callbacks(target,
710 TARGET_EVENT_DEBUG_HALTED);
711 }
712
713 target->state = TARGET_RUNNING;
714
715 }
716
717 return ERROR_OK;
718 }
719
720 static int or1k_assert_reset(struct target *target)
721 {
722 struct or1k_common *or1k = target_to_or1k(target);
723 struct or1k_du *du_core = or1k_to_du(or1k);
724
725 LOG_DEBUG("-");
726
727 int retval = du_core->or1k_cpu_reset(&or1k->jtag, CPU_RESET);
728 if (retval != ERROR_OK) {
729 LOG_ERROR("Error while asserting RESET");
730 return retval;
731 }
732
733 return ERROR_OK;
734 }
735
736 static int or1k_deassert_reset(struct target *target)
737 {
738 struct or1k_common *or1k = target_to_or1k(target);
739 struct or1k_du *du_core = or1k_to_du(or1k);
740
741 LOG_DEBUG("-");
742
743 int retval = du_core->or1k_cpu_reset(&or1k->jtag, CPU_NOT_RESET);
744 if (retval != ERROR_OK) {
745 LOG_ERROR("Error while desasserting RESET");
746 return retval;
747 }
748
749 return ERROR_OK;
750 }
751
752 static int or1k_soft_reset_halt(struct target *target)
753 {
754 struct or1k_common *or1k = target_to_or1k(target);
755 struct or1k_du *du_core = or1k_to_du(or1k);
756
757 LOG_DEBUG("-");
758
759 int retval = du_core->or1k_cpu_stall(&or1k->jtag, CPU_STALL);
760 if (retval != ERROR_OK) {
761 LOG_ERROR("Error while stalling the CPU");
762 return retval;
763 }
764
765 retval = or1k_assert_reset(target);
766 if (retval != ERROR_OK)
767 return retval;
768
769 retval = or1k_deassert_reset(target);
770 if (retval != ERROR_OK)
771 return retval;
772
773 return ERROR_OK;
774 }
775
776 static bool is_any_soft_breakpoint(struct target *target)
777 {
778 struct breakpoint *breakpoint = target->breakpoints;
779
780 LOG_DEBUG("-");
781
782 while (breakpoint)
783 if (breakpoint->type == BKPT_SOFT)
784 return true;
785
786 return false;
787 }
788
789 static int or1k_resume_or_step(struct target *target, int current,
790 uint32_t address, int handle_breakpoints,
791 int debug_execution, int step)
792 {
793 struct or1k_common *or1k = target_to_or1k(target);
794 struct or1k_du *du_core = or1k_to_du(or1k);
795 struct breakpoint *breakpoint = NULL;
796 uint32_t resume_pc;
797 uint32_t debug_reg_list[OR1K_DEBUG_REG_NUM];
798
799 LOG_DEBUG("Addr: 0x%" PRIx32 ", stepping: %s, handle breakpoints %s\n",
800 address, step ? "yes" : "no", handle_breakpoints ? "yes" : "no");
801
802 if (target->state != TARGET_HALTED) {
803 LOG_ERROR("Target not halted");
804 return ERROR_TARGET_NOT_HALTED;
805 }
806
807 if (!debug_execution)
808 target_free_all_working_areas(target);
809
810 /* current ? continue on current pc : continue at <address> */
811 if (!current)
812 buf_set_u32(or1k->core_cache->reg_list[OR1K_REG_NPC].value, 0,
813 32, address);
814
815 int retval = or1k_restore_context(target);
816 if (retval != ERROR_OK) {
817 LOG_ERROR("Error while calling or1k_restore_context");
818 return retval;
819 }
820
821 /* read debug registers (starting from DMR1 register) */
822 retval = du_core->or1k_jtag_read_cpu(&or1k->jtag, OR1K_DMR1_CPU_REG_ADD,
823 OR1K_DEBUG_REG_NUM, debug_reg_list);
824 if (retval != ERROR_OK) {
825 LOG_ERROR("Error while reading debug registers");
826 return retval;
827 }
828
829 /* Clear Debug Reason Register (DRR) */
830 debug_reg_list[OR1K_DEBUG_REG_DRR] = 0;
831
832 /* Clear watchpoint break generation in Debug Mode Register 2 (DMR2) */
833 debug_reg_list[OR1K_DEBUG_REG_DMR2] &= ~OR1K_DMR2_WGB;
834 if (step)
835 /* Set the single step trigger in Debug Mode Register 1 (DMR1) */
836 debug_reg_list[OR1K_DEBUG_REG_DMR1] |= OR1K_DMR1_ST | OR1K_DMR1_BT;
837 else
838 /* Clear the single step trigger in Debug Mode Register 1 (DMR1) */
839 debug_reg_list[OR1K_DEBUG_REG_DMR1] &= ~(OR1K_DMR1_ST | OR1K_DMR1_BT);
840
841 /* Set traps to be handled by the debug unit in the Debug Stop
842 Register (DSR). Check if we have any software breakpoints in
843 place before setting this value - the kernel, for instance,
844 relies on l.trap instructions not stalling the processor ! */
845 if (is_any_soft_breakpoint(target) == true)
846 debug_reg_list[OR1K_DEBUG_REG_DSR] |= OR1K_DSR_TE;
847
848 /* Write debug registers (starting from DMR1 register) */
849 retval = du_core->or1k_jtag_write_cpu(&or1k->jtag, OR1K_DMR1_CPU_REG_ADD,
850 OR1K_DEBUG_REG_NUM, debug_reg_list);
851 if (retval != ERROR_OK) {
852 LOG_ERROR("Error while writing back debug registers");
853 return retval;
854 }
855
856 resume_pc = buf_get_u32(or1k->core_cache->reg_list[OR1K_REG_NPC].value,
857 0, 32);
858
859 /* The front-end may request us not to handle breakpoints */
860 if (handle_breakpoints) {
861 /* Single step past breakpoint at current address */
862 breakpoint = breakpoint_find(target, resume_pc);
863 if (breakpoint) {
864 LOG_DEBUG("Unset breakpoint at 0x%08" TARGET_PRIxADDR, breakpoint->address);
865 retval = or1k_remove_breakpoint(target, breakpoint);
866 if (retval != ERROR_OK)
867 return retval;
868 }
869 }
870
871 /* Unstall time */
872 retval = du_core->or1k_cpu_stall(&or1k->jtag, CPU_UNSTALL);
873 if (retval != ERROR_OK) {
874 LOG_ERROR("Error while unstalling the CPU");
875 return retval;
876 }
877
878 if (step)
879 target->debug_reason = DBG_REASON_SINGLESTEP;
880 else
881 target->debug_reason = DBG_REASON_NOTHALTED;
882
883 /* Registers are now invalid */
884 register_cache_invalidate(or1k->core_cache);
885
886 if (!debug_execution) {
887 target->state = TARGET_RUNNING;
888 target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
889 LOG_DEBUG("Target resumed at 0x%08" PRIx32, resume_pc);
890 } else {
891 target->state = TARGET_DEBUG_RUNNING;
892 target_call_event_callbacks(target, TARGET_EVENT_DEBUG_RESUMED);
893 LOG_DEBUG("Target debug resumed at 0x%08" PRIx32, resume_pc);
894 }
895
896 return ERROR_OK;
897 }
898
899 static int or1k_resume(struct target *target, int current,
900 target_addr_t address, int handle_breakpoints,
901 int debug_execution)
902 {
903 return or1k_resume_or_step(target, current, address,
904 handle_breakpoints,
905 debug_execution,
906 NO_SINGLE_STEP);
907 }
908
909 static int or1k_step(struct target *target, int current,
910 target_addr_t address, int handle_breakpoints)
911 {
912 return or1k_resume_or_step(target, current, address,
913 handle_breakpoints,
914 0,
915 SINGLE_STEP);
916
917 }
918
919 static int or1k_add_breakpoint(struct target *target,
920 struct breakpoint *breakpoint)
921 {
922 struct or1k_common *or1k = target_to_or1k(target);
923 struct or1k_du *du_core = or1k_to_du(or1k);
924 uint8_t data;
925
926 LOG_DEBUG("Adding breakpoint: addr 0x%08" TARGET_PRIxADDR ", len %d, type %d, set: %d, id: %" PRId32,
927 breakpoint->address, breakpoint->length, breakpoint->type,
928 breakpoint->set, breakpoint->unique_id);
929
930 /* Only support SW breakpoints for now. */
931 if (breakpoint->type == BKPT_HARD)
932 LOG_ERROR("HW breakpoints not supported for now. Doing SW breakpoint.");
933
934 /* Read and save the instruction */
935 int retval = du_core->or1k_jtag_read_memory(&or1k->jtag,
936 breakpoint->address,
937 4,
938 1,
939 &data);
940 if (retval != ERROR_OK) {
941 LOG_ERROR("Error while reading the instruction at 0x%08" TARGET_PRIxADDR,
942 breakpoint->address);
943 return retval;
944 }
945
946 if (breakpoint->orig_instr != NULL)
947 free(breakpoint->orig_instr);
948
949 breakpoint->orig_instr = malloc(breakpoint->length);
950 memcpy(breakpoint->orig_instr, &data, breakpoint->length);
951
952 /* Sub in the OR1K trap instruction */
953 uint8_t or1k_trap_insn[4];
954 target_buffer_set_u32(target, or1k_trap_insn, OR1K_TRAP_INSTR);
955 retval = du_core->or1k_jtag_write_memory(&or1k->jtag,
956 breakpoint->address,
957 4,
958 1,
959 or1k_trap_insn);
960
961 if (retval != ERROR_OK) {
962 LOG_ERROR("Error while writing OR1K_TRAP_INSTR at 0x%08" TARGET_PRIxADDR,
963 breakpoint->address);
964 return retval;
965 }
966
967 /* invalidate instruction cache */
968 uint32_t addr = breakpoint->address;
969 retval = du_core->or1k_jtag_write_cpu(&or1k->jtag,
970 OR1K_ICBIR_CPU_REG_ADD, 1, &addr);
971 if (retval != ERROR_OK) {
972 LOG_ERROR("Error while invalidating the ICACHE");
973 return retval;
974 }
975
976 return ERROR_OK;
977 }
978
979 static int or1k_remove_breakpoint(struct target *target,
980 struct breakpoint *breakpoint)
981 {
982 struct or1k_common *or1k = target_to_or1k(target);
983 struct or1k_du *du_core = or1k_to_du(or1k);
984
985 LOG_DEBUG("Removing breakpoint: addr 0x%08" TARGET_PRIxADDR ", len %d, type %d, set: %d, id: %" PRId32,
986 breakpoint->address, breakpoint->length, breakpoint->type,
987 breakpoint->set, breakpoint->unique_id);
988
989 /* Only support SW breakpoints for now. */
990 if (breakpoint->type == BKPT_HARD)
991 LOG_ERROR("HW breakpoints not supported for now. Doing SW breakpoint.");
992
993 /* Replace the removed instruction */
994 int retval = du_core->or1k_jtag_write_memory(&or1k->jtag,
995 breakpoint->address,
996 4,
997 1,
998 breakpoint->orig_instr);
999
1000 if (retval != ERROR_OK) {
1001 LOG_ERROR("Error while writing back the instruction at 0x%08" TARGET_PRIxADDR,
1002 breakpoint->address);
1003 return retval;
1004 }
1005
1006 /* invalidate instruction cache */
1007 uint32_t addr = breakpoint->address;
1008 retval = du_core->or1k_jtag_write_cpu(&or1k->jtag,
1009 OR1K_ICBIR_CPU_REG_ADD, 1, &addr);
1010 if (retval != ERROR_OK) {
1011 LOG_ERROR("Error while invalidating the ICACHE");
1012 return retval;
1013 }
1014
1015 return ERROR_OK;
1016 }
1017
1018 static int or1k_add_watchpoint(struct target *target,
1019 struct watchpoint *watchpoint)
1020 {
1021 LOG_ERROR("%s: implement me", __func__);
1022 return ERROR_OK;
1023 }
1024
1025 static int or1k_remove_watchpoint(struct target *target,
1026 struct watchpoint *watchpoint)
1027 {
1028 LOG_ERROR("%s: implement me", __func__);
1029 return ERROR_OK;
1030 }
1031
1032 static int or1k_read_memory(struct target *target, target_addr_t address,
1033 uint32_t size, uint32_t count, uint8_t *buffer)
1034 {
1035 struct or1k_common *or1k = target_to_or1k(target);
1036 struct or1k_du *du_core = or1k_to_du(or1k);
1037
1038 LOG_DEBUG("Read memory at 0x%08" TARGET_PRIxADDR ", size: %" PRIu32 ", count: 0x%08" PRIx32, address, size, count);
1039
1040 if (target->state != TARGET_HALTED) {
1041 LOG_ERROR("Target not halted");
1042 return ERROR_TARGET_NOT_HALTED;
1043 }
1044
1045 /* Sanitize arguments */
1046 if (((size != 4) && (size != 2) && (size != 1)) || (count == 0) || !buffer) {
1047 LOG_ERROR("Bad arguments");
1048 return ERROR_COMMAND_SYNTAX_ERROR;
1049 }
1050
1051 if (((size == 4) && (address & 0x3u)) || ((size == 2) && (address & 0x1u))) {
1052 LOG_ERROR("Can't handle unaligned memory access");
1053 return ERROR_TARGET_UNALIGNED_ACCESS;
1054 }
1055
1056 return du_core->or1k_jtag_read_memory(&or1k->jtag, address, size, count, buffer);
1057 }
1058
1059 static int or1k_write_memory(struct target *target, target_addr_t address,
1060 uint32_t size, uint32_t count, const uint8_t *buffer)
1061 {
1062 struct or1k_common *or1k = target_to_or1k(target);
1063 struct or1k_du *du_core = or1k_to_du(or1k);
1064
1065 LOG_DEBUG("Write memory at 0x%08" TARGET_PRIxADDR ", size: %" PRIu32 ", count: 0x%08" PRIx32, address, size, count);
1066
1067 if (target->state != TARGET_HALTED) {
1068 LOG_WARNING("Target not halted");
1069 return ERROR_TARGET_NOT_HALTED;
1070 }
1071
1072 /* Sanitize arguments */
1073 if (((size != 4) && (size != 2) && (size != 1)) || (count == 0) || !buffer) {
1074 LOG_ERROR("Bad arguments");
1075 return ERROR_COMMAND_SYNTAX_ERROR;
1076 }
1077
1078 if (((size == 4) && (address & 0x3u)) || ((size == 2) && (address & 0x1u))) {
1079 LOG_ERROR("Can't handle unaligned memory access");
1080 return ERROR_TARGET_UNALIGNED_ACCESS;
1081 }
1082
1083 return du_core->or1k_jtag_write_memory(&or1k->jtag, address, size, count, buffer);
1084 }
1085
1086 static int or1k_init_target(struct command_context *cmd_ctx,
1087 struct target *target)
1088 {
1089 struct or1k_common *or1k = target_to_or1k(target);
1090 struct or1k_du *du_core = or1k_to_du(or1k);
1091 struct or1k_jtag *jtag = &or1k->jtag;
1092
1093 if (du_core == NULL) {
1094 LOG_ERROR("No debug unit selected");
1095 return ERROR_FAIL;
1096 }
1097
1098 if (jtag->tap_ip == NULL) {
1099 LOG_ERROR("No tap selected");
1100 return ERROR_FAIL;
1101 }
1102
1103 or1k->jtag.tap = target->tap;
1104 or1k->jtag.or1k_jtag_inited = 0;
1105 or1k->jtag.or1k_jtag_module_selected = -1;
1106 or1k->jtag.target = target;
1107
1108 or1k_build_reg_cache(target);
1109
1110 return ERROR_OK;
1111 }
1112
1113 static int or1k_target_create(struct target *target, Jim_Interp *interp)
1114 {
1115 if (target->tap == NULL)
1116 return ERROR_FAIL;
1117
1118 struct or1k_common *or1k = calloc(1, sizeof(struct or1k_common));
1119
1120 target->arch_info = or1k;
1121
1122 or1k_create_reg_list(target);
1123
1124 or1k_tap_vjtag_register();
1125 or1k_tap_xilinx_bscan_register();
1126 or1k_tap_mohor_register();
1127
1128 or1k_du_adv_register();
1129
1130 return ERROR_OK;
1131 }
1132
1133 static int or1k_examine(struct target *target)
1134 {
1135 struct or1k_common *or1k = target_to_or1k(target);
1136 struct or1k_du *du_core = or1k_to_du(or1k);
1137
1138 if (!target_was_examined(target)) {
1139
1140 target_set_examined(target);
1141
1142 int running;
1143
1144 int retval = du_core->or1k_is_cpu_running(&or1k->jtag, &running);
1145 if (retval != ERROR_OK) {
1146 LOG_ERROR("Couldn't read the CPU state");
1147 return retval;
1148 } else {
1149 if (running)
1150 target->state = TARGET_RUNNING;
1151 else {
1152 LOG_DEBUG("Target is halted");
1153
1154 /* This is the first time we examine the target,
1155 * it is stalled and we don't know why. Let's
1156 * assume this is because of a debug reason.
1157 */
1158 if (target->state == TARGET_UNKNOWN)
1159 target->debug_reason = DBG_REASON_DBGRQ;
1160
1161 target->state = TARGET_HALTED;
1162 }
1163 }
1164 }
1165
1166 return ERROR_OK;
1167 }
1168
1169 static int or1k_arch_state(struct target *target)
1170 {
1171 return ERROR_OK;
1172 }
1173
1174 static int or1k_get_gdb_reg_list(struct target *target, struct reg **reg_list[],
1175 int *reg_list_size, enum target_register_class reg_class)
1176 {
1177 struct or1k_common *or1k = target_to_or1k(target);
1178
1179 if (reg_class == REG_CLASS_GENERAL) {
1180 /* We will have this called whenever GDB connects. */
1181 int retval = or1k_save_context(target);
1182 if (retval != ERROR_OK) {
1183 LOG_ERROR("Error while calling or1k_save_context");
1184 return retval;
1185 }
1186 *reg_list_size = OR1KNUMCOREREGS;
1187 /* this is free()'d back in gdb_server.c's gdb_get_register_packet() */
1188 *reg_list = malloc((*reg_list_size) * sizeof(struct reg *));
1189
1190 for (int i = 0; i < OR1KNUMCOREREGS; i++)
1191 (*reg_list)[i] = &or1k->core_cache->reg_list[i];
1192 } else {
1193 *reg_list_size = or1k->nb_regs;
1194 *reg_list = malloc((*reg_list_size) * sizeof(struct reg *));
1195
1196 for (int i = 0; i < or1k->nb_regs; i++)
1197 (*reg_list)[i] = &or1k->core_cache->reg_list[i];
1198 }
1199
1200 return ERROR_OK;
1201
1202 }
1203
1204 int or1k_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fileio_info)
1205 {
1206 return ERROR_FAIL;
1207 }
1208
1209 static int or1k_checksum_memory(struct target *target, target_addr_t address,
1210 uint32_t count, uint32_t *checksum) {
1211
1212 return ERROR_FAIL;
1213 }
1214
1215 static int or1k_profiling(struct target *target, uint32_t *samples,
1216 uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
1217 {
1218 struct timeval timeout, now;
1219 struct or1k_common *or1k = target_to_or1k(target);
1220 struct or1k_du *du_core = or1k_to_du(or1k);
1221 int retval = ERROR_OK;
1222
1223 gettimeofday(&timeout, NULL);
1224 timeval_add_time(&timeout, seconds, 0);
1225
1226 LOG_INFO("Starting or1k profiling. Sampling npc as fast as we can...");
1227
1228 /* Make sure the target is running */
1229 target_poll(target);
1230 if (target->state == TARGET_HALTED)
1231 retval = target_resume(target, 1, 0, 0, 0);
1232
1233 if (retval != ERROR_OK) {
1234 LOG_ERROR("Error while resuming target");
1235 return retval;
1236 }
1237
1238 uint32_t sample_count = 0;
1239
1240 for (;;) {
1241 uint32_t reg_value;
1242 retval = du_core->or1k_jtag_read_cpu(&or1k->jtag, GROUP0 + 16 /* NPC */, 1, &reg_value);
1243 if (retval != ERROR_OK) {
1244 LOG_ERROR("Error while reading NPC");
1245 return retval;
1246 }
1247
1248 samples[sample_count++] = reg_value;
1249
1250 gettimeofday(&now, NULL);
1251 if ((sample_count >= max_num_samples) || timeval_compare(&now, &timeout) > 0) {
1252 LOG_INFO("Profiling completed. %" PRIu32 " samples.", sample_count);
1253 break;
1254 }
1255 }
1256
1257 *num_samples = sample_count;
1258 return retval;
1259 }
1260
1261 COMMAND_HANDLER(or1k_tap_select_command_handler)
1262 {
1263 struct target *target = get_current_target(CMD_CTX);
1264 struct or1k_common *or1k = target_to_or1k(target);
1265 struct or1k_jtag *jtag = &or1k->jtag;
1266 struct or1k_tap_ip *or1k_tap;
1267
1268 if (CMD_ARGC != 1)
1269 return ERROR_COMMAND_SYNTAX_ERROR;
1270
1271 list_for_each_entry(or1k_tap, &tap_list, list) {
1272 if (or1k_tap->name) {
1273 if (!strcmp(CMD_ARGV[0], or1k_tap->name)) {
1274 jtag->tap_ip = or1k_tap;
1275 LOG_INFO("%s tap selected", or1k_tap->name);
1276 return ERROR_OK;
1277 }
1278 }
1279 }
1280
1281 LOG_ERROR("%s unknown, no tap selected", CMD_ARGV[0]);
1282 return ERROR_COMMAND_SYNTAX_ERROR;
1283 }
1284
1285 COMMAND_HANDLER(or1k_tap_list_command_handler)
1286 {
1287 struct or1k_tap_ip *or1k_tap;
1288
1289 if (CMD_ARGC != 0)
1290 return ERROR_COMMAND_SYNTAX_ERROR;
1291
1292 list_for_each_entry(or1k_tap, &tap_list, list) {
1293 if (or1k_tap->name)
1294 command_print(CMD_CTX, "%s", or1k_tap->name);
1295 }
1296
1297 return ERROR_OK;
1298 }
1299
1300 COMMAND_HANDLER(or1k_du_select_command_handler)
1301 {
1302 struct target *target = get_current_target(CMD_CTX);
1303 struct or1k_common *or1k = target_to_or1k(target);
1304 struct or1k_jtag *jtag = &or1k->jtag;
1305 struct or1k_du *or1k_du;
1306
1307 if (CMD_ARGC > 2)
1308 return ERROR_COMMAND_SYNTAX_ERROR;
1309
1310 list_for_each_entry(or1k_du, &du_list, list) {
1311 if (or1k_du->name) {
1312 if (!strcmp(CMD_ARGV[0], or1k_du->name)) {
1313 jtag->du_core = or1k_du;
1314 LOG_INFO("%s debug unit selected", or1k_du->name);
1315
1316 if (CMD_ARGC == 2) {
1317 int options;
1318 COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], options);
1319 or1k_du->options = options;
1320 LOG_INFO("Option %x is passed to %s debug unit"
1321 , options, or1k_du->name);
1322 }
1323
1324 return ERROR_OK;
1325 }
1326 }
1327 }
1328
1329 LOG_ERROR("%s unknown, no debug unit selected", CMD_ARGV[0]);
1330 return ERROR_COMMAND_SYNTAX_ERROR;
1331 }
1332
1333 COMMAND_HANDLER(or1k_du_list_command_handler)
1334 {
1335 struct or1k_du *or1k_du;
1336
1337 if (CMD_ARGC != 0)
1338 return ERROR_COMMAND_SYNTAX_ERROR;
1339
1340 list_for_each_entry(or1k_du, &du_list, list) {
1341 if (or1k_du->name)
1342 command_print(CMD_CTX, "%s", or1k_du->name);
1343 }
1344
1345 return ERROR_OK;
1346 }
1347
1348 COMMAND_HANDLER(or1k_addreg_command_handler)
1349 {
1350 struct target *target = get_current_target(CMD_CTX);
1351 struct or1k_core_reg new_reg;
1352
1353 if (CMD_ARGC != 4)
1354 return ERROR_COMMAND_SYNTAX_ERROR;
1355
1356 new_reg.target = NULL;
1357 new_reg.or1k_common = NULL;
1358
1359 uint32_t addr;
1360 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
1361
1362 new_reg.name = strdup(CMD_ARGV[0]);
1363 new_reg.spr_num = addr;
1364 new_reg.feature = strdup(CMD_ARGV[2]);
1365 new_reg.group = strdup(CMD_ARGV[3]);
1366
1367 or1k_add_reg(target, &new_reg);
1368
1369 LOG_DEBUG("Add reg \"%s\" @ 0x%08" PRIx32 ", group \"%s\", feature \"%s\"",
1370 new_reg.name, addr, new_reg.group, new_reg.feature);
1371
1372 return ERROR_OK;
1373 }
1374
1375 static const struct command_registration or1k_hw_ip_command_handlers[] = {
1376 {
1377 "tap_select",
1378 .handler = or1k_tap_select_command_handler,
1379 .mode = COMMAND_ANY,
1380 .usage = "tap_select name",
1381 .help = "Select the TAP core to use",
1382 },
1383 {
1384 "tap_list",
1385 .handler = or1k_tap_list_command_handler,
1386 .mode = COMMAND_ANY,
1387 .usage = "tap_list",
1388 .help = "Display available TAP core",
1389 },
1390 {
1391 "du_select",
1392 .handler = or1k_du_select_command_handler,
1393 .mode = COMMAND_ANY,
1394 .usage = "du_select name",
1395 .help = "Select the Debug Unit core to use",
1396 },
1397 {
1398 "du_list",
1399 .handler = or1k_du_list_command_handler,
1400 .mode = COMMAND_ANY,
1401 .usage = "select_tap name",
1402 .help = "Display available Debug Unit core",
1403 },
1404 COMMAND_REGISTRATION_DONE
1405 };
1406
1407 static const struct command_registration or1k_reg_command_handlers[] = {
1408 {
1409 "addreg",
1410 .handler = or1k_addreg_command_handler,
1411 .mode = COMMAND_ANY,
1412 .usage = "addreg name addr feature group",
1413 .help = "Add a register to the register list",
1414 },
1415 COMMAND_REGISTRATION_DONE
1416 };
1417
1418 static const struct command_registration or1k_command_handlers[] = {
1419 {
1420 .chain = or1k_reg_command_handlers,
1421 },
1422 {
1423 .chain = or1k_hw_ip_command_handlers,
1424 },
1425 COMMAND_REGISTRATION_DONE
1426 };
1427
1428
1429 struct target_type or1k_target = {
1430 .name = "or1k",
1431
1432 .poll = or1k_poll,
1433 .arch_state = or1k_arch_state,
1434
1435 .target_request_data = NULL,
1436
1437 .halt = or1k_halt,
1438 .resume = or1k_resume,
1439 .step = or1k_step,
1440
1441 .assert_reset = or1k_assert_reset,
1442 .deassert_reset = or1k_deassert_reset,
1443 .soft_reset_halt = or1k_soft_reset_halt,
1444
1445 .get_gdb_reg_list = or1k_get_gdb_reg_list,
1446
1447 .read_memory = or1k_read_memory,
1448 .write_memory = or1k_write_memory,
1449 .checksum_memory = or1k_checksum_memory,
1450
1451 .commands = or1k_command_handlers,
1452 .add_breakpoint = or1k_add_breakpoint,
1453 .remove_breakpoint = or1k_remove_breakpoint,
1454 .add_watchpoint = or1k_add_watchpoint,
1455 .remove_watchpoint = or1k_remove_watchpoint,
1456
1457 .target_create = or1k_target_create,
1458 .init_target = or1k_init_target,
1459 .examine = or1k_examine,
1460
1461 .get_gdb_fileio_info = or1k_get_gdb_fileio_info,
1462
1463 .profiling = or1k_profiling,
1464 };
Open On-Chip Debugger

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)