Index: doc/configs/at91sam7_jlink.cfg =================================================================== --- doc/configs/at91sam7_jlink.cfg (revision 0) +++ doc/configs/at91sam7_jlink.cfg (revision 0) @@ -0,0 +1,23 @@ +#daemon configuration +telnet_port 4444 +gdb_port 3333 + +#interface +interface jlink +jtag_speed 8000 +reset_config trst_and_srst + +#jtag scan chain +#format L IRC IRCM IDCODE (Length, IR Capture, IR Capture Mask, IDCODE) +jtag_device 4 0x1 0xf 0xe + +#target configuration +daemon_startup reset + +#target +#target arm7tdmi +target arm7tdmi little reset_halt 0 arm7tdmi +working_area 0 0x00208000 0x4000 backup + +#flash configuration +flash bank at91sam7 0 0 0 0 0 Index: configure.in =================================================================== --- configure.in (revision 184) +++ configure.in (working copy) @@ -67,6 +67,10 @@ AS_HELP_STRING([--enable-usbprog], [Enable building support for the usbprog JTAG Programmer]), [build_usbprog=$enableval], [build_usbprog=no]) +AC_ARG_ENABLE(jlink, + AS_HELP_STRING([--enable-jlink], [Enable building support for the Segger J-Link JTAG Programmer]), + [build_jlink=$enableval], [build_jlink=no]) + AC_ARG_WITH(ftd2xx, [AS_HELP_STRING(--with-ftd2xx, [Where libftd2xx can be found ])], @@ -191,6 +195,12 @@ AC_DEFINE(BUILD_USBPROG, 0, [0 if you don't want the usbprog JTAG driver.]) fi +if test $build_jlink = yes; then + AC_DEFINE(BUILD_JLINK, 1, [1 if you want the J-Link JTAG driver.]) +else + AC_DEFINE(BUILD_JLINK, 0, [0 if you don't want the J-Link JTAG driver.]) +fi + AM_CONFIG_HEADER(config.h) AM_INIT_AUTOMAKE(openocd, 0.1) @@ -205,6 +215,7 @@ AM_CONDITIONAL(GW16012, test $build_gw16012 = yes) AM_CONDITIONAL(PRESTO, test $build_presto = yes) AM_CONDITIONAL(USBPROG, test $build_usbprog = yes) +AM_CONDITIONAL(JLINK, test $build_jlink = yes) AM_CONDITIONAL(IS_CYGWIN, test $is_cygwin = yes) AM_CONDITIONAL(IS_MINGW, test $is_mingw = yes) AM_CONDITIONAL(IS_WIN32, test $is_win32 = yes) Index: src/jtag/jlink.c =================================================================== --- src/jtag/jlink.c (revision 0) +++ src/jtag/jlink.c (revision 0) @@ -0,0 +1,825 @@ +/*************************************************************************** + * Copyright (C) 2007 by Juergen Stuber * + * based on Dominic Rath's and Benedikt Sauter's usbprog.c * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + ***************************************************************************/ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "replacements.h" + +#include "jtag.h" + +#include +#include + +#include "log.h" + +#ifdef _DEBUG_JTAG_IO_ +#define DEBUG_JTAG_IO(expr ...) DEBUG(expr) +#else +#define DEBUG_JTAG_IO(expr ...) +#endif + +#define VID 0x1366 +#define PID 0x0101 + +#define JLINK_WRITE_ENDPOINT 0x02 +#define JLINK_READ_ENDPOINT 0x81 + +#define JLINK_USB_TIMEOUT 100 + +#define JLINK_IN_BUFFER_SIZE 2064 +#define JLINK_OUT_BUFFER_SIZE 2064 + +/* Global USB buffers */ +static u8 usb_in_buffer[JLINK_IN_BUFFER_SIZE]; +static u8 usb_out_buffer[JLINK_OUT_BUFFER_SIZE]; + +/* Constants for JLink command */ +#define JLINK_SPEED_COMMAND 0x05 +#define JLINK_TAP_SEQUENCE_COMMAND 0xcd +#define JLINK_SET_SRST_LOW_COMMAND 0xdc +#define JLINK_SET_SRST_HIGH_COMMAND 0xdd +#define JLINK_SET_TRST_LOW_COMMAND 0xde +#define JLINK_SET_TRST_HIGH_COMMAND 0xdf + +#define JLINK_MAX_SPEED 12000 + + +/* External interface functions */ +static int jlink_execute_queue(void); +static int jlink_speed(int speed); +static int jlink_register_commands(struct command_context_s *cmd_ctx); +static int jlink_init(void); +static int jlink_quit(void); + +/* CLI command handler functions */ +static int jlink_handle_jlink_version_command( + struct command_context_s *cmd_ctx, + char *cmd, + char **args, + int argc); + +/* Queue command functions */ +static void jlink_end_state(enum tap_state state); +static void jlink_state_move(void); +static void jlink_path_move(int num_states, enum tap_state *path); +static void jlink_runtest(int num_cycles); +static void jlink_scan( + int ir_scan, + enum scan_type type, + u8 *buffer, + int scan_size, + scan_command_t *command); +static void jlink_reset(int trst, int srst); +static void jlink_simple_command(u8 command); + +/* J-Link tap buffer functions */ +static void jlink_tap_init(); +static int jlink_tap_execute(); +static void jlink_tap_ensure_space(int scans, int bits); +static void jlink_tap_append_step(int tms, int tdi); +static void jlink_tap_append_scan( + int length, + u8 *buffer, + scan_command_t *command); + + +/* Jlink lowlevel functions */ +typedef struct jlink_jtag +{ + struct usb_dev_handle* usb_handle; +} jlink_jtag_t; + +static jlink_jtag_t *jlink_usb_open(void); +static void jlink_usb_close(jlink_jtag_t *jlink_jtag); +static int jlink_usb_message( + jlink_jtag_t *jlink_jtag, + int out_length, + int in_length); +static int jlink_usb_write(jlink_jtag_t *jlink_jtag, int out_length); +static int jlink_usb_read(jlink_jtag_t *jlink_jtag); +static jlink_debug_buffer(u8 *buffer, int length); + +jlink_jtag_t* jlink_jtag_handle; + +/***************************************************************************/ +/* External interface implementation */ + +jtag_interface_t jlink_interface = +{ + .name = "jlink", + + .execute_queue = jlink_execute_queue, + + .support_pathmove = 0, + + .speed = jlink_speed, + .register_commands = jlink_register_commands, + .init = jlink_init, + .quit = jlink_quit +}; + +static int jlink_execute_queue(void) +{ + jtag_command_t *cmd = jtag_command_queue; + int scan_size; + enum scan_type type; + u8 *buffer; + + while (cmd != NULL) + { + switch (cmd->type) + { + case JTAG_END_STATE: + DEBUG_JTAG_IO("end_state: %i", cmd->cmd.end_state->end_state); + + if (cmd->cmd.end_state->end_state != -1) + { + jlink_end_state(cmd->cmd.end_state->end_state); + } + break; + + case JTAG_RUNTEST: + DEBUG_JTAG_IO( + "runtest %i cycles, end in %i", + cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state); + + if (cmd->cmd.runtest->end_state != -1) + { + jlink_end_state(cmd->cmd.runtest->end_state); + } + jlink_runtest(cmd->cmd.runtest->num_cycles); + break; + + case JTAG_STATEMOVE: + DEBUG_JTAG_IO( + "statemove end in %i", + cmd->cmd.statemove->end_state); + + if (cmd->cmd.statemove->end_state != -1) + { + jlink_end_state(cmd->cmd.statemove->end_state); + } + jlink_state_move(); + break; + + case JTAG_PATHMOVE: + DEBUG_JTAG_IO("pathmove: %i states, end in %i", + cmd->cmd.pathmove->num_states, + cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); + + jlink_path_move( + cmd->cmd.pathmove->num_states, + cmd->cmd.pathmove->path); + break; + + case JTAG_SCAN: + DEBUG_JTAG_IO("scan end in %i", cmd->cmd.scan->end_state); + + if (cmd->cmd.scan->end_state != -1) + { + jlink_end_state(cmd->cmd.scan->end_state); + } + + scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); + // DEBUG("scan input, length = %d", scan_size); + // jlink_debug_buffer(buffer, (scan_size + 7) / 8); + + type = jtag_scan_type(cmd->cmd.scan); + jlink_scan( + cmd->cmd.scan->ir_scan, + type, + buffer, + scan_size, + cmd->cmd.scan); + break; + + case JTAG_RESET: + DEBUG_JTAG_IO( + "reset trst: %i srst %i", + cmd->cmd.reset->trst, + cmd->cmd.reset->srst); + + jlink_tap_execute(); + + if (cmd->cmd.reset->trst == 1) + { + cur_state = TAP_TLR; + } + jlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); + break; + + case JTAG_SLEEP: + DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us); + + jlink_tap_execute(); + + jtag_sleep(cmd->cmd.sleep->us); + break; + + default: + ERROR("BUG: unknown JTAG command type encountered"); + exit(-1); + } + cmd = cmd->next; + } + jlink_tap_execute(); + + return ERROR_OK; +} + +/** Sets speed in kHz. */ +static int jlink_speed(int speed) +{ + int result; + + if (1 <= speed && speed <= JLINK_MAX_SPEED) + { + usb_out_buffer[0] = JLINK_SPEED_COMMAND; + usb_out_buffer[1] = (speed >> 0) & 0xff; + usb_out_buffer[2] = (speed >> 8) & 0xff; + + result = jlink_usb_write(jlink_jtag_handle, 3); + + if (result == 3) + { + return ERROR_OK; + } + else + { + ERROR("J-Link setting speed failed (%d)", result); + return ERROR_JTAG_DEVICE_ERROR; + } + } + else + { + INFO("Requested speed %dkHz exceeds maximum of %dkHz, ignored", + speed, + JLINK_MAX_SPEED); + } +} + + +static int jlink_register_commands(struct command_context_s *cmd_ctx) +{ + return ERROR_OK; +} + + +static int jlink_init(void) +{ + int result; + + jlink_jtag_handle = jlink_usb_open(); + + if (jlink_jtag_handle == 0) + { + ERROR("Can't find USB JTAG Interface! Please check connection and permissions."); + return ERROR_JTAG_INIT_FAILED; + } + + result = jlink_usb_read(jlink_jtag_handle); + if (result != 2 || usb_in_buffer[0] != 0x07 || usb_in_buffer[1] != 0x00) + { + INFO("J-Link initial read failed, don't worry"); + } + + INFO("J-Link JTAG Interface ready"); + + jlink_reset(0, 0); + jlink_tap_init(); + + return ERROR_OK; +} + +static int jlink_quit(void) +{ + jlink_usb_close(jlink_jtag_handle); + return ERROR_OK; +} + +/***************************************************************************/ +/* Queue command implementations */ + +static void jlink_end_state(enum tap_state state) +{ + if (tap_move_map[state] != -1) + { + end_state = state; + } + else + { + ERROR("BUG: %i is not a valid end state", state); + exit(-1); + } +} + +/** Goes to the end state. */ +static void jlink_state_move(void) +{ + int i; + int tms = 0; + u8 tms_scan = TAP_MOVE(cur_state, end_state); + + for (i = 0; i < 7; i++) + { + tms = (tms_scan >> i) & 1; + jlink_tap_append_step(tms, 0); + } + + cur_state = end_state; +} + +static void jlink_path_move(int num_states, enum tap_state *path) +{ + int i; + + for (i = 0; i < num_states; i++) + { + if (path[i] = tap_transitions[cur_state].low) + { + jlink_tap_append_step(0, 0); + } + else if (path[i] == tap_transitions[cur_state].high) + { + jlink_tap_append_step(1, 0); + } + else + { + ERROR( + "BUG: %s -> %s isn't a valid TAP transition", + tap_state_strings[cur_state], + tap_state_strings[path[i]]); + + exit(-1); + } + + cur_state = path[i]; + } + + end_state = cur_state; +} + +static void jlink_runtest(int num_cycles) +{ + int i; + + enum tap_state saved_end_state = end_state; + + /* only do a state_move when we're not already in RTI */ + if (cur_state != TAP_RTI) + { + jlink_end_state(TAP_RTI); + jlink_state_move(); + } + + /* execute num_cycles */ + for (i = 0; i < num_cycles; i++) + { + jlink_tap_append_step(0, 0); + } + + /* finish in end_state */ + jlink_end_state(saved_end_state); + if (cur_state != end_state) + { + jlink_state_move(); + } +} + +static void jlink_scan( + int ir_scan, + enum scan_type type, + u8 *buffer, + int scan_size, + scan_command_t *command) +{ + enum tap_state saved_end_state; + int bit_cnt; + + jlink_tap_ensure_space(1, scan_size + 8); + + saved_end_state = end_state; + + /* Move to appropriate scan state */ + jlink_end_state(ir_scan ? TAP_SI : TAP_SD); + + jlink_state_move(); + jlink_end_state(saved_end_state); + + /* Scan */ + jlink_tap_append_scan(scan_size, buffer, command); + + /* We are in Exit1, go to Pause */ + jlink_tap_append_step(0, 0); + + cur_state = ir_scan ? TAP_PI : TAP_PD; + + if (cur_state != end_state) + { + jlink_state_move(); + } +} + + +void jlink_reset(int trst, int srst) +{ + DEBUG("trst: %i, srst: %i", trst, srst); + + /* Signals are active low */ + if (trst == 0) + { + jlink_simple_command(JLINK_SET_TRST_HIGH_COMMAND); + } + else if (trst == 1) + { + jlink_simple_command(JLINK_SET_TRST_LOW_COMMAND); + } + + if (srst == 0) + { + jlink_simple_command(JLINK_SET_SRST_HIGH_COMMAND); + } + else if (srst == 1) + { + jlink_simple_command(JLINK_SET_SRST_LOW_COMMAND); + } +} + + +static void jlink_simple_command(u8 command) +{ + int result; + + DEBUG("0x%02x", command); + + usb_out_buffer[0] = command; + result = jlink_usb_write(jlink_jtag_handle, 1); + + if (result != 1) + { + ERROR("J-Link command 0x%02x failed (%d)", command, result); + } +} + +/***************************************************************************/ +/* J-Link tap functions */ + +/* We use the maximal value observed */ +#define JLINK_TAP_BUFFER_SIZE 390 + +static int tap_length; +static u8 tms_buffer[JLINK_TAP_BUFFER_SIZE]; +static u8 tdi_buffer[JLINK_TAP_BUFFER_SIZE]; +static u8 tdo_buffer[JLINK_TAP_BUFFER_SIZE]; + +typedef struct +{ + int first; /* First bit position in tdo_buffer to read */ + int length; /* Number of bits to read */ + scan_command_t *command; /* Corresponding scan command */ + u8 *buffer; +} pending_scan_result_t; + +#define MAX_PENDING_SCAN_RESULTS 16 + +static int pending_scan_results_length; +static pending_scan_result_t + pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS]; + +static int last_tms; + +static void jlink_tap_init() +{ + tap_length = 0; + pending_scan_results_length = 0; +} + +static void jlink_tap_ensure_space(int scans, int bits) +{ + int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length; + int available_bits = JLINK_TAP_BUFFER_SIZE * 8 - tap_length; + + if (scans > available_scans || bits > available_bits) + { + jlink_tap_execute(); + } +} + +static void jlink_tap_append_step(int tms, int tdi) +{ + last_tms = tms; + int index = tap_length / 8; + + if (index < JLINK_TAP_BUFFER_SIZE) + { + int bit_index = tap_length % 8; + u8 bit = 1 << bit_index; + + if (tms) + { + tms_buffer[index] |= bit; + } + else + { + tms_buffer[index] &= ~bit; + } + + if (tdi) + { + tdi_buffer[index] |= bit; + } + else + { + tdi_buffer[index] &= ~bit; + } + + tap_length++; + } + else + { + ERROR("jlink_tap_append_step, overflow"); + } +} + +static void jlink_tap_append_scan( + int length, + u8 *buffer, + scan_command_t *command) +{ + pending_scan_result_t *pending_scan_result = + &pending_scan_results_buffer[pending_scan_results_length]; + int i; + + pending_scan_result->first = tap_length; + pending_scan_result->length = length; + pending_scan_result->command = command; + pending_scan_result->buffer = buffer; + + for (i = 0; i < length; i++) + { + jlink_tap_append_step( + (i < length-1 ? 0 : 1), + (buffer[i/8] >> (i%8)) & 1); + } + pending_scan_results_length++; +} + + +/* Pad and send a tap sequence to the device, and receive the answer. + * For the purpose of padding we assume that we are in idle or pause state. */ +static int jlink_tap_execute() +{ + int byte_length; + int tms_offset; + int tdi_offset; + int i; + int result; + + if (tap_length > 0) + { + // Pad last byte so that tap_length is divisible by 8 + while (tap_length % 8 != 0) + { + /* More of the last TMS value keeps us in the same state, + * analogous to free-running JTAG interfaces. */ + jlink_tap_append_step(last_tms, 0); + } + + byte_length = tap_length / 8; + + usb_out_buffer[0] = JLINK_TAP_SEQUENCE_COMMAND; + usb_out_buffer[1] = (tap_length >> 0) & 0xff; + usb_out_buffer[2] = (tap_length >> 8) & 0xff; + + tms_offset = 3; + for (i = 0; i < byte_length; i++) + { + usb_out_buffer[tms_offset + i] = tms_buffer[i]; + } + + tdi_offset = tms_offset + byte_length; + for (i = 0; i < byte_length; i++) + { + usb_out_buffer[tdi_offset + i] = tdi_buffer[i]; + } + + result = jlink_usb_message( + jlink_jtag_handle, + 3 + 2 * byte_length, + byte_length); + + if (result == byte_length) + { + for (i = 0; i < byte_length; i++) + { + tdo_buffer[i] = usb_in_buffer[i]; + } + for (i = 0; i < pending_scan_results_length; i++) + { + pending_scan_result_t *pending_scan_result = + &pending_scan_results_buffer[i]; + u8 *buffer = pending_scan_result->buffer; + int length = pending_scan_result->length; + int first = pending_scan_result->first; + int byte_length = (pending_scan_result->length + 7) / 8; + scan_command_t *command = pending_scan_result->command; + + /* Copy to buffer */ + buf_set_buf(tdo_buffer, first, buffer, 0, length); + + // DEBUG("pending scan result, length = %d", length); + // jlink_debug_buffer(buffer, byte_length); + + if (jtag_read_buffer(buffer, command)!= ERROR_OK) + { + return ERROR_JTAG_QUEUE_FAILED; + } + + if (pending_scan_result->buffer != NULL) + { + free(pending_scan_result->buffer); + } + } + } + else + { + ERROR( + "jlink_tap_execute, wrong result %d, expected %d", + result, + byte_length); + + return ERROR_JTAG_QUEUE_FAILED; + } + + jlink_tap_init(); + } + return ERROR_OK; +} + +/*****************************************************************************/ +/* JLink USB low-level functions */ + +static jlink_jtag_t* jlink_usb_open() +{ + struct usb_bus *busses; + struct usb_dev_handle* usb_handle; + struct usb_bus *bus; + struct usb_device *dev; + + jlink_jtag_t *result; + + result = (jlink_jtag_t*) malloc(sizeof(jlink_jtag_t)); + + usb_init(); + usb_find_busses(); + usb_find_devices(); + + busses = usb_get_busses(); + + /* find jlink_jtag device in usb bus */ + + for (bus = busses; bus; bus = bus->next) + { + for (dev = bus->devices; dev; dev = dev->next) + { + if (dev->descriptor.idVendor == VID&& dev->descriptor.idProduct + == PID) + { + result->usb_handle = usb_open(dev); + usb_set_configuration( + result->usb_handle, + dev->config[0].bConfigurationValue); + usb_claim_interface(result->usb_handle, 0); + usb_set_altinterface(result->usb_handle, 0); + return result; + } + } + } + + free(result); + return NULL; +} + +static void jlink_usb_close(jlink_jtag_t *jlink_jtag) +{ + usb_close(jlink_jtag->usb_handle); + free(jlink_jtag); +} + +/* Send a message and receive the reply. */ +static int jlink_usb_message( + jlink_jtag_t *jlink_jtag, + int out_length, + int in_length) +{ + int result; + + result = jlink_usb_write(jlink_jtag, out_length); + if (result == out_length) + { + result = jlink_usb_read(jlink_jtag); + if (result == in_length) + { + return result; + } + else + { + ERROR( + "usb_bulk_read failed (requested=%d, result=%d)", + in_length, + result); + + return -1; + } + } + else + { + ERROR( + "usb_bulk_write failed (requested=%d, result=%d)", + out_length, + result); + + return -1; + } +} + +/* Write data from out_buffer to USB. */ +static int jlink_usb_write(jlink_jtag_t *jlink_jtag, int out_length) +{ + int result; + + if (out_length > JLINK_OUT_BUFFER_SIZE) + { + ERROR("jlink_jtag_write illegal out_length=%d (max=%d)", out_length, + JLINK_OUT_BUFFER_SIZE); + + return -1; + } + + result = usb_bulk_write( + jlink_jtag->usb_handle, + JLINK_WRITE_ENDPOINT, + usb_out_buffer, + out_length, + JLINK_USB_TIMEOUT); + + // DEBUG("jlink_usb_write, out_length = %d, result = %d", out_length, result); + // jlink_debug_buffer(usb_out_buffer, out_length); + return result; +} + +/* Read data from USB into in_buffer. */ +static int jlink_usb_read(jlink_jtag_t *jlink_jtag) +{ + int result = usb_bulk_read( + jlink_jtag->usb_handle, + JLINK_READ_ENDPOINT, + usb_in_buffer, + JLINK_IN_BUFFER_SIZE, + JLINK_USB_TIMEOUT); + + // DEBUG("jlink_usb_read, result = %d", result); + // jlink_debug_buffer(usb_in_buffer, result); + return result; +} + + +#define BYTES_PER_LINE 16 + +static jlink_debug_buffer(u8 *buffer, int length) +{ + char line[81]; + char s[4]; + int i; + int j; + + for (i = 0; i < length; i += BYTES_PER_LINE) + { + snprintf(line, 5, "%04x", i); + for (j = i; j < i + BYTES_PER_LINE && j < length; j++) + { + snprintf(s, 4, " %02x", buffer[j]); + strcat(line, s); + } + DEBUG(line); + } +} Index: src/jtag/jtag.c =================================================================== --- src/jtag/jtag.c (revision 184) +++ src/jtag/jtag.c (working copy) @@ -170,6 +170,10 @@ extern jtag_interface_t usbprog_interface; #endif +#if BUILD_JLINK == 1 + extern jtag_interface_t jlink_interface; +#endif + jtag_interface_t *jtag_interfaces[] = { #if BUILD_PARPORT == 1 &parport_interface, @@ -198,6 +202,9 @@ #if BUILD_USBPROG == 1 &usbprog_interface, #endif +#if BUILD_JLINK == 1 + &jlink_interface, +#endif NULL, }; Index: src/jtag/Makefile.am =================================================================== --- src/jtag/Makefile.am (revision 184) +++ src/jtag/Makefile.am (working copy) @@ -77,7 +77,23 @@ USBPROGFILES = endif -libjtag_a_SOURCES = jtag.c $(BITBANGFILES) $(PARPORTFILES) $(FT2232FILES) $(AMTJTAGACCELFILES) $(EP93XXFILES) \ - $(AT91RM9200FILES) $(GW16012FILES) $(BITQFILES) $(PRESTOFILES) $(USBPROGFILES) +if JLINK +JLINKFILES = jlink.c +else +JLINKFILES = +endif +libjtag_a_SOURCES = jtag.c \ + $(BITBANGFILES) \ + $(PARPORTFILES) \ + $(FT2232FILES) \ + $(AMTJTAGACCELFILES) \ + $(EP93XXFILES) \ + $(AT91RM9200FILES) \ + $(GW16012FILES) \ + $(BITQFILES) \ + $(PRESTOFILES) \ + $(USBPROGFILES) \ + $(JLINKFILES) + noinst_HEADERS = bitbang.h jtag.h Index: src/Makefile.am =================================================================== --- src/Makefile.am (revision 184) +++ src/Makefile.am (working copy) @@ -25,8 +25,12 @@ if USBPROG LIBUSB = -lusb else +if JLINK +LIBUSB = -lusb +else LIBUSB = endif +endif if IS_WIN32 if FTD2XXDIR