?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target/cortex_m: minor refactoring in cortex_m_store_core_reg_u32()
[openocd.git] / src / target / arm_cti.c
blobc776e9c2a5c35e967b87e494e4c8f74321eef8db
1 /***************************************************************************
2 * Copyright (C) 2016 by Matthias Welwarsky *
3 * *
4 * This program is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
8 * *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
13 * *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program; if not, write to the *
16 * Free Software Foundation, Inc., *
17 * *
18 ***************************************************************************/
19
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include <stdlib.h>
25 #include <stdint.h>
26 #include "target/arm_adi_v5.h"
27 #include "target/arm_cti.h"
28 #include "target/target.h"
29 #include "helper/time_support.h"
30 #include "helper/list.h"
31 #include "helper/command.h"
32
33 struct arm_cti {
34 struct list_head lh;
35 char *name;
36 struct adiv5_mem_ap_spot spot;
37 };
38
39 static LIST_HEAD(all_cti);
40
41 const char *arm_cti_name(struct arm_cti *self)
42 {
43 return self->name;
44 }
45
46 struct arm_cti *cti_instance_by_jim_obj(Jim_Interp *interp, Jim_Obj *o)
47 {
48 struct arm_cti *obj = NULL;
49 const char *name;
50 bool found = false;
51
52 name = Jim_GetString(o, NULL);
53
54 list_for_each_entry(obj, &all_cti, lh) {
55 if (!strcmp(name, obj->name)) {
56 found = true;
57 break;
58 }
59 }
60
61 if (found)
62 return obj;
63 return NULL;
64 }
65
66 static int arm_cti_mod_reg_bits(struct arm_cti *self, unsigned int reg, uint32_t mask, uint32_t value)
67 {
68 struct adiv5_ap *ap = dap_ap(self->spot.dap, self->spot.ap_num);
69 uint32_t tmp;
70
71 /* Read register */
72 int retval = mem_ap_read_atomic_u32(ap, self->spot.base + reg, &tmp);
73 if (retval != ERROR_OK)
74 return retval;
75
76 /* clear bitfield */
77 tmp &= ~mask;
78 /* put new value */
79 tmp |= value & mask;
80
81 /* write new value */
82 return mem_ap_write_atomic_u32(ap, self->spot.base + reg, tmp);
83 }
84
85 int arm_cti_enable(struct arm_cti *self, bool enable)
86 {
87 struct adiv5_ap *ap = dap_ap(self->spot.dap, self->spot.ap_num);
88 uint32_t val = enable ? 1 : 0;
89
90 return mem_ap_write_atomic_u32(ap, self->spot.base + CTI_CTR, val);
91 }
92
93 int arm_cti_ack_events(struct arm_cti *self, uint32_t event)
94 {
95 struct adiv5_ap *ap = dap_ap(self->spot.dap, self->spot.ap_num);
96 int retval;
97 uint32_t tmp;
98
99 retval = mem_ap_write_atomic_u32(ap, self->spot.base + CTI_INACK, event);
100 if (retval == ERROR_OK) {
101 int64_t then = timeval_ms();
102 for (;;) {
103 retval = mem_ap_read_atomic_u32(ap, self->spot.base + CTI_TROUT_STATUS, &tmp);
104 if (retval != ERROR_OK)
105 break;
106 if ((tmp & event) == 0)
107 break;
108 if (timeval_ms() > then + 1000) {
109 LOG_ERROR("timeout waiting for target");
110 retval = ERROR_TARGET_TIMEOUT;
111 break;
112 }
113 }
114 }
115
116 return retval;
117 }
118
119 int arm_cti_gate_channel(struct arm_cti *self, uint32_t channel)
120 {
121 if (channel > 31)
122 return ERROR_COMMAND_ARGUMENT_INVALID;
123
124 return arm_cti_mod_reg_bits(self, CTI_GATE, CTI_CHNL(channel), 0);
125 }
126
127 int arm_cti_ungate_channel(struct arm_cti *self, uint32_t channel)
128 {
129 if (channel > 31)
130 return ERROR_COMMAND_ARGUMENT_INVALID;
131
132 return arm_cti_mod_reg_bits(self, CTI_GATE, CTI_CHNL(channel), 0xFFFFFFFF);
133 }
134
135 int arm_cti_write_reg(struct arm_cti *self, unsigned int reg, uint32_t value)
136 {
137 struct adiv5_ap *ap = dap_ap(self->spot.dap, self->spot.ap_num);
138
139 return mem_ap_write_atomic_u32(ap, self->spot.base + reg, value);
140 }
141
142 int arm_cti_read_reg(struct arm_cti *self, unsigned int reg, uint32_t *p_value)
143 {
144 struct adiv5_ap *ap = dap_ap(self->spot.dap, self->spot.ap_num);
145
146 if (!p_value)
147 return ERROR_COMMAND_ARGUMENT_INVALID;
148
149 return mem_ap_read_atomic_u32(ap, self->spot.base + reg, p_value);
150 }
151
152 int arm_cti_pulse_channel(struct arm_cti *self, uint32_t channel)
153 {
154 if (channel > 31)
155 return ERROR_COMMAND_ARGUMENT_INVALID;
156
157 return arm_cti_write_reg(self, CTI_APPPULSE, CTI_CHNL(channel));
158 }
159
160 int arm_cti_set_channel(struct arm_cti *self, uint32_t channel)
161 {
162 if (channel > 31)
163 return ERROR_COMMAND_ARGUMENT_INVALID;
164
165 return arm_cti_write_reg(self, CTI_APPSET, CTI_CHNL(channel));
166 }
167
168 int arm_cti_clear_channel(struct arm_cti *self, uint32_t channel)
169 {
170 if (channel > 31)
171 return ERROR_COMMAND_ARGUMENT_INVALID;
172
173 return arm_cti_write_reg(self, CTI_APPCLEAR, CTI_CHNL(channel));
174 }
175
176 static uint32_t cti_regs[28];
177
178 static const struct {
179 uint32_t offset;
180 const char *label;
181 uint32_t *p_val;
182 } cti_names[] = {
183 { CTI_CTR, "CTR", &cti_regs[0] },
184 { CTI_GATE, "GATE", &cti_regs[1] },
185 { CTI_INEN0, "INEN0", &cti_regs[2] },
186 { CTI_INEN1, "INEN1", &cti_regs[3] },
187 { CTI_INEN2, "INEN2", &cti_regs[4] },
188 { CTI_INEN3, "INEN3", &cti_regs[5] },
189 { CTI_INEN4, "INEN4", &cti_regs[6] },
190 { CTI_INEN5, "INEN5", &cti_regs[7] },
191 { CTI_INEN6, "INEN6", &cti_regs[8] },
192 { CTI_INEN7, "INEN7", &cti_regs[9] },
193 { CTI_INEN8, "INEN8", &cti_regs[10] },
194 { CTI_OUTEN0, "OUTEN0", &cti_regs[11] },
195 { CTI_OUTEN1, "OUTEN1", &cti_regs[12] },
196 { CTI_OUTEN2, "OUTEN2", &cti_regs[13] },
197 { CTI_OUTEN3, "OUTEN3", &cti_regs[14] },
198 { CTI_OUTEN4, "OUTEN4", &cti_regs[15] },
199 { CTI_OUTEN5, "OUTEN5", &cti_regs[16] },
200 { CTI_OUTEN6, "OUTEN6", &cti_regs[17] },
201 { CTI_OUTEN7, "OUTEN7", &cti_regs[18] },
202 { CTI_OUTEN8, "OUTEN8", &cti_regs[19] },
203 { CTI_TRIN_STATUS, "TRIN", &cti_regs[20] },
204 { CTI_TROUT_STATUS, "TROUT", &cti_regs[21] },
205 { CTI_CHIN_STATUS, "CHIN", &cti_regs[22] },
206 { CTI_CHOU_STATUS, "CHOUT", &cti_regs[23] },
207 { CTI_APPSET, "APPSET", &cti_regs[24] },
208 { CTI_APPCLEAR, "APPCLR", &cti_regs[25] },
209 { CTI_APPPULSE, "APPPULSE", &cti_regs[26] },
210 { CTI_INACK, "INACK", &cti_regs[27] },
211 };
212
213 static int cti_find_reg_offset(const char *name)
214 {
215 unsigned int i;
216
217 for (i = 0; i < ARRAY_SIZE(cti_names); i++) {
218 if (!strcmp(name, cti_names[i].label))
219 return cti_names[i].offset;
220 }
221
222 LOG_ERROR("unknown CTI register %s", name);
223 return -1;
224 }
225
226 int arm_cti_cleanup_all(void)
227 {
228 struct arm_cti *obj, *tmp;
229
230 list_for_each_entry_safe(obj, tmp, &all_cti, lh) {
231 free(obj->name);
232 free(obj);
233 }
234
235 return ERROR_OK;
236 }
237
238 COMMAND_HANDLER(handle_cti_dump)
239 {
240 struct arm_cti *cti = CMD_DATA;
241 struct adiv5_ap *ap = dap_ap(cti->spot.dap, cti->spot.ap_num);
242 int retval = ERROR_OK;
243
244 for (int i = 0; (retval == ERROR_OK) && (i < (int)ARRAY_SIZE(cti_names)); i++)
245 retval = mem_ap_read_u32(ap,
246 cti->spot.base + cti_names[i].offset, cti_names[i].p_val);
247
248 if (retval == ERROR_OK)
249 retval = dap_run(ap->dap);
250
251 if (retval != ERROR_OK)
252 return JIM_ERR;
253
254 for (int i = 0; i < (int)ARRAY_SIZE(cti_names); i++)
255 command_print(CMD, "%8.8s (0x%04"PRIx32") 0x%08"PRIx32,
256 cti_names[i].label, cti_names[i].offset, *cti_names[i].p_val);
257
258 return JIM_OK;
259 }
260
261 COMMAND_HANDLER(handle_cti_enable)
262 {
263 struct arm_cti *cti = CMD_DATA;
264 bool on_off;
265
266 if (CMD_ARGC != 1)
267 return ERROR_COMMAND_SYNTAX_ERROR;
268
269 COMMAND_PARSE_ON_OFF(CMD_ARGV[0], on_off);
270
271 return arm_cti_enable(cti, on_off);
272 }
273
274 COMMAND_HANDLER(handle_cti_testmode)
275 {
276 struct arm_cti *cti = CMD_DATA;
277 bool on_off;
278
279 if (CMD_ARGC != 1)
280 return ERROR_COMMAND_SYNTAX_ERROR;
281
282 COMMAND_PARSE_ON_OFF(CMD_ARGV[0], on_off);
283
284 return arm_cti_write_reg(cti, 0xf00, on_off ? 0x1 : 0x0);
285 }
286
287 COMMAND_HANDLER(handle_cti_write)
288 {
289 struct arm_cti *cti = CMD_DATA;
290 int offset;
291 uint32_t value;
292
293 if (CMD_ARGC != 2)
294 return ERROR_COMMAND_SYNTAX_ERROR;
295
296 offset = cti_find_reg_offset(CMD_ARGV[0]);
297 if (offset < 0)
298 return ERROR_FAIL;
299
300 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
301
302 return arm_cti_write_reg(cti, offset, value);
303 }
304
305 COMMAND_HANDLER(handle_cti_read)
306 {
307 struct arm_cti *cti = CMD_DATA;
308 int offset;
309 int retval;
310 uint32_t value;
311
312 if (CMD_ARGC != 1)
313 return ERROR_COMMAND_SYNTAX_ERROR;
314
315 offset = cti_find_reg_offset(CMD_ARGV[0]);
316 if (offset < 0)
317 return ERROR_FAIL;
318
319 retval = arm_cti_read_reg(cti, offset, &value);
320 if (retval != ERROR_OK)
321 return retval;
322
323 command_print(CMD, "0x%08"PRIx32, value);
324
325 return ERROR_OK;
326 }
327
328 COMMAND_HANDLER(handle_cti_ack)
329 {
330 struct arm_cti *cti = CMD_DATA;
331 uint32_t event;
332
333 if (CMD_ARGC != 1)
334 return ERROR_COMMAND_SYNTAX_ERROR;
335
336 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], event);
337
338 int retval = arm_cti_ack_events(cti, 1 << event);
339
340
341 if (retval != ERROR_OK)
342 return retval;
343
344 return ERROR_OK;
345 }
346
347 COMMAND_HANDLER(handle_cti_channel)
348 {
349 struct arm_cti *cti = CMD_DATA;
350 int retval = ERROR_OK;
351 uint32_t ch_num;
352
353 if (CMD_ARGC != 2)
354 return ERROR_COMMAND_SYNTAX_ERROR;
355
356 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], ch_num);
357
358 if (!strcmp(CMD_ARGV[1], "gate"))
359 retval = arm_cti_gate_channel(cti, ch_num);
360 else if (!strcmp(CMD_ARGV[1], "ungate"))
361 retval = arm_cti_ungate_channel(cti, ch_num);
362 else if (!strcmp(CMD_ARGV[1], "pulse"))
363 retval = arm_cti_pulse_channel(cti, ch_num);
364 else if (!strcmp(CMD_ARGV[1], "set"))
365 retval = arm_cti_set_channel(cti, ch_num);
366 else if (!strcmp(CMD_ARGV[1], "clear"))
367 retval = arm_cti_clear_channel(cti, ch_num);
368 else {
369 command_print(CMD, "Possible channel operations: gate|ungate|set|clear|pulse");
370 return ERROR_COMMAND_ARGUMENT_INVALID;
371 }
372
373 if (retval != ERROR_OK)
374 return retval;
375
376 return ERROR_OK;
377 }
378
379 static const struct command_registration cti_instance_command_handlers[] = {
380 {
381 .name = "dump",
382 .mode = COMMAND_EXEC,
383 .handler = handle_cti_dump,
384 .help = "dump CTI registers",
385 .usage = "",
386 },
387 {
388 .name = "enable",
389 .mode = COMMAND_EXEC,
390 .handler = handle_cti_enable,
391 .help = "enable or disable the CTI",
392 .usage = "'on'|'off'",
393 },
394 {
395 .name = "testmode",
396 .mode = COMMAND_EXEC,
397 .handler = handle_cti_testmode,
398 .help = "enable or disable integration test mode",
399 .usage = "'on'|'off'",
400 },
401 {
402 .name = "write",
403 .mode = COMMAND_EXEC,
404 .handler = handle_cti_write,
405 .help = "write to a CTI register",
406 .usage = "register_name value",
407 },
408 {
409 .name = "read",
410 .mode = COMMAND_EXEC,
411 .handler = handle_cti_read,
412 .help = "read a CTI register",
413 .usage = "register_name",
414 },
415 {
416 .name = "ack",
417 .mode = COMMAND_EXEC,
418 .handler = handle_cti_ack,
419 .help = "acknowledge a CTI event",
420 .usage = "event",
421 },
422 {
423 .name = "channel",
424 .mode = COMMAND_EXEC,
425 .handler = handle_cti_channel,
426 .help = "do an operation on one CTI channel, possible operations: "
427 "gate, ungate, set, clear and pulse",
428 .usage = "channel_number operation",
429 },
430 COMMAND_REGISTRATION_DONE
431 };
432
433 static int cti_configure(struct jim_getopt_info *goi, struct arm_cti *cti)
434 {
435 /* parse config or cget options ... */
436 while (goi->argc > 0) {
437 int e = adiv5_jim_mem_ap_spot_configure(&cti->spot, goi);
438 if (e != JIM_OK)
439 return e;
440 }
441
442 if (!cti->spot.dap) {
443 Jim_SetResultString(goi->interp, "-dap required when creating CTI", -1);
444 return JIM_ERR;
445 }
446
447 return JIM_OK;
448 }
449 static int cti_create(struct jim_getopt_info *goi)
450 {
451 struct command_context *cmd_ctx;
452 static struct arm_cti *cti;
453 Jim_Obj *new_cmd;
454 Jim_Cmd *cmd;
455 const char *cp;
456 int e;
457
458 cmd_ctx = current_command_context(goi->interp);
459 assert(cmd_ctx);
460
461 if (goi->argc < 3) {
462 Jim_WrongNumArgs(goi->interp, 1, goi->argv, "?name? ..options...");
463 return JIM_ERR;
464 }
465 /* COMMAND */
466 jim_getopt_obj(goi, &new_cmd);
467 /* does this command exist? */
468 cmd = Jim_GetCommand(goi->interp, new_cmd, JIM_NONE);
469 if (cmd) {
470 cp = Jim_GetString(new_cmd, NULL);
471 Jim_SetResultFormatted(goi->interp, "Command: %s Exists", cp);
472 return JIM_ERR;
473 }
474
475 /* Create it */
476 cti = calloc(1, sizeof(*cti));
477 if (!cti)
478 return JIM_ERR;
479
480 adiv5_mem_ap_spot_init(&cti->spot);
481
482 /* Do the rest as "configure" options */
483 goi->isconfigure = 1;
484 e = cti_configure(goi, cti);
485 if (e != JIM_OK) {
486 free(cti);
487 return e;
488 }
489
490 cp = Jim_GetString(new_cmd, NULL);
491 cti->name = strdup(cp);
492
493 /* now - create the new cti name command */
494 const struct command_registration cti_subcommands[] = {
495 {
496 .chain = cti_instance_command_handlers,
497 },
498 COMMAND_REGISTRATION_DONE
499 };
500 const struct command_registration cti_commands[] = {
501 {
502 .name = cp,
503 .mode = COMMAND_ANY,
504 .help = "cti instance command group",
505 .usage = "",
506 .chain = cti_subcommands,
507 },
508 COMMAND_REGISTRATION_DONE
509 };
510 e = register_commands_with_data(cmd_ctx, NULL, cti_commands, cti);
511 if (e != ERROR_OK)
512 return JIM_ERR;
513
514 list_add_tail(&cti->lh, &all_cti);
515
516 return JIM_OK;
517 }
518
519 static int jim_cti_create(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
520 {
521 struct jim_getopt_info goi;
522 jim_getopt_setup(&goi, interp, argc - 1, argv + 1);
523 if (goi.argc < 2) {
524 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
525 "<name> [<cti_options> ...]");
526 return JIM_ERR;
527 }
528 return cti_create(&goi);
529 }
530
531 static int jim_cti_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
532 {
533 struct arm_cti *obj;
534
535 if (argc != 1) {
536 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
537 return JIM_ERR;
538 }
539 Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
540 list_for_each_entry(obj, &all_cti, lh) {
541 Jim_ListAppendElement(interp, Jim_GetResult(interp),
542 Jim_NewStringObj(interp, obj->name, -1));
543 }
544 return JIM_OK;
545 }
546
547
548 static const struct command_registration cti_subcommand_handlers[] = {
549 {
550 .name = "create",
551 .mode = COMMAND_ANY,
552 .jim_handler = jim_cti_create,
553 .usage = "name '-chain-position' name [options ...]",
554 .help = "Creates a new CTI object",
555 },
556 {
557 .name = "names",
558 .mode = COMMAND_ANY,
559 .jim_handler = jim_cti_names,
560 .usage = "",
561 .help = "Lists all registered CTI objects by name",
562 },
563 COMMAND_REGISTRATION_DONE
564 };
565
566 static const struct command_registration cti_command_handlers[] = {
567 {
568 .name = "cti",
569 .mode = COMMAND_CONFIG,
570 .help = "CTI commands",
571 .chain = cti_subcommand_handlers,
572 .usage = "",
573 },
574 COMMAND_REGISTRATION_DONE
575 };
576
577 int cti_register_commands(struct command_context *cmd_ctx)
578 {
579 return register_commands(cmd_ctx, NULL, cti_command_handlers);
580 }
Official OpenOCD Mirror