Menu
▾
▴
[OpenOCD-devel] [PATCH]: efda740 Add Q&D aspeed JTAG for the version that's currently in OpenBMC
|
From: <ge...@op...> - 2020-12-14 09:36:49
|
This is an automated email from Gerrit. Paul Fertser (fer...@gm...) just uploaded a new patch set to Gerrit, which you can find at http://openocd.zylin.com/5976 -- gerrit commit efda740f669c82f48c107810510349d014d3d9d3 Author: Paul Fertser <fer...@gm...> Date: Tue Dec 1 13:16:55 2020 +0000 Add Q&D aspeed JTAG for the version that's currently in OpenBMC Change-Id: I223e997af1ebef56b81293110534874edd1da32a Signed-off-by: Paul Fertser <fer...@gm...> diff --git a/src/jtag/drivers/Makefile.am b/src/jtag/drivers/Makefile.am index 572cd24..0547604 100644 --- a/src/jtag/drivers/Makefile.am +++ b/src/jtag/drivers/Makefile.am @@ -15,7 +15,7 @@ EXTRA_DIST += $(ULINK_FIRMWARE) \ %D%/rlink_call.m4 \ %D%/rlink_init.m4 -DRIVERFILES = +DRIVERFILES = %D%/kernel_jtag.c # Standard Driver: common files DRIVERFILES += %D%/driver.c @@ -165,6 +165,7 @@ DRIVERFILES += %D%/xds110.c endif DRIVERHEADERS = \ + %D%/kernel_jtag.h \ %D%/bitbang.h \ %D%/bitq.h \ %D%/jtag_usb_common.h \ diff --git a/src/jtag/drivers/kernel_jtag.c b/src/jtag/drivers/kernel_jtag.c new file mode 100644 index 0000000..094fd83 --- /dev/null +++ b/src/jtag/drivers/kernel_jtag.c @@ -0,0 +1,430 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright (C) 2020 Gagar.IN LLC + * by Paul Fertser <fer...@gm...> + * + * Copyright (C) 2012 by Andreas Fritiofson + * and...@gm... + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +/* project specific includes */ +#include <jtag/drivers/jtag_usb_common.h> +#include <jtag/interface.h> +#include <transport/transport.h> +#include <helper/time_support.h> + +#include <assert.h> + +#include "kernel_jtag.h" +#include <sys/ioctl.h> + +static int jtag_fd; + +static uint8_t tap_state_to_kernel(tap_state_t state) +{ + switch (state) { + case TAP_DREXIT2: + return JTAG_STATE_EXIT2DR; + case TAP_DREXIT1: + return JTAG_STATE_EXIT1DR; + case TAP_DRSHIFT: + return JTAG_STATE_SHIFTDR; + case TAP_DRPAUSE: + return JTAG_STATE_PAUSEDR; + case TAP_IRSELECT: + return JTAG_STATE_SELECTIR; + case TAP_DRUPDATE: + return JTAG_STATE_UPDATEDR; + case TAP_DRCAPTURE: + return JTAG_STATE_CAPTUREDR; + case TAP_DRSELECT: + return JTAG_STATE_SELECTDR; + case TAP_IREXIT2: + return JTAG_STATE_EXIT2IR; + case TAP_IREXIT1: + return JTAG_STATE_EXIT1IR; + case TAP_IRSHIFT: + return JTAG_STATE_SHIFTIR; + case TAP_IRPAUSE: + return JTAG_STATE_PAUSEIR; + case TAP_IDLE: + return JTAG_STATE_IDLE; + case TAP_IRUPDATE: + return JTAG_STATE_UPDATEIR; + case TAP_IRCAPTURE: + return JTAG_STATE_CAPTUREIR; + case TAP_RESET: + return JTAG_STATE_TLRESET; + case TAP_INVALID: + default: + return JTAG_STATE_UPDATEIR + 1; + } +} + +/** + * Function move_to_state + * moves the TAP controller from the current state to a + * \a goal_state through a path given by tap_get_tms_path(). State transition + * logging is performed by delegation to clock_tms(). + * + * @param goal_state is the destination state for the move. + */ +static int move_to_state(tap_state_t goal_state) +{ + tap_state_t start_state = tap_get_state(); + + /* goal_state is 1/2 of a tuple/pair of states which allow convenient + lookup of the required TMS pattern to move to this state from the + start state. + */ + + /* do the 2 lookups */ + uint8_t tms_bits = tap_get_tms_path(start_state, goal_state); + int tms_count = tap_get_tms_path_len(start_state, goal_state); + assert(tms_count <= 8); + + LOG_DEBUG_IO("start=%s goal=%s", tap_state_name(start_state), tap_state_name(goal_state)); + + /* Track state transitions step by step */ + for (int i = 0; i < tms_count; i++) + tap_set_state(tap_state_transition(tap_get_state(), (tms_bits >> i) & 1)); + + struct jtag_end_tap_state endstate; + endstate.endstate = tap_state_to_kernel(goal_state); + endstate.reset = JTAG_NO_RESET; + endstate.tck = 0; + int retval = ioctl(jtag_fd, JTAG_SIOCSTATE, &endstate); + if (retval < 0) { + LOG_ERROR("couldn't set move to state"); + return ERROR_FAIL; + } + return ERROR_OK; +} + +static int kernel_jtag_speed(int speed) +{ + int retval; + uint32_t freq = speed; + + retval = ioctl(jtag_fd, JTAG_SIOCFREQ, &freq); + + if (retval < 0) { + LOG_ERROR("couldn't set JTAG TCK speed"); + return ERROR_FAIL; + } + + return ERROR_OK; +} + +static int kernel_jtag_speed_div(int speed, int *khz) +{ + *khz = speed / 1000; + return ERROR_OK; +} + +static int kernel_jtag_khz(int khz, int *jtag_speed) +{ + if (khz == 0) { + /* TODO */ + LOG_DEBUG("RCLK not supported"); + return ERROR_FAIL; + } + + *jtag_speed = khz * 1000; + return ERROR_OK; +} + +static void kernel_jtag_end_state(tap_state_t state) +{ + if (tap_is_state_stable(state)) + tap_set_end_state(state); + else { + LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state)); + exit(-1); + } +} + +static void kernel_jtag_execute_runtest(struct jtag_command *cmd) +{ + LOG_DEBUG_IO("runtest %i cycles, end in %s", + cmd->cmd.runtest->num_cycles, + tap_state_name(cmd->cmd.runtest->end_state)); + + if (tap_get_state() != TAP_IDLE) + move_to_state(TAP_IDLE); + + /* TODO: Reuse kernel_jtag_execute_stableclocks */ + + move_to_state(TAP_IDLE); + + struct tck_bitbang bitbang; + bitbang.tms = 0; + bitbang.tdi = 0; + + for (int i = 0; i < cmd->cmd.runtest->num_cycles; i++) { + int retval = ioctl(jtag_fd, JTAG_IOCBITBANG, &bitbang); + if (retval < 0) { + LOG_ERROR("CBITBANG error"); + return ERROR_FAIL; + } + } + + kernel_jtag_end_state(cmd->cmd.runtest->end_state); + + if (tap_get_state() != tap_get_end_state()) + move_to_state(tap_get_end_state()); + + LOG_DEBUG_IO("runtest: %i, end in %s", + cmd->cmd.runtest->num_cycles, + tap_state_name(tap_get_end_state())); +} + +static void kernel_jtag_execute_statemove(struct jtag_command *cmd) +{ + LOG_DEBUG_IO("statemove end in %s", + tap_state_name(cmd->cmd.statemove->end_state)); + + kernel_jtag_end_state(cmd->cmd.statemove->end_state); + + /* shortest-path move to desired end state */ + if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET) + move_to_state(tap_get_end_state()); +} + +static void kernel_jtag_execute_pathmove(struct jtag_command *cmd) +{ + tap_state_t *path = cmd->cmd.pathmove->path; + int num_states = cmd->cmd.pathmove->num_states; + + LOG_DEBUG_IO("pathmove: %i states, current: %s end: %s", num_states, + tap_state_name(tap_get_state()), + tap_state_name(path[num_states-1])); + + int state_count = 0; + unsigned bit_count = 0; + uint8_t tms_byte = 0; + + LOG_DEBUG_IO("-"); + + /* this loop verifies that the path is legal and logs each state in the path */ + while (num_states--) { + + /* either TMS=0 or TMS=1 must work ... */ + if (tap_state_transition(tap_get_state(), false) + == path[state_count]) + buf_set_u32(&tms_byte, bit_count++, 1, 0x0); + else if (tap_state_transition(tap_get_state(), true) + == path[state_count]) { + buf_set_u32(&tms_byte, bit_count++, 1, 0x1); + + /* ... or else the caller goofed BADLY */ + } else { + LOG_ERROR("BUG: %s -> %s isn't a valid " + "TAP state transition", + tap_state_name(tap_get_state()), + tap_state_name(path[state_count])); + exit(-1); + } + + tap_set_state(path[state_count]); + state_count++; + + if (bit_count == 7 || num_states == 0) { + /* TODO mpsse_clock_tms_cs_out(mpsse_ctx, + &tms_byte, + 0, + bit_count, + false, + ftdi_jtag_mode); */ + bit_count = 0; + } + } + tap_set_end_state(tap_get_state()); + move_to_state(tap_get_state()); +} + +static void kernel_jtag_execute_scan(struct jtag_command *cmd) +{ + LOG_DEBUG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", + jtag_scan_type(cmd->cmd.scan)); + + /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */ + while (cmd->cmd.scan->num_fields > 0 + && cmd->cmd.scan->fields[cmd->cmd.scan->num_fields - 1].num_bits == 0) { + cmd->cmd.scan->num_fields--; + LOG_DEBUG_IO("discarding trailing empty field"); + } + + if (cmd->cmd.scan->num_fields == 0) { + LOG_DEBUG_IO("empty scan, doing nothing"); + return; + } + + kernel_jtag_end_state(cmd->cmd.scan->end_state); + + struct scan_field *field = cmd->cmd.scan->fields; + unsigned scan_size = 0; + struct jtag_xfer xfer; + xfer.type = cmd->cmd.scan->ir_scan ? JTAG_SIR_XFER : JTAG_SDR_XFER; + /* TODO why doesn't this work ... + * xfer.endstate = cmd->cmd.scan->ir_scan ? JTAG_STATE_PAUSEIR : JTAG_STATE_PAUSEDR; + */ + xfer.endstate = JTAG_STATE_IDLE; + xfer.padding = 0; + + for (int i = 0; i < cmd->cmd.scan->num_fields; i++, field++) { + scan_size += field->num_bits; + LOG_DEBUG_IO("%s%s field %d/%d %d bits", + field->in_value ? "in" : "", + field->out_value ? "out" : "", + i, + cmd->cmd.scan->num_fields, + field->num_bits); + + xfer.length = field->num_bits; + + /*if (i == cmd->cmd.scan->num_fields - 1) + xfer.endstate = tap_state_to_kernel(tap_get_end_state());*/ + + if (field->in_value && field->out_value) + xfer.direction = JTAG_READ_WRITE_XFER; + else if (field->in_value) + xfer.direction = JTAG_READ_XFER; + else + xfer.direction = JTAG_WRITE_XFER; + + if (field->out_value) + xfer.tdio = (uint64_t)(uintptr_t)field->out_value; + else + xfer.tdio = (uint64_t)(uintptr_t)field->in_value; + + int retval = ioctl(jtag_fd, JTAG_IOCXFER, &xfer); + if (retval < 0) { + LOG_ERROR("Error doing JTAG_IOCXFER"); + return; + } + + if (field->in_value && field->out_value) + bit_copy(field->in_value, 0, field->out_value, 0, field->num_bits); + } + + tap_set_state(tap_get_end_state()); + + LOG_DEBUG_IO("%s scan, %i bits, end in %s", + (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size, + tap_state_name(tap_get_end_state())); +} + +static void kernel_jtag_execute_sleep(struct jtag_command *cmd) +{ + LOG_DEBUG_IO("sleep %" PRIi32, cmd->cmd.sleep->us); + + jtag_sleep(cmd->cmd.sleep->us); + LOG_DEBUG_IO("sleep %" PRIi32 " usec while in %s", + cmd->cmd.sleep->us, + tap_state_name(tap_get_state())); +} + +static void kernel_jtag_execute_stableclocks(struct jtag_command *cmd) +{ + /* this is only allowed while in a stable state. A check for a stable + * state was done in jtag_add_clocks() + */ + move_to_state(TAP_IDLE); + + struct tck_bitbang bitbang; + bitbang.tms = 0; + bitbang.tdi = 0; + + for (int i = 0; i < cmd->cmd.runtest->num_cycles; i++) { + int retval = ioctl(jtag_fd, JTAG_IOCBITBANG, &bitbang); + if (retval < 0) { + LOG_ERROR("CBITBANG error"); + return ERROR_FAIL; + } + } + + LOG_DEBUG_IO("clocks %i while in %s", + cmd->cmd.stableclocks->num_cycles, + tap_state_name(tap_get_state())); +} + +static void kernel_jtag_execute_command(struct jtag_command *cmd) +{ + switch (cmd->type) { + case JTAG_RESET: + /* TODO kernel_jtag_execute_reset(cmd); */ + break; + case JTAG_RUNTEST: + kernel_jtag_execute_runtest(cmd); + break; + case JTAG_TLR_RESET: + kernel_jtag_execute_statemove(cmd); + break; + case JTAG_PATHMOVE: + kernel_jtag_execute_pathmove(cmd); + break; + case JTAG_SCAN: + kernel_jtag_execute_scan(cmd); + break; + case JTAG_SLEEP: + kernel_jtag_execute_sleep(cmd); + break; + case JTAG_STABLECLOCKS: + kernel_jtag_execute_stableclocks(cmd); + break; + case JTAG_TMS: + /* TODO kernel_jtag_execute_tms(cmd); */ + break; + default: + LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd->type); + break; + } +} + +static int kernel_jtag_initialize(void) +{ + jtag_fd = open("/dev/jtag0", O_RDWR); + kernel_jtag_speed(jtag_get_speed_khz() * 1000); + + /* TODO HW mode doesn't work */ + struct jtag_mode mode = { .feature = JTAG_XFER_MODE, + .mode = JTAG_XFER_SW_MODE }; + ioctl(jtag_fd, JTAG_SIOCMODE, &mode); + + return ERROR_OK; +} + +static int kernel_jtag_quit(void) +{ + close(jtag_fd); + return ERROR_OK; +} + +static int kernel_jtag_execute_queue(void) +{ + for (struct jtag_command *cmd = jtag_command_queue; cmd; cmd = cmd->next) { + kernel_jtag_execute_command(cmd); + } + + return ERROR_OK; +} + +static const char * const kernel_jtag_transports[] = { "jtag", NULL }; + +struct jtag_interface kernel_jtag_interface = { + .name = "kernel_jtag", + /* TODO .supported = DEBUG_CAP_TMS_SEQ, */ + .transports = kernel_jtag_transports, + + .init = kernel_jtag_initialize, + .quit = kernel_jtag_quit, + .speed = kernel_jtag_speed, + .speed_div = kernel_jtag_speed_div, + .khz = kernel_jtag_khz, + .execute_queue = kernel_jtag_execute_queue, +}; diff --git a/src/jtag/drivers/kernel_jtag.h b/src/jtag/drivers/kernel_jtag.h new file mode 100644 index 0000000..7cc4e4e --- /dev/null +++ b/src/jtag/drivers/kernel_jtag.h @@ -0,0 +1,196 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +// include/uapi/linux/jtag.h - JTAG class driver uapi +// +// Copyright (c) 2018 Mellanox Technologies. All rights reserved. +// Copyright (c) 2018 Oleksandr Shamray <ole...@me...> + +#ifndef __UAPI_LINUX_JTAG_H +#define __UAPI_LINUX_JTAG_H + +#include <linux/types.h> + +/* + * JTAG_XFER_MODE: JTAG transfer mode. Used to set JTAG controller transfer mode + * This is bitmask for feature param in jtag_mode for ioctl JTAG_SIOCMODE + */ +#define JTAG_XFER_MODE 0 +/* + * JTAG_CONTROL_MODE: JTAG controller mode. Used to set JTAG controller mode + * This is bitmask for feature param in jtag_mode for ioctl JTAG_SIOCMODE + */ +#define JTAG_CONTROL_MODE 1 +/* + * JTAG_SLAVE_MODE: JTAG slave mode. Used to set JTAG controller slave mode + * This is bitmask for mode param in jtag_mode for ioctl JTAG_SIOCMODE + */ +#define JTAG_SLAVE_MODE 0 +/* + * JTAG_MASTER_MODE: JTAG master mode. Used to set JTAG controller master mode + * This is bitmask for mode param in jtag_mode for ioctl JTAG_SIOCMODE + */ +#define JTAG_MASTER_MODE 1 +/* + * JTAG_XFER_HW_MODE: JTAG hardware mode. Used to set HW drived or bitbang + * mode. This is bitmask for mode param in jtag_mode for ioctl JTAG_SIOCMODE + */ +#define JTAG_XFER_HW_MODE 1 +/* + * JTAG_XFER_SW_MODE: JTAG software mode. Used to set SW drived or bitbang + * mode. This is bitmask for mode param in jtag_mode for ioctl JTAG_SIOCMODE + */ +#define JTAG_XFER_SW_MODE 0 + +/** + * enum jtag_endstate: + * + * @JTAG_STATE_TLRESET: JTAG state machine Test Logic Reset state + * @JTAG_STATE_IDLE: JTAG state machine IDLE state + * @JTAG_STATE_SELECTDR: JTAG state machine SELECT_DR state + * @JTAG_STATE_CAPTUREDR: JTAG state machine CAPTURE_DR state + * @JTAG_STATE_SHIFTDR: JTAG state machine SHIFT_DR state + * @JTAG_STATE_EXIT1DR: JTAG state machine EXIT-1 DR state + * @JTAG_STATE_PAUSEDR: JTAG state machine PAUSE_DR state + * @JTAG_STATE_EXIT2DR: JTAG state machine EXIT-2 DR state + * @JTAG_STATE_UPDATEDR: JTAG state machine UPDATE DR state + * @JTAG_STATE_SELECTIR: JTAG state machine SELECT_IR state + * @JTAG_STATE_CAPTUREIR: JTAG state machine CAPTURE_IR state + * @JTAG_STATE_SHIFTIR: JTAG state machine SHIFT_IR state + * @JTAG_STATE_EXIT1IR: JTAG state machine EXIT-1 IR state + * @JTAG_STATE_PAUSEIR: JTAG state machine PAUSE_IR state + * @JTAG_STATE_EXIT2IR: JTAG state machine EXIT-2 IR state + * @JTAG_STATE_UPDATEIR: JTAG state machine UPDATE IR state + */ +enum jtag_endstate { + JTAG_STATE_TLRESET, + JTAG_STATE_IDLE, + JTAG_STATE_SELECTDR, + JTAG_STATE_CAPTUREDR, + JTAG_STATE_SHIFTDR, + JTAG_STATE_EXIT1DR, + JTAG_STATE_PAUSEDR, + JTAG_STATE_EXIT2DR, + JTAG_STATE_UPDATEDR, + JTAG_STATE_SELECTIR, + JTAG_STATE_CAPTUREIR, + JTAG_STATE_SHIFTIR, + JTAG_STATE_EXIT1IR, + JTAG_STATE_PAUSEIR, + JTAG_STATE_EXIT2IR, + JTAG_STATE_UPDATEIR +}; + +/** + * enum jtag_reset: + * + * @JTAG_NO_RESET: JTAG run TAP from current state + * @JTAG_FORCE_RESET: JTAG force TAP to reset state + */ +enum jtag_reset { + JTAG_NO_RESET = 0, + JTAG_FORCE_RESET = 1, +}; + +/** + * enum jtag_xfer_type: + * + * @JTAG_SIR_XFER: SIR transfer + * @JTAG_SDR_XFER: SDR transfer + */ +enum jtag_xfer_type { + JTAG_SIR_XFER = 0, + JTAG_SDR_XFER = 1, +}; + +/** + * enum jtag_xfer_direction: + * + * @JTAG_READ_XFER: read transfer + * @JTAG_WRITE_XFER: write transfer + * @JTAG_READ_WRITE_XFER: read & write transfer + */ +enum jtag_xfer_direction { + JTAG_READ_XFER = 1, + JTAG_WRITE_XFER = 2, + JTAG_READ_WRITE_XFER = 3, +}; + +/** + * struct jtag_end_tap_state - forces JTAG state machine to go into a TAPC + * state + * + * @reset: 0 - run IDLE/PAUSE from current state + * 1 - go through TEST_LOGIC/RESET state before IDLE/PAUSE + * @end: completion flag + * @tck: clock counter + * + * Structure provide interface to JTAG device for JTAG set state execution. + */ +struct jtag_end_tap_state { + __u8 reset; + __u8 endstate; + __u8 tck; +}; + +/** + * struct jtag_xfer - jtag xfer: + * + * @type: transfer type + * @direction: xfer direction + * @length: xfer bits len + * @tdio : xfer data array + * @endir: xfer end state + * + * Structure provide interface to JTAG device for JTAG SDR/SIR xfer execution. + */ +struct jtag_xfer { + __u8 type; + __u8 direction; + __u8 endstate; + __u8 padding; + __u32 length; + __u64 tdio; +}; + +/** + * struct jtag_bitbang - jtag bitbang: + * + * @tms: JTAG TMS + * @tdi: JTAG TDI (input) + * @tdo: JTAG TDO (output) + * + * Structure provide interface to JTAG device for JTAG bitbang execution. + */ +struct tck_bitbang { + __u8 tms; + __u8 tdi; + __u8 tdo; +} __attribute__((__packed__)); + +/** + * struct jtag_mode - jtag mode: + * + * @feature: 0 - JTAG feature setting selector for JTAG controller HW/SW + * 1 - JTAG feature setting selector for controller + * bus(master/slave) mode. + * @mode: (0 - SW / 1 - HW) for JTAG_XFER_MODE feature(0) + * (0 - Slave / 1 - Master) for JTAG_CONTROL_MODE feature(1) + * + * Structure provide configuration modes to JTAG device. + */ +struct jtag_mode { + __u32 feature; + __u32 mode; +}; + +/* ioctl interface */ +#define __JTAG_IOCTL_MAGIC 0xb2 + +#define JTAG_SIOCSTATE _IOW(__JTAG_IOCTL_MAGIC, 0, struct jtag_end_tap_state) +#define JTAG_SIOCFREQ _IOW(__JTAG_IOCTL_MAGIC, 1, unsigned int) +#define JTAG_GIOCFREQ _IOR(__JTAG_IOCTL_MAGIC, 2, unsigned int) +#define JTAG_IOCXFER _IOWR(__JTAG_IOCTL_MAGIC, 3, struct jtag_xfer) +#define JTAG_GIOCSTATUS _IOWR(__JTAG_IOCTL_MAGIC, 4, enum jtag_endstate) +#define JTAG_SIOCMODE _IOW(__JTAG_IOCTL_MAGIC, 5, unsigned int) +#define JTAG_IOCBITBANG _IOW(__JTAG_IOCTL_MAGIC, 6, unsigned int) + +#endif /* __UAPI_LINUX_JTAG_H */ diff --git a/src/jtag/interfaces.c b/src/jtag/interfaces.c index 286a73a..96c2494 100644 --- a/src/jtag/interfaces.c +++ b/src/jtag/interfaces.c @@ -40,6 +40,7 @@ * that contain a jtag_interface structure that can added to this list. */ +extern struct jtag_interface kernel_jtag_interface; #if BUILD_ZY1000 == 1 extern struct jtag_interface zy1000_interface; #elif defined(BUILD_MINIDRIVER_DUMMY) @@ -241,6 +242,7 @@ struct jtag_interface *jtag_interfaces[] = { &xds110_interface, #endif #endif /* standard drivers */ + &kernel_jtag_interface, NULL, }; -- |