+enum adapter_clk_mode {
+ CLOCK_MODE_UNSELECTED = 0,
+ CLOCK_MODE_KHZ,
+ CLOCK_MODE_RCLK
+};
+
+#define DEFAULT_CLOCK_SPEED_KHZ 100U
+
+/**
+ * Adapter configuration
+ */
+static struct {
+ bool adapter_initialized;
+ char *usb_location;
+ char *serial;
+ enum adapter_clk_mode clock_mode;
+ int speed_khz;
+ int rclk_fallback_speed_khz;
+ struct adapter_gpio_config gpios[ADAPTER_GPIO_IDX_NUM];
+ bool gpios_initialized; /* Initialization of GPIOs to their unset values performed at run time */
+} adapter_config;
+
+static const struct gpio_map {
+ const char *name;
+ enum adapter_gpio_direction direction;
+ bool permit_drive_option;
+ bool permit_init_state_option;
+} gpio_map[ADAPTER_GPIO_IDX_NUM] = {
+ [ADAPTER_GPIO_IDX_TDO] = { "tdo", ADAPTER_GPIO_DIRECTION_INPUT, false, true, },
+ [ADAPTER_GPIO_IDX_TDI] = { "tdi", ADAPTER_GPIO_DIRECTION_OUTPUT, true, true, },
+ [ADAPTER_GPIO_IDX_TMS] = { "tms", ADAPTER_GPIO_DIRECTION_OUTPUT, true, true, },
+ [ADAPTER_GPIO_IDX_TCK] = { "tck", ADAPTER_GPIO_DIRECTION_OUTPUT, true, true, },
+ [ADAPTER_GPIO_IDX_SWDIO] = { "swdio", ADAPTER_GPIO_DIRECTION_BIDIRECTIONAL, true, true, },
+ [ADAPTER_GPIO_IDX_SWDIO_DIR] = { "swdio_dir", ADAPTER_GPIO_DIRECTION_OUTPUT, true, false, },
+ [ADAPTER_GPIO_IDX_SWCLK] = { "swclk", ADAPTER_GPIO_DIRECTION_OUTPUT, true, true, },
+ [ADAPTER_GPIO_IDX_TRST] = { "trst", ADAPTER_GPIO_DIRECTION_OUTPUT, false, true, },
+ [ADAPTER_GPIO_IDX_SRST] = { "srst", ADAPTER_GPIO_DIRECTION_OUTPUT, false, true, },
+ [ADAPTER_GPIO_IDX_LED] = { "led", ADAPTER_GPIO_DIRECTION_OUTPUT, true, true, },
+};
+
+bool is_adapter_initialized(void)
+{
+ return adapter_config.adapter_initialized;
+}
+
+/* For convenience of the bit-banging drivers keep the gpio_config drive
+ * settings for srst and trst in sync with values set by the "adapter
+ * reset_config" command.
+ */
+static void sync_adapter_reset_with_gpios(void)
+{
+ enum reset_types cfg = jtag_get_reset_config();
+ if (cfg & RESET_SRST_PUSH_PULL)
+ adapter_config.gpios[ADAPTER_GPIO_IDX_SRST].drive = ADAPTER_GPIO_DRIVE_MODE_PUSH_PULL;
+ else
+ adapter_config.gpios[ADAPTER_GPIO_IDX_SRST].drive = ADAPTER_GPIO_DRIVE_MODE_OPEN_DRAIN;
+ if (cfg & RESET_TRST_OPEN_DRAIN)
+ adapter_config.gpios[ADAPTER_GPIO_IDX_TRST].drive = ADAPTER_GPIO_DRIVE_MODE_OPEN_DRAIN;
+ else
+ adapter_config.gpios[ADAPTER_GPIO_IDX_TRST].drive = ADAPTER_GPIO_DRIVE_MODE_PUSH_PULL;
+}
+
+static void adapter_driver_gpios_init(void)
+{
+ if (adapter_config.gpios_initialized)
+ return;
+
+ for (int i = 0; i < ADAPTER_GPIO_IDX_NUM; ++i) {
+ /* Use ADAPTER_GPIO_NOT_SET as the sentinel 'unset' value. */
+ adapter_config.gpios[i].gpio_num = ADAPTER_GPIO_NOT_SET;
+ adapter_config.gpios[i].chip_num = ADAPTER_GPIO_NOT_SET;
+ if (gpio_map[i].direction == ADAPTER_GPIO_DIRECTION_INPUT)
+ adapter_config.gpios[i].init_state = ADAPTER_GPIO_INIT_STATE_INPUT;
+ }
+
+ /* Drivers assume active low, and this is the normal behaviour for reset
+ * lines so should be the default. */
+ adapter_config.gpios[ADAPTER_GPIO_IDX_SRST].active_low = true;
+ adapter_config.gpios[ADAPTER_GPIO_IDX_TRST].active_low = true;
+ sync_adapter_reset_with_gpios();
+
+ /* JTAG GPIOs should be inactive except for tms */
+ adapter_config.gpios[ADAPTER_GPIO_IDX_TMS].init_state = ADAPTER_GPIO_INIT_STATE_ACTIVE;
+
+ adapter_config.gpios_initialized = true;
+}
+
+/**
+ * Do low-level setup like initializing registers, output signals,
+ * and clocking.
+ */
+int adapter_init(struct command_context *cmd_ctx)
+{
+ if (is_adapter_initialized())
+ return ERROR_OK;
+
+ if (!adapter_driver) {
+ /* nothing was previously specified by "adapter driver" command */
+ LOG_ERROR("Debug Adapter has to be specified, "
+ "see \"adapter driver\" command");
+ return ERROR_JTAG_INVALID_INTERFACE;
+ }
+
+ adapter_driver_gpios_init();
+
+ int retval;
+
+ /* If the adapter supports configurable speed but the speed is not configured,
+ * provide a hint to the user. */
+ if (adapter_driver->speed && adapter_config.clock_mode == CLOCK_MODE_UNSELECTED) {
+ LOG_WARNING("An adapter speed is not selected in the init scripts."
+ " OpenOCD will try to run the adapter at very low speed (%d kHz).",
+ DEFAULT_CLOCK_SPEED_KHZ);
+ LOG_WARNING("To remove this warnings and achieve reasonable communication speed with the target,"
+ " set \"adapter speed\" or \"jtag_rclk\" in the init scripts.");
+ retval = adapter_config_khz(DEFAULT_CLOCK_SPEED_KHZ);
+ if (retval != ERROR_OK)
+ return ERROR_JTAG_INIT_FAILED;
+ }
+
+ retval = adapter_driver->init();
+ if (retval != ERROR_OK)
+ return retval;
+ adapter_config.adapter_initialized = true;
+
+ if (!adapter_driver->speed) {
+ LOG_INFO("Note: The adapter \"%s\" doesn't support configurable speed", adapter_driver->name);
+ return ERROR_OK;
+ }
+
+ int requested_khz = adapter_get_speed_khz();
+ int actual_khz = requested_khz;
+ int speed_var = 0;
+ retval = adapter_get_speed(&speed_var);
+ if (retval != ERROR_OK)
+ return retval;
+ retval = adapter_driver->speed(speed_var);
+ if (retval != ERROR_OK)
+ return retval;
+ retval = adapter_get_speed_readable(&actual_khz);
+ if (retval != ERROR_OK)
+ LOG_INFO("adapter-specific clock speed value %d", speed_var);
+ else if (actual_khz) {
+ /* Adaptive clocking -- JTAG-specific */
+ if ((adapter_config.clock_mode == CLOCK_MODE_RCLK)
+ || ((adapter_config.clock_mode == CLOCK_MODE_KHZ) && !requested_khz)) {
+ LOG_INFO("RCLK (adaptive clock speed) not supported - fallback to %d kHz"
+ , actual_khz);
+ } else
+ LOG_INFO("clock speed %d kHz", actual_khz);
+ } else
+ LOG_INFO("RCLK (adaptive clock speed)");
+
+ return ERROR_OK;
+}
+
+int adapter_quit(void)
+{
+ if (is_adapter_initialized() && adapter_driver->quit) {
+ /* close the JTAG interface */
+ int result = adapter_driver->quit();
+ if (result != ERROR_OK)
+ LOG_ERROR("failed: %d", result);
+ }
+
+ free(adapter_config.serial);
+ free(adapter_config.usb_location);
+
+ struct jtag_tap *t = jtag_all_taps();
+ while (t) {
+ struct jtag_tap *n = t->next_tap;
+ jtag_tap_free(t);
+ t = n;
+ }
+
+ return ERROR_OK;
+}
+
+unsigned int adapter_get_speed_khz(void)
+{
+ return adapter_config.speed_khz;
+}
+
+static int adapter_khz_to_speed(unsigned int khz, int *speed)
+{
+ LOG_DEBUG("convert khz to adapter specific speed value");
+ adapter_config.speed_khz = khz;
+ if (!is_adapter_initialized())
+ return ERROR_OK;
+ LOG_DEBUG("have adapter set up");
+ if (!adapter_driver->khz) {
+ LOG_ERROR("Translation from khz to adapter speed not implemented");
+ return ERROR_FAIL;
+ }
+ int speed_div1;
+ int retval = adapter_driver->khz(adapter_get_speed_khz(), &speed_div1);
+ if (retval != ERROR_OK)
+ return retval;
+ *speed = speed_div1;
+ return ERROR_OK;
+}
+
+static int adapter_rclk_to_speed(unsigned int fallback_speed_khz, int *speed)
+{
+ int retval = adapter_khz_to_speed(0, speed);
+ if ((retval != ERROR_OK) && fallback_speed_khz) {
+ LOG_DEBUG("trying fallback speed...");
+ retval = adapter_khz_to_speed(fallback_speed_khz, speed);
+ }
+ return retval;
+}
+
+static int adapter_set_speed(int speed)
+{
+ /* this command can be called during CONFIG,
+ * in which case adapter isn't initialized */
+ return is_adapter_initialized() ? adapter_driver->speed(speed) : ERROR_OK;
+}
+
+int adapter_config_khz(unsigned int khz)
+{
+ LOG_DEBUG("handle adapter khz");
+ adapter_config.clock_mode = CLOCK_MODE_KHZ;
+ int speed = 0;
+ int retval = adapter_khz_to_speed(khz, &speed);
+ return (retval != ERROR_OK) ? retval : adapter_set_speed(speed);
+}
+
+int adapter_config_rclk(unsigned int fallback_speed_khz)
+{
+ LOG_DEBUG("handle adapter rclk");
+ adapter_config.clock_mode = CLOCK_MODE_RCLK;
+ adapter_config.rclk_fallback_speed_khz = fallback_speed_khz;
+ int speed = 0;
+ int retval = adapter_rclk_to_speed(fallback_speed_khz, &speed);
+ return (retval != ERROR_OK) ? retval : adapter_set_speed(speed);
+}
+
+int adapter_get_speed(int *speed)
+{
+ switch (adapter_config.clock_mode) {
+ case CLOCK_MODE_KHZ:
+ adapter_khz_to_speed(adapter_get_speed_khz(), speed);
+ break;
+ case CLOCK_MODE_RCLK:
+ adapter_rclk_to_speed(adapter_config.rclk_fallback_speed_khz, speed);
+ break;
+ default:
+ LOG_ERROR("BUG: unknown adapter clock mode");
+ return ERROR_FAIL;
+ }
+ return ERROR_OK;
+}
+
+int adapter_get_speed_readable(int *khz)
+{
+ int speed_var = 0;
+ int retval = adapter_get_speed(&speed_var);
+ if (retval != ERROR_OK)
+ return retval;
+ if (!is_adapter_initialized())
+ return ERROR_OK;
+ if (!adapter_driver->speed_div) {
+ LOG_ERROR("Translation from adapter speed to khz not implemented");
+ return ERROR_FAIL;
+ }
+ return adapter_driver->speed_div(speed_var, khz);
+}
+
+const char *adapter_get_required_serial(void)
+{
+ return adapter_config.serial;
+}
+
+/*
+ * 1 char: bus
+ * 2 * 7 chars: max 7 ports
+ * 1 char: test for overflow
+ * ------
+ * 16 chars
+ */
+#define USB_MAX_LOCATION_LENGTH 16
+
+#ifdef HAVE_LIBUSB_GET_PORT_NUMBERS
+static void adapter_usb_set_location(const char *location)
+{
+ if (strnlen(location, USB_MAX_LOCATION_LENGTH) == USB_MAX_LOCATION_LENGTH)
+ LOG_WARNING("usb location string is too long!!");
+
+ free(adapter_config.usb_location);
+
+ adapter_config.usb_location = strndup(location, USB_MAX_LOCATION_LENGTH);
+}
+#endif /* HAVE_LIBUSB_GET_PORT_NUMBERS */
+
+const char *adapter_usb_get_location(void)
+{
+ return adapter_config.usb_location;
+}
+
+bool adapter_usb_location_equal(uint8_t dev_bus, uint8_t *port_path, size_t path_len)