?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target/xtensa: avoid IHI for writes to non-executable memory
[openocd.git] / src / jtag / adapter.c
blobbbf1cb3d2e2e8c4a8f04c3fd53697058579fb048
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) 2005 by Dominic Rath <Dominic.Rath@gmx.de>
4 * Copyright (C) 2007-2010 Øyvind Harboe <oyvind.harboe@zylin.com>
5 * Copyright (C) 2009 SoftPLC Corporation, http://softplc.com, Dick Hollenbeck <dick@softplc.com>
6 * Copyright (C) 2009 Zachary T Welch <zw@superlucidity.net>
7 * Copyright (C) 2018 Pengutronix, Oleksij Rempel <kernel@pengutronix.de>
8 */
9
10 #ifdef HAVE_CONFIG_H
11 #include "config.h"
12 #endif
13
14 #include "adapter.h"
15 #include "jtag.h"
16 #include "minidriver.h"
17 #include "interface.h"
18 #include "interfaces.h"
19 #include <transport/transport.h>
20
21 /**
22 * @file
23 * Holds support for configuring debug adapters from TCl scripts.
24 */
25
26 struct adapter_driver *adapter_driver;
27 const char * const jtag_only[] = { "jtag", NULL };
28
29 enum adapter_clk_mode {
30 CLOCK_MODE_UNSELECTED = 0,
31 CLOCK_MODE_KHZ,
32 CLOCK_MODE_RCLK
33 };
34
35 #define DEFAULT_CLOCK_SPEED_KHZ 100U
36
37 /**
38 * Adapter configuration
39 */
40 static struct {
41 bool adapter_initialized;
42 char *usb_location;
43 char *serial;
44 enum adapter_clk_mode clock_mode;
45 int speed_khz;
46 int rclk_fallback_speed_khz;
47 struct adapter_gpio_config gpios[ADAPTER_GPIO_IDX_NUM];
48 bool gpios_initialized; /* Initialization of GPIOs to their unset values performed at run time */
49 } adapter_config;
50
51 static const struct gpio_map {
52 const char *name;
53 enum adapter_gpio_direction direction;
54 bool permit_drive_option;
55 bool permit_init_state_option;
56 } gpio_map[ADAPTER_GPIO_IDX_NUM] = {
57 [ADAPTER_GPIO_IDX_TDO] = { "tdo", ADAPTER_GPIO_DIRECTION_INPUT, false, true, },
58 [ADAPTER_GPIO_IDX_TDI] = { "tdi", ADAPTER_GPIO_DIRECTION_OUTPUT, true, true, },
59 [ADAPTER_GPIO_IDX_TMS] = { "tms", ADAPTER_GPIO_DIRECTION_OUTPUT, true, true, },
60 [ADAPTER_GPIO_IDX_TCK] = { "tck", ADAPTER_GPIO_DIRECTION_OUTPUT, true, true, },
61 [ADAPTER_GPIO_IDX_SWDIO] = { "swdio", ADAPTER_GPIO_DIRECTION_BIDIRECTIONAL, true, true, },
62 [ADAPTER_GPIO_IDX_SWDIO_DIR] = { "swdio_dir", ADAPTER_GPIO_DIRECTION_OUTPUT, true, false, },
63 [ADAPTER_GPIO_IDX_SWCLK] = { "swclk", ADAPTER_GPIO_DIRECTION_OUTPUT, true, true, },
64 [ADAPTER_GPIO_IDX_TRST] = { "trst", ADAPTER_GPIO_DIRECTION_OUTPUT, false, true, },
65 [ADAPTER_GPIO_IDX_SRST] = { "srst", ADAPTER_GPIO_DIRECTION_OUTPUT, false, true, },
66 [ADAPTER_GPIO_IDX_LED] = { "led", ADAPTER_GPIO_DIRECTION_OUTPUT, true, true, },
67 };
68
69 bool is_adapter_initialized(void)
70 {
71 return adapter_config.adapter_initialized;
72 }
73
74 /* For convenience of the bit-banging drivers keep the gpio_config drive
75 * settings for srst and trst in sync with values set by the "adapter
76 * reset_config" command.
77 */
78 static void sync_adapter_reset_with_gpios(void)
79 {
80 enum reset_types cfg = jtag_get_reset_config();
81 if (cfg & RESET_SRST_PUSH_PULL)
82 adapter_config.gpios[ADAPTER_GPIO_IDX_SRST].drive = ADAPTER_GPIO_DRIVE_MODE_PUSH_PULL;
83 else
84 adapter_config.gpios[ADAPTER_GPIO_IDX_SRST].drive = ADAPTER_GPIO_DRIVE_MODE_OPEN_DRAIN;
85 if (cfg & RESET_TRST_OPEN_DRAIN)
86 adapter_config.gpios[ADAPTER_GPIO_IDX_TRST].drive = ADAPTER_GPIO_DRIVE_MODE_OPEN_DRAIN;
87 else
88 adapter_config.gpios[ADAPTER_GPIO_IDX_TRST].drive = ADAPTER_GPIO_DRIVE_MODE_PUSH_PULL;
89 }
90
91 static void adapter_driver_gpios_init(void)
92 {
93 if (adapter_config.gpios_initialized)
94 return;
95
96 for (int i = 0; i < ADAPTER_GPIO_IDX_NUM; ++i) {
97 /* Use ADAPTER_GPIO_NOT_SET as the sentinel 'unset' value. */
98 adapter_config.gpios[i].gpio_num = ADAPTER_GPIO_NOT_SET;
99 adapter_config.gpios[i].chip_num = ADAPTER_GPIO_NOT_SET;
100 if (gpio_map[i].direction == ADAPTER_GPIO_DIRECTION_INPUT)
101 adapter_config.gpios[i].init_state = ADAPTER_GPIO_INIT_STATE_INPUT;
102 }
103
104 /* Drivers assume active low, and this is the normal behaviour for reset
105 * lines so should be the default. */
106 adapter_config.gpios[ADAPTER_GPIO_IDX_SRST].active_low = true;
107 adapter_config.gpios[ADAPTER_GPIO_IDX_TRST].active_low = true;
108 sync_adapter_reset_with_gpios();
109
110 /* JTAG GPIOs should be inactive except for tms */
111 adapter_config.gpios[ADAPTER_GPIO_IDX_TMS].init_state = ADAPTER_GPIO_INIT_STATE_ACTIVE;
112
113 adapter_config.gpios_initialized = true;
114 }
115
116 /**
117 * Do low-level setup like initializing registers, output signals,
118 * and clocking.
119 */
120 int adapter_init(struct command_context *cmd_ctx)
121 {
122 if (is_adapter_initialized())
123 return ERROR_OK;
124
125 if (!adapter_driver) {
126 /* nothing was previously specified by "adapter driver" command */
127 LOG_ERROR("Debug Adapter has to be specified, "
128 "see \"adapter driver\" command");
129 return ERROR_JTAG_INVALID_INTERFACE;
130 }
131
132 adapter_driver_gpios_init();
133
134 int retval;
135
136 /* If the adapter supports configurable speed but the speed is not configured,
137 * provide a hint to the user. */
138 if (adapter_driver->speed && adapter_config.clock_mode == CLOCK_MODE_UNSELECTED) {
139 LOG_WARNING("An adapter speed is not selected in the init scripts."
140 " OpenOCD will try to run the adapter at very low speed (%d kHz).",
141 DEFAULT_CLOCK_SPEED_KHZ);
142 LOG_WARNING("To remove this warnings and achieve reasonable communication speed with the target,"
143 " set \"adapter speed\" or \"jtag_rclk\" in the init scripts.");
144 retval = adapter_config_khz(DEFAULT_CLOCK_SPEED_KHZ);
145 if (retval != ERROR_OK)
146 return ERROR_JTAG_INIT_FAILED;
147 }
148
149 retval = adapter_driver->init();
150 if (retval != ERROR_OK)
151 return retval;
152 adapter_config.adapter_initialized = true;
153
154 if (!adapter_driver->speed) {
155 LOG_INFO("Note: The adapter \"%s\" doesn't support configurable speed", adapter_driver->name);
156 return ERROR_OK;
157 }
158
159 int requested_khz = adapter_get_speed_khz();
160 int actual_khz = requested_khz;
161 int speed_var = 0;
162 retval = adapter_get_speed(&speed_var);
163 if (retval != ERROR_OK)
164 return retval;
165 retval = adapter_driver->speed(speed_var);
166 if (retval != ERROR_OK)
167 return retval;
168 retval = adapter_get_speed_readable(&actual_khz);
169 if (retval != ERROR_OK)
170 LOG_INFO("adapter-specific clock speed value %d", speed_var);
171 else if (actual_khz) {
172 /* Adaptive clocking -- JTAG-specific */
173 if ((adapter_config.clock_mode == CLOCK_MODE_RCLK)
174 || ((adapter_config.clock_mode == CLOCK_MODE_KHZ) && !requested_khz)) {
175 LOG_INFO("RCLK (adaptive clock speed) not supported - fallback to %d kHz"
176 , actual_khz);
177 } else
178 LOG_INFO("clock speed %d kHz", actual_khz);
179 } else
180 LOG_INFO("RCLK (adaptive clock speed)");
181
182 return ERROR_OK;
183 }
184
185 int adapter_quit(void)
186 {
187 if (is_adapter_initialized() && adapter_driver->quit) {
188 /* close the JTAG interface */
189 int result = adapter_driver->quit();
190 if (result != ERROR_OK)
191 LOG_ERROR("failed: %d", result);
192 }
193
194 free(adapter_config.serial);
195 free(adapter_config.usb_location);
196
197 struct jtag_tap *t = jtag_all_taps();
198 while (t) {
199 struct jtag_tap *n = t->next_tap;
200 jtag_tap_free(t);
201 t = n;
202 }
203
204 return ERROR_OK;
205 }
206
207 unsigned int adapter_get_speed_khz(void)
208 {
209 return adapter_config.speed_khz;
210 }
211
212 static int adapter_khz_to_speed(unsigned int khz, int *speed)
213 {
214 LOG_DEBUG("convert khz to adapter specific speed value");
215 adapter_config.speed_khz = khz;
216 if (!is_adapter_initialized())
217 return ERROR_OK;
218 LOG_DEBUG("have adapter set up");
219 if (!adapter_driver->khz) {
220 LOG_ERROR("Translation from khz to adapter speed not implemented");
221 return ERROR_FAIL;
222 }
223 int speed_div1;
224 int retval = adapter_driver->khz(adapter_get_speed_khz(), &speed_div1);
225 if (retval != ERROR_OK)
226 return retval;
227 *speed = speed_div1;
228 return ERROR_OK;
229 }
230
231 static int adapter_rclk_to_speed(unsigned int fallback_speed_khz, int *speed)
232 {
233 int retval = adapter_khz_to_speed(0, speed);
234 if ((retval != ERROR_OK) && fallback_speed_khz) {
235 LOG_DEBUG("trying fallback speed...");
236 retval = adapter_khz_to_speed(fallback_speed_khz, speed);
237 }
238 return retval;
239 }
240
241 static int adapter_set_speed(int speed)
242 {
243 /* this command can be called during CONFIG,
244 * in which case adapter isn't initialized */
245 return is_adapter_initialized() ? adapter_driver->speed(speed) : ERROR_OK;
246 }
247
248 int adapter_config_khz(unsigned int khz)
249 {
250 LOG_DEBUG("handle adapter khz");
251 adapter_config.clock_mode = CLOCK_MODE_KHZ;
252 int speed = 0;
253 int retval = adapter_khz_to_speed(khz, &speed);
254 return (retval != ERROR_OK) ? retval : adapter_set_speed(speed);
255 }
256
257 int adapter_config_rclk(unsigned int fallback_speed_khz)
258 {
259 LOG_DEBUG("handle adapter rclk");
260 adapter_config.clock_mode = CLOCK_MODE_RCLK;
261 adapter_config.rclk_fallback_speed_khz = fallback_speed_khz;
262 int speed = 0;
263 int retval = adapter_rclk_to_speed(fallback_speed_khz, &speed);
264 return (retval != ERROR_OK) ? retval : adapter_set_speed(speed);
265 }
266
267 int adapter_get_speed(int *speed)
268 {
269 switch (adapter_config.clock_mode) {
270 case CLOCK_MODE_KHZ:
271 adapter_khz_to_speed(adapter_get_speed_khz(), speed);
272 break;
273 case CLOCK_MODE_RCLK:
274 adapter_rclk_to_speed(adapter_config.rclk_fallback_speed_khz, speed);
275 break;
276 default:
277 LOG_ERROR("BUG: unknown adapter clock mode");
278 return ERROR_FAIL;
279 }
280 return ERROR_OK;
281 }
282
283 int adapter_get_speed_readable(int *khz)
284 {
285 int speed_var = 0;
286 int retval = adapter_get_speed(&speed_var);
287 if (retval != ERROR_OK)
288 return retval;
289 if (!is_adapter_initialized())
290 return ERROR_OK;
291 if (!adapter_driver->speed_div) {
292 LOG_ERROR("Translation from adapter speed to khz not implemented");
293 return ERROR_FAIL;
294 }
295 return adapter_driver->speed_div(speed_var, khz);
296 }
297
298 const char *adapter_get_required_serial(void)
299 {
300 return adapter_config.serial;
301 }
302
303 /*
304 * 1 char: bus
305 * 2 * 7 chars: max 7 ports
306 * 1 char: test for overflow
307 * ------
308 * 16 chars
309 */
310 #define USB_MAX_LOCATION_LENGTH 16
311
312 #ifdef HAVE_LIBUSB_GET_PORT_NUMBERS
313 static void adapter_usb_set_location(const char *location)
314 {
315 if (strnlen(location, USB_MAX_LOCATION_LENGTH) == USB_MAX_LOCATION_LENGTH)
316 LOG_WARNING("usb location string is too long!!");
317
318 free(adapter_config.usb_location);
319
320 adapter_config.usb_location = strndup(location, USB_MAX_LOCATION_LENGTH);
321 }
322 #endif /* HAVE_LIBUSB_GET_PORT_NUMBERS */
323
324 const char *adapter_usb_get_location(void)
325 {
326 return adapter_config.usb_location;
327 }
328
329 bool adapter_usb_location_equal(uint8_t dev_bus, uint8_t *port_path, size_t path_len)
330 {
331 size_t path_step, string_length;
332 char *ptr, *loc;
333 bool equal = false;
334
335 if (!adapter_usb_get_location())
336 return equal;
337
338 /* strtok need non const char */
339 loc = strndup(adapter_usb_get_location(), USB_MAX_LOCATION_LENGTH);
340 string_length = strnlen(loc, USB_MAX_LOCATION_LENGTH);
341
342 ptr = strtok(loc, "-");
343 if (!ptr) {
344 LOG_WARNING("no '-' in usb path\n");
345 goto done;
346 }
347
348 string_length -= strnlen(ptr, string_length);
349 /* check bus mismatch */
350 if (atoi(ptr) != dev_bus)
351 goto done;
352
353 path_step = 0;
354 while (path_step < path_len) {
355 ptr = strtok(NULL, ".");
356
357 /* no more tokens in path */
358 if (!ptr)
359 break;
360
361 /* path mismatch at some step */
362 if (path_step < path_len && atoi(ptr) != port_path[path_step])
363 break;
364
365 path_step++;
366 string_length -= strnlen(ptr, string_length) + 1;
367 };
368
369 /* walked the full path, all elements match */
370 if (path_step == path_len && !string_length)
371 equal = true;
372
373 done:
374 free(loc);
375 return equal;
376 }
377
378 COMMAND_HANDLER(handle_adapter_name)
379 {
380 /* return the name of the interface */
381 /* TCL code might need to know the exact type... */
382 /* FUTURE: we allow this as a means to "set" the interface. */
383
384 if (CMD_ARGC != 0)
385 return ERROR_COMMAND_SYNTAX_ERROR;
386
387 command_print(CMD, "%s", adapter_driver ? adapter_driver->name : "undefined");
388
389 return ERROR_OK;
390 }
391
392 COMMAND_HANDLER(adapter_transports_command)
393 {
394 char **transports;
395 int retval;
396
397 retval = CALL_COMMAND_HANDLER(transport_list_parse, &transports);
398 if (retval != ERROR_OK)
399 return retval;
400
401 retval = allow_transports(CMD_CTX, (const char **)transports);
402
403 if (retval != ERROR_OK) {
404 for (unsigned i = 0; transports[i]; i++)
405 free(transports[i]);
406 free(transports);
407 }
408 return retval;
409 }
410
411 COMMAND_HANDLER(handle_adapter_list_command)
412 {
413 if (strcmp(CMD_NAME, "list") == 0 && CMD_ARGC > 0)
414 return ERROR_COMMAND_SYNTAX_ERROR;
415
416 command_print(CMD, "The following debug adapters are available:");
417 for (unsigned i = 0; adapter_drivers[i]; i++) {
418 const char *name = adapter_drivers[i]->name;
419 command_print(CMD, "%u: %s", i + 1, name);
420 }
421
422 return ERROR_OK;
423 }
424
425 COMMAND_HANDLER(handle_adapter_driver_command)
426 {
427 int retval;
428
429 /* check whether the interface is already configured */
430 if (adapter_driver) {
431 LOG_WARNING("Interface already configured, ignoring");
432 return ERROR_OK;
433 }
434
435 /* interface name is a mandatory argument */
436 if (CMD_ARGC != 1 || CMD_ARGV[0][0] == '\0')
437 return ERROR_COMMAND_SYNTAX_ERROR;
438
439 for (unsigned i = 0; adapter_drivers[i]; i++) {
440 if (strcmp(CMD_ARGV[0], adapter_drivers[i]->name) != 0)
441 continue;
442
443 if (adapter_drivers[i]->commands) {
444 retval = register_commands(CMD_CTX, NULL, adapter_drivers[i]->commands);
445 if (retval != ERROR_OK)
446 return retval;
447 }
448
449 adapter_driver = adapter_drivers[i];
450
451 return allow_transports(CMD_CTX, adapter_driver->transports);
452 }
453
454 /* no valid interface was found (i.e. the configuration option,
455 * didn't match one of the compiled-in interfaces
456 */
457 LOG_ERROR("The specified debug interface was not found (%s)",
458 CMD_ARGV[0]);
459 CALL_COMMAND_HANDLER(handle_adapter_list_command);
460 return ERROR_JTAG_INVALID_INTERFACE;
461 }
462
463 COMMAND_HANDLER(handle_reset_config_command)
464 {
465 int new_cfg = 0;
466 int mask = 0;
467
468 /* Original versions cared about the order of these tokens:
469 * reset_config signals [combination [trst_type [srst_type]]]
470 * They also clobbered the previous configuration even on error.
471 *
472 * Here we don't care about the order, and only change values
473 * which have been explicitly specified.
474 */
475 for (; CMD_ARGC; CMD_ARGC--, CMD_ARGV++) {
476 int tmp = 0;
477 int m;
478
479 /* gating */
480 m = RESET_SRST_NO_GATING;
481 if (strcmp(*CMD_ARGV, "srst_gates_jtag") == 0)
482 /* default: don't use JTAG while SRST asserted */;
483 else if (strcmp(*CMD_ARGV, "srst_nogate") == 0)
484 tmp = RESET_SRST_NO_GATING;
485 else
486 m = 0;
487 if (mask & m) {
488 LOG_ERROR("extra reset_config %s spec (%s)",
489 "gating", *CMD_ARGV);
490 return ERROR_COMMAND_SYNTAX_ERROR;
491 }
492 if (m)
493 goto next;
494
495 /* signals */
496 m = RESET_HAS_TRST | RESET_HAS_SRST;
497 if (strcmp(*CMD_ARGV, "none") == 0)
498 tmp = RESET_NONE;
499 else if (strcmp(*CMD_ARGV, "trst_only") == 0)
500 tmp = RESET_HAS_TRST;
501 else if (strcmp(*CMD_ARGV, "srst_only") == 0)
502 tmp = RESET_HAS_SRST;
503 else if (strcmp(*CMD_ARGV, "trst_and_srst") == 0)
504 tmp = RESET_HAS_TRST | RESET_HAS_SRST;
505 else
506 m = 0;
507 if (mask & m) {
508 LOG_ERROR("extra reset_config %s spec (%s)",
509 "signal", *CMD_ARGV);
510 return ERROR_COMMAND_SYNTAX_ERROR;
511 }
512 if (m)
513 goto next;
514
515 /* combination (options for broken wiring) */
516 m = RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
517 if (strcmp(*CMD_ARGV, "separate") == 0)
518 /* separate reset lines - default */;
519 else if (strcmp(*CMD_ARGV, "srst_pulls_trst") == 0)
520 tmp |= RESET_SRST_PULLS_TRST;
521 else if (strcmp(*CMD_ARGV, "trst_pulls_srst") == 0)
522 tmp |= RESET_TRST_PULLS_SRST;
523 else if (strcmp(*CMD_ARGV, "combined") == 0)
524 tmp |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
525 else
526 m = 0;
527 if (mask & m) {
528 LOG_ERROR("extra reset_config %s spec (%s)",
529 "combination", *CMD_ARGV);
530 return ERROR_COMMAND_SYNTAX_ERROR;
531 }
532 if (m)
533 goto next;
534
535 /* trst_type (NOP without HAS_TRST) */
536 m = RESET_TRST_OPEN_DRAIN;
537 if (strcmp(*CMD_ARGV, "trst_open_drain") == 0)
538 tmp |= RESET_TRST_OPEN_DRAIN;
539 else if (strcmp(*CMD_ARGV, "trst_push_pull") == 0)
540 /* push/pull from adapter - default */;
541 else
542 m = 0;
543 if (mask & m) {
544 LOG_ERROR("extra reset_config %s spec (%s)",
545 "trst_type", *CMD_ARGV);
546 return ERROR_COMMAND_SYNTAX_ERROR;
547 }
548 if (m)
549 goto next;
550
551 /* srst_type (NOP without HAS_SRST) */
552 m = RESET_SRST_PUSH_PULL;
553 if (strcmp(*CMD_ARGV, "srst_push_pull") == 0)
554 tmp |= RESET_SRST_PUSH_PULL;
555 else if (strcmp(*CMD_ARGV, "srst_open_drain") == 0)
556 /* open drain from adapter - default */;
557 else
558 m = 0;
559 if (mask & m) {
560 LOG_ERROR("extra reset_config %s spec (%s)",
561 "srst_type", *CMD_ARGV);
562 return ERROR_COMMAND_SYNTAX_ERROR;
563 }
564 if (m)
565 goto next;
566
567 /* connect_type - only valid when srst_nogate */
568 m = RESET_CNCT_UNDER_SRST;
569 if (strcmp(*CMD_ARGV, "connect_assert_srst") == 0)
570 tmp |= RESET_CNCT_UNDER_SRST;
571 else if (strcmp(*CMD_ARGV, "connect_deassert_srst") == 0)
572 /* connect normally - default */;
573 else
574 m = 0;
575 if (mask & m) {
576 LOG_ERROR("extra reset_config %s spec (%s)",
577 "connect_type", *CMD_ARGV);
578 return ERROR_COMMAND_SYNTAX_ERROR;
579 }
580 if (m)
581 goto next;
582
583 /* caller provided nonsense; fail */
584 LOG_ERROR("unknown reset_config flag (%s)", *CMD_ARGV);
585 return ERROR_COMMAND_SYNTAX_ERROR;
586
587 next:
588 /* Remember the bits which were specified (mask)
589 * and their new values (new_cfg).
590 */
591 mask |= m;
592 new_cfg |= tmp;
593 }
594
595 /* clear previous values of those bits, save new values */
596 if (mask) {
597 int old_cfg = jtag_get_reset_config();
598
599 old_cfg &= ~mask;
600 new_cfg |= old_cfg;
601 jtag_set_reset_config(new_cfg);
602 sync_adapter_reset_with_gpios();
603
604 } else
605 new_cfg = jtag_get_reset_config();
606
607 /*
608 * Display the (now-)current reset mode
609 */
610 char *modes[6];
611
612 /* minimal JTAG has neither SRST nor TRST (so that's the default) */
613 switch (new_cfg & (RESET_HAS_TRST | RESET_HAS_SRST)) {
614 case RESET_HAS_SRST:
615 modes[0] = "srst_only";
616 break;
617 case RESET_HAS_TRST:
618 modes[0] = "trst_only";
619 break;
620 case RESET_TRST_AND_SRST:
621 modes[0] = "trst_and_srst";
622 break;
623 default:
624 modes[0] = "none";
625 break;
626 }
627
628 /* normally SRST and TRST are decoupled; but bugs happen ... */
629 switch (new_cfg & (RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST)) {
630 case RESET_SRST_PULLS_TRST:
631 modes[1] = "srst_pulls_trst";
632 break;
633 case RESET_TRST_PULLS_SRST:
634 modes[1] = "trst_pulls_srst";
635 break;
636 case RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST:
637 modes[1] = "combined";
638 break;
639 default:
640 modes[1] = "separate";
641 break;
642 }
643
644 /* TRST-less connectors include Altera, Xilinx, and minimal JTAG */
645 if (new_cfg & RESET_HAS_TRST) {
646 if (new_cfg & RESET_TRST_OPEN_DRAIN)
647 modes[3] = " trst_open_drain";
648 else
649 modes[3] = " trst_push_pull";
650 } else
651 modes[3] = "";
652
653 /* SRST-less connectors include TI-14, Xilinx, and minimal JTAG */
654 if (new_cfg & RESET_HAS_SRST) {
655 if (new_cfg & RESET_SRST_NO_GATING)
656 modes[2] = " srst_nogate";
657 else
658 modes[2] = " srst_gates_jtag";
659
660 if (new_cfg & RESET_SRST_PUSH_PULL)
661 modes[4] = " srst_push_pull";
662 else
663 modes[4] = " srst_open_drain";
664
665 if (new_cfg & RESET_CNCT_UNDER_SRST)
666 modes[5] = " connect_assert_srst";
667 else
668 modes[5] = " connect_deassert_srst";
669 } else {
670 modes[2] = "";
671 modes[4] = "";
672 modes[5] = "";
673 }
674
675 command_print(CMD, "%s %s%s%s%s%s",
676 modes[0], modes[1],
677 modes[2], modes[3], modes[4], modes[5]);
678
679 return ERROR_OK;
680 }
681
682 COMMAND_HANDLER(handle_adapter_srst_delay_command)
683 {
684 if (CMD_ARGC > 1)
685 return ERROR_COMMAND_SYNTAX_ERROR;
686 if (CMD_ARGC == 1) {
687 unsigned delay;
688 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], delay);
689
690 jtag_set_nsrst_delay(delay);
691 }
692 command_print(CMD, "adapter srst delay: %u", jtag_get_nsrst_delay());
693 return ERROR_OK;
694 }
695
696 COMMAND_HANDLER(handle_adapter_srst_pulse_width_command)
697 {
698 if (CMD_ARGC > 1)
699 return ERROR_COMMAND_SYNTAX_ERROR;
700 if (CMD_ARGC == 1) {
701 unsigned width;
702 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], width);
703
704 jtag_set_nsrst_assert_width(width);
705 }
706 command_print(CMD, "adapter srst pulse_width: %u", jtag_get_nsrst_assert_width());
707 return ERROR_OK;
708 }
709
710 COMMAND_HANDLER(handle_adapter_speed_command)
711 {
712 if (CMD_ARGC > 1)
713 return ERROR_COMMAND_SYNTAX_ERROR;
714
715 int retval = ERROR_OK;
716 if (CMD_ARGC == 1) {
717 unsigned khz = 0;
718 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], khz);
719
720 retval = adapter_config_khz(khz);
721 if (retval != ERROR_OK)
722 return retval;
723 }
724
725 int cur_speed = adapter_get_speed_khz();
726 retval = adapter_get_speed_readable(&cur_speed);
727 if (retval != ERROR_OK)
728 return retval;
729
730 if (cur_speed)
731 command_print(CMD, "adapter speed: %d kHz", cur_speed);
732 else
733 command_print(CMD, "adapter speed: RCLK - adaptive");
734
735 return retval;
736 }
737
738 COMMAND_HANDLER(handle_adapter_serial_command)
739 {
740 if (CMD_ARGC != 1)
741 return ERROR_COMMAND_SYNTAX_ERROR;
742
743 free(adapter_config.serial);
744 adapter_config.serial = strdup(CMD_ARGV[0]);
745 return ERROR_OK;
746 }
747
748 COMMAND_HANDLER(handle_adapter_reset_de_assert)
749 {
750 enum values {
751 VALUE_UNDEFINED = -1,
752 VALUE_DEASSERT = 0,
753 VALUE_ASSERT = 1,
754 };
755 enum values value;
756 enum values srst = VALUE_UNDEFINED;
757 enum values trst = VALUE_UNDEFINED;
758 enum reset_types jtag_reset_config = jtag_get_reset_config();
759 char *signal;
760
761 if (CMD_ARGC == 0) {
762 if (transport_is_jtag()) {
763 if (jtag_reset_config & RESET_HAS_TRST)
764 signal = jtag_get_trst() ? "asserted" : "deasserted";
765 else
766 signal = "not present";
767 command_print(CMD, "trst %s", signal);
768 }
769
770 if (jtag_reset_config & RESET_HAS_SRST)
771 signal = jtag_get_srst() ? "asserted" : "deasserted";
772 else
773 signal = "not present";
774 command_print(CMD, "srst %s", signal);
775
776 return ERROR_OK;
777 }
778
779 if (CMD_ARGC != 1 && CMD_ARGC != 3)
780 return ERROR_COMMAND_SYNTAX_ERROR;
781
782 value = (strcmp(CMD_NAME, "assert") == 0) ? VALUE_ASSERT : VALUE_DEASSERT;
783 if (strcmp(CMD_ARGV[0], "srst") == 0)
784 srst = value;
785 else if (strcmp(CMD_ARGV[0], "trst") == 0)
786 trst = value;
787 else
788 return ERROR_COMMAND_SYNTAX_ERROR;
789
790 if (CMD_ARGC == 3) {
791 if (strcmp(CMD_ARGV[1], "assert") == 0)
792 value = VALUE_ASSERT;
793 else if (strcmp(CMD_ARGV[1], "deassert") == 0)
794 value = VALUE_DEASSERT;
795 else
796 return ERROR_COMMAND_SYNTAX_ERROR;
797
798 if (strcmp(CMD_ARGV[2], "srst") == 0 && srst == VALUE_UNDEFINED)
799 srst = value;
800 else if (strcmp(CMD_ARGV[2], "trst") == 0 && trst == VALUE_UNDEFINED)
801 trst = value;
802 else
803 return ERROR_COMMAND_SYNTAX_ERROR;
804 }
805
806 if (trst == VALUE_UNDEFINED) {
807 if (transport_is_jtag())
808 trst = jtag_get_trst() ? VALUE_ASSERT : VALUE_DEASSERT;
809 else
810 trst = VALUE_DEASSERT; /* unused, safe value */
811 }
812
813 if (srst == VALUE_UNDEFINED) {
814 if (jtag_reset_config & RESET_HAS_SRST)
815 srst = jtag_get_srst() ? VALUE_ASSERT : VALUE_DEASSERT;
816 else
817 srst = VALUE_DEASSERT; /* unused, safe value */
818 }
819
820 if (trst == VALUE_ASSERT && !transport_is_jtag()) {
821 LOG_ERROR("transport has no trst signal");
822 return ERROR_FAIL;
823 }
824
825 if (srst == VALUE_ASSERT && !(jtag_reset_config & RESET_HAS_SRST)) {
826 LOG_ERROR("adapter has no srst signal");
827 return ERROR_FAIL;
828 }
829
830 return adapter_resets((trst == VALUE_DEASSERT) ? TRST_DEASSERT : TRST_ASSERT,
831 (srst == VALUE_DEASSERT) ? SRST_DEASSERT : SRST_ASSERT);
832 }
833
834 static int get_gpio_index(const char *signal_name)
835 {
836 for (int i = 0; i < ADAPTER_GPIO_IDX_NUM; ++i) {
837 if (strcmp(gpio_map[i].name, signal_name) == 0)
838 return i;
839 }
840 return -1;
841 }
842
843 static COMMAND_HELPER(helper_adapter_gpio_print_config, enum adapter_gpio_config_index gpio_idx)
844 {
845 struct adapter_gpio_config *gpio_config = &adapter_config.gpios[gpio_idx];
846 const char *active_state = gpio_config->active_low ? "low" : "high";
847 const char *dir = "";
848 const char *drive = "";
849 const char *pull = "";
850 const char *init_state = "";
851
852 if (gpio_config->gpio_num == ADAPTER_GPIO_NOT_SET) {
853 command_print(CMD, "adapter gpio %s: not configured", gpio_map[gpio_idx].name);
854 return ERROR_OK;
855 }
856
857 switch (gpio_map[gpio_idx].direction) {
858 case ADAPTER_GPIO_DIRECTION_INPUT:
859 dir = "input";
860 break;
861 case ADAPTER_GPIO_DIRECTION_OUTPUT:
862 dir = "output";
863 break;
864 case ADAPTER_GPIO_DIRECTION_BIDIRECTIONAL:
865 dir = "bidirectional";
866 break;
867 }
868
869 if (gpio_map[gpio_idx].permit_drive_option) {
870 switch (gpio_config->drive) {
871 case ADAPTER_GPIO_DRIVE_MODE_PUSH_PULL:
872 drive = ", push-pull";
873 break;
874 case ADAPTER_GPIO_DRIVE_MODE_OPEN_DRAIN:
875 drive = ", open-drain";
876 break;
877 case ADAPTER_GPIO_DRIVE_MODE_OPEN_SOURCE:
878 drive = ", open-source";
879 break;
880 }
881 }
882
883 switch (gpio_config->pull) {
884 case ADAPTER_GPIO_PULL_NONE:
885 pull = ", pull-none";
886 break;
887 case ADAPTER_GPIO_PULL_UP:
888 pull = ", pull-up";
889 break;
890 case ADAPTER_GPIO_PULL_DOWN:
891 pull = ", pull-down";
892 break;
893 }
894
895 if (gpio_map[gpio_idx].permit_init_state_option) {
896 switch (gpio_config->init_state) {
897 case ADAPTER_GPIO_INIT_STATE_INACTIVE:
898 init_state = ", init-state inactive";
899 break;
900 case ADAPTER_GPIO_INIT_STATE_ACTIVE:
901 init_state = ", init-state active";
902 break;
903 case ADAPTER_GPIO_INIT_STATE_INPUT:
904 init_state = ", init-state input";
905 break;
906 }
907 }
908
909 command_print(CMD, "adapter gpio %s (%s): num %u, chip %d, active-%s%s%s%s",
910 gpio_map[gpio_idx].name, dir, gpio_config->gpio_num, (int)gpio_config->chip_num, active_state,
911 drive, pull, init_state);
912
913 return ERROR_OK;
914 }
915
916 COMMAND_HANDLER(helper_adapter_gpio_print_all_configs)
917 {
918 for (int i = 0; i < ADAPTER_GPIO_IDX_NUM; ++i)
919 CALL_COMMAND_HANDLER(helper_adapter_gpio_print_config, i);
920 return ERROR_OK;
921 }
922
923 COMMAND_HANDLER(adapter_gpio_config_handler)
924 {
925 unsigned int i = 1;
926 struct adapter_gpio_config *gpio_config;
927
928 adapter_driver_gpios_init();
929
930 if (CMD_ARGC == 0) {
931 CALL_COMMAND_HANDLER(helper_adapter_gpio_print_all_configs);
932 return ERROR_OK;
933 }
934
935 int gpio_idx = get_gpio_index(CMD_ARGV[0]);
936 if (gpio_idx == -1) {
937 LOG_ERROR("adapter has no gpio named %s", CMD_ARGV[0]);
938 return ERROR_COMMAND_SYNTAX_ERROR;
939 }
940
941 if (CMD_ARGC == 1) {
942 CALL_COMMAND_HANDLER(helper_adapter_gpio_print_config, gpio_idx);
943 return ERROR_OK;
944 }
945
946 gpio_config = &adapter_config.gpios[gpio_idx];
947 while (i < CMD_ARGC) {
948 LOG_DEBUG("Processing %s", CMD_ARGV[i]);
949
950 if (isdigit(*CMD_ARGV[i])) {
951 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[i], gpio_config->gpio_num);
952 ++i;
953 continue;
954 }
955
956 if (strcmp(CMD_ARGV[i], "-chip") == 0) {
957 if (CMD_ARGC - i < 2) {
958 LOG_ERROR("-chip option requires a parameter");
959 return ERROR_FAIL;
960 }
961 LOG_DEBUG("-chip arg is %s", CMD_ARGV[i + 1]);
962 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[i + 1], gpio_config->chip_num);
963 i += 2;
964 continue;
965 }
966
967 if (strcmp(CMD_ARGV[i], "-active-high") == 0) {
968 ++i;
969 gpio_config->active_low = false;
970 continue;
971 }
972 if (strcmp(CMD_ARGV[i], "-active-low") == 0) {
973 ++i;
974 gpio_config->active_low = true;
975 continue;
976 }
977
978 if (gpio_map[gpio_idx].permit_drive_option) {
979 if (strcmp(CMD_ARGV[i], "-push-pull") == 0) {
980 ++i;
981 gpio_config->drive = ADAPTER_GPIO_DRIVE_MODE_PUSH_PULL;
982 continue;
983 }
984 if (strcmp(CMD_ARGV[i], "-open-drain") == 0) {
985 ++i;
986 gpio_config->drive = ADAPTER_GPIO_DRIVE_MODE_OPEN_DRAIN;
987 continue;
988 }
989 if (strcmp(CMD_ARGV[i], "-open-source") == 0) {
990 ++i;
991 gpio_config->drive = ADAPTER_GPIO_DRIVE_MODE_OPEN_SOURCE;
992 continue;
993 }
994 }
995
996 if (strcmp(CMD_ARGV[i], "-pull-none") == 0) {
997 ++i;
998 gpio_config->pull = ADAPTER_GPIO_PULL_NONE;
999 continue;
1000 }
1001 if (strcmp(CMD_ARGV[i], "-pull-up") == 0) {
1002 ++i;
1003 gpio_config->pull = ADAPTER_GPIO_PULL_UP;
1004 continue;
1005 }
1006 if (strcmp(CMD_ARGV[i], "-pull-down") == 0) {
1007 ++i;
1008 gpio_config->pull = ADAPTER_GPIO_PULL_DOWN;
1009 continue;
1010 }
1011
1012 if (gpio_map[gpio_idx].permit_init_state_option) {
1013 if (strcmp(CMD_ARGV[i], "-init-inactive") == 0) {
1014 ++i;
1015 gpio_config->init_state = ADAPTER_GPIO_INIT_STATE_INACTIVE;
1016 continue;
1017 }
1018 if (strcmp(CMD_ARGV[i], "-init-active") == 0) {
1019 ++i;
1020 gpio_config->init_state = ADAPTER_GPIO_INIT_STATE_ACTIVE;
1021 continue;
1022 }
1023
1024 if (gpio_map[gpio_idx].direction == ADAPTER_GPIO_DIRECTION_BIDIRECTIONAL &&
1025 strcmp(CMD_ARGV[i], "-init-input") == 0) {
1026 ++i;
1027 gpio_config->init_state = ADAPTER_GPIO_INIT_STATE_INPUT;
1028 continue;
1029 }
1030 }
1031
1032 LOG_ERROR("illegal option for adapter %s %s: %s",
1033 CMD_NAME, gpio_map[gpio_idx].name, CMD_ARGV[i]);
1034 return ERROR_COMMAND_SYNTAX_ERROR;
1035 }
1036
1037 /* Force swdio_dir init state to be compatible with swdio init state */
1038 if (gpio_idx == ADAPTER_GPIO_IDX_SWDIO)
1039 adapter_config.gpios[ADAPTER_GPIO_IDX_SWDIO_DIR].init_state =
1040 (gpio_config->init_state == ADAPTER_GPIO_INIT_STATE_INPUT) ?
1041 ADAPTER_GPIO_INIT_STATE_INACTIVE :
1042 ADAPTER_GPIO_INIT_STATE_ACTIVE;
1043
1044 return ERROR_OK;
1045 }
1046
1047 #ifdef HAVE_LIBUSB_GET_PORT_NUMBERS
1048 COMMAND_HANDLER(handle_usb_location_command)
1049 {
1050 if (CMD_ARGC == 1)
1051 adapter_usb_set_location(CMD_ARGV[0]);
1052
1053 command_print(CMD, "adapter usb location: %s", adapter_usb_get_location());
1054
1055 return ERROR_OK;
1056 }
1057 #endif /* HAVE_LIBUSB_GET_PORT_NUMBERS */
1058
1059 static const struct command_registration adapter_usb_command_handlers[] = {
1060 #ifdef HAVE_LIBUSB_GET_PORT_NUMBERS
1061 {
1062 .name = "location",
1063 .handler = &handle_usb_location_command,
1064 .mode = COMMAND_CONFIG,
1065 .help = "display or set the USB bus location of the USB device",
1066 .usage = "[<bus>-port[.port]...]",
1067 },
1068 #endif /* HAVE_LIBUSB_GET_PORT_NUMBERS */
1069 COMMAND_REGISTRATION_DONE
1070 };
1071
1072 static const struct command_registration adapter_srst_command_handlers[] = {
1073 {
1074 .name = "delay",
1075 .handler = handle_adapter_srst_delay_command,
1076 .mode = COMMAND_ANY,
1077 .help = "delay after deasserting SRST in ms",
1078 .usage = "[milliseconds]",
1079 },
1080 {
1081 .name = "pulse_width",
1082 .handler = handle_adapter_srst_pulse_width_command,
1083 .mode = COMMAND_ANY,
1084 .help = "SRST assertion pulse width in ms",
1085 .usage = "[milliseconds]",
1086 },
1087 COMMAND_REGISTRATION_DONE
1088 };
1089
1090 static const struct command_registration adapter_command_handlers[] = {
1091 {
1092 .name = "driver",
1093 .handler = handle_adapter_driver_command,
1094 .mode = COMMAND_CONFIG,
1095 .help = "Select a debug adapter driver",
1096 .usage = "driver_name",
1097 },
1098 {
1099 .name = "speed",
1100 .handler = handle_adapter_speed_command,
1101 .mode = COMMAND_ANY,
1102 .help = "With an argument, change to the specified maximum "
1103 "jtag speed. For JTAG, 0 KHz signifies adaptive "
1104 "clocking. "
1105 "With or without argument, display current setting.",
1106 .usage = "[khz]",
1107 },
1108 {
1109 .name = "serial",
1110 .handler = handle_adapter_serial_command,
1111 .mode = COMMAND_CONFIG,
1112 .help = "Set the serial number of the adapter",
1113 .usage = "serial_string",
1114 },
1115 {
1116 .name = "list",
1117 .handler = handle_adapter_list_command,
1118 .mode = COMMAND_ANY,
1119 .help = "List all built-in debug adapter drivers",
1120 .usage = "",
1121 },
1122 {
1123 .name = "name",
1124 .mode = COMMAND_ANY,
1125 .handler = handle_adapter_name,
1126 .help = "Returns the name of the currently "
1127 "selected adapter (driver)",
1128 .usage = "",
1129 },
1130 {
1131 .name = "srst",
1132 .mode = COMMAND_ANY,
1133 .help = "srst adapter command group",
1134 .usage = "",
1135 .chain = adapter_srst_command_handlers,
1136 },
1137 {
1138 .name = "transports",
1139 .handler = adapter_transports_command,
1140 .mode = COMMAND_CONFIG,
1141 .help = "Declare transports the adapter supports.",
1142 .usage = "transport ...",
1143 },
1144 {
1145 .name = "usb",
1146 .mode = COMMAND_ANY,
1147 .help = "usb adapter command group",
1148 .usage = "",
1149 .chain = adapter_usb_command_handlers,
1150 },
1151 {
1152 .name = "assert",
1153 .handler = handle_adapter_reset_de_assert,
1154 .mode = COMMAND_EXEC,
1155 .help = "Controls SRST and TRST lines.",
1156 .usage = "|deassert [srst|trst [assert|deassert srst|trst]]",
1157 },
1158 {
1159 .name = "deassert",
1160 .handler = handle_adapter_reset_de_assert,
1161 .mode = COMMAND_EXEC,
1162 .help = "Controls SRST and TRST lines.",
1163 .usage = "|assert [srst|trst [deassert|assert srst|trst]]",
1164 },
1165 {
1166 .name = "gpio",
1167 .handler = adapter_gpio_config_handler,
1168 .mode = COMMAND_CONFIG,
1169 .help = "gpio adapter command group",
1170 .usage = "[ tdo|tdi|tms|tck|trst|swdio|swdio_dir|swclk|srst|led"
1171 "[gpio_number] "
1172 "[-chip chip_number] "
1173 "[-active-high|-active-low] "
1174 "[-push-pull|-open-drain|-open-source] "
1175 "[-pull-none|-pull-up|-pull-down]"
1176 "[-init-inactive|-init-active|-init-input] ]",
1177 },
1178 COMMAND_REGISTRATION_DONE
1179 };
1180
1181 static const struct command_registration interface_command_handlers[] = {
1182 {
1183 .name = "adapter",
1184 .mode = COMMAND_ANY,
1185 .help = "adapter command group",
1186 .usage = "",
1187 .chain = adapter_command_handlers,
1188 },
1189 {
1190 .name = "reset_config",
1191 .handler = handle_reset_config_command,
1192 .mode = COMMAND_ANY,
1193 .help = "configure adapter reset behavior",
1194 .usage = "[none|trst_only|srst_only|trst_and_srst] "
1195 "[srst_pulls_trst|trst_pulls_srst|combined|separate] "
1196 "[srst_gates_jtag|srst_nogate] "
1197 "[trst_push_pull|trst_open_drain] "
1198 "[srst_push_pull|srst_open_drain] "
1199 "[connect_deassert_srst|connect_assert_srst]",
1200 },
1201 COMMAND_REGISTRATION_DONE
1202 };
1203
1204 /**
1205 * Register the commands which deal with arbitrary debug adapter drivers.
1206 *
1207 * @todo Remove internal assumptions that all debug adapters use JTAG for
1208 * transport. Various types and data structures are not named generically.
1209 */
1210 int adapter_register_commands(struct command_context *ctx)
1211 {
1212 return register_commands(ctx, NULL, interface_command_handlers);
1213 }
1214
1215 const char *adapter_gpio_get_name(enum adapter_gpio_config_index idx)
1216 {
1217 return gpio_map[idx].name;
1218 }
1219
1220 /* Allow drivers access to the GPIO configuration */
1221 const struct adapter_gpio_config *adapter_gpio_get_config(void)
1222 {
1223 return adapter_config.gpios;
1224 }
Official OpenOCD Mirror