1 /***************************************************************************
2 * Copyright (C) 2007 by Juergen Stuber <juergen@jstuber.net> *
3 * based on Dominic Rath's and Benedikt Sauter's usbprog.c *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
28 #include "replacements.h"
41 #define JLINK_WRITE_ENDPOINT 0x02
42 #define JLINK_READ_ENDPOINT 0x81
44 #define JLINK_USB_TIMEOUT 1000
46 // See Section 1.3.2 of the Segger JLink USB protocol manual
47 #define JLINK_IN_BUFFER_SIZE 2048
48 #define JLINK_OUT_BUFFER_SIZE 2*2048+4
49 #define JLINK_EMU_RESULT_BUFFER_SIZE 64
51 /* Global USB buffers */
52 static u8 usb_in_buffer[JLINK_IN_BUFFER_SIZE];
53 static u8 usb_out_buffer[JLINK_OUT_BUFFER_SIZE];
54 static u8 usb_emu_result_buffer[JLINK_EMU_RESULT_BUFFER_SIZE];
56 /* Constants for JLink command */
57 #define EMU_CMD_VERSION 0x01
58 #define EMU_CMD_SET_SPEED 0x05
59 #define EMU_CMD_GET_STATE 0x07
60 #define EMU_CMD_HW_JTAG3 0xcf
61 #define EMU_CMD_GET_MAX_MEM_BLOCK 0xd4
62 #define EMU_CMD_HW_RESET0 0xdc
63 #define EMU_CMD_HW_RESET1 0xdd
64 #define EMU_CMD_HW_TRST0 0xde
65 #define EMU_CMD_HW_TRST1 0xdf
66 #define EMU_CMD_GET_CAPS 0xe8
68 /* max speed 12MHz v5.0 jlink */
69 #define JLINK_MAX_SPEED 12000
71 /* External interface functions */
72 static int jlink_execute_queue(void);
73 static int jlink_speed(int speed);
74 static int jlink_speed_div(int speed, int* khz);
75 static int jlink_khz(int khz, int *jtag_speed);
76 static int jlink_register_commands(struct command_context_s *cmd_ctx);
77 static int jlink_init(void);
78 static int jlink_quit(void);
80 /* CLI command handler functions */
81 static int jlink_handle_jlink_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
83 /* Queue command functions */
84 static void jlink_end_state(tap_state_t state);
85 static void jlink_state_move(void);
86 static void jlink_path_move(int num_states, tap_state_t *path);
87 static void jlink_runtest(int num_cycles);
88 static void jlink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command);
89 static void jlink_reset(int trst, int srst);
90 static void jlink_simple_command(u8 command);
91 static int jlink_get_status(void);
93 /* J-Link tap buffer functions */
94 static void jlink_tap_init(void);
95 static int jlink_tap_execute(void);
96 static void jlink_tap_ensure_space(int scans, int bits);
97 static void jlink_tap_append_step(int tms, int tdi);
98 static void jlink_tap_append_scan(int length, u8 *buffer, scan_command_t *command);
100 /* Jlink lowlevel functions */
101 typedef struct jlink_jtag
103 struct usb_dev_handle* usb_handle;
106 static jlink_jtag_t *jlink_usb_open(void);
107 static void jlink_usb_close(jlink_jtag_t *jlink_jtag);
108 static int jlink_usb_message(jlink_jtag_t *jlink_jtag, int out_length, int in_length);
109 static int jlink_usb_write(jlink_jtag_t *jlink_jtag, int out_length);
110 static int jlink_usb_read(jlink_jtag_t *jlink_jtag, int expected_size);
111 static int jlink_usb_read_emu_result(jlink_jtag_t *jlink_jtag);
113 /* helper functions */
114 static int jlink_get_version_info(void);
116 #ifdef _DEBUG_USB_COMMS_
117 static void jlink_debug_buffer(u8 *buffer, int length);
120 static enum tap_state jlink_last_state = TAP_RESET;
122 static jlink_jtag_t* jlink_jtag_handle;
124 /***************************************************************************/
125 /* External interface implementation */
127 jtag_interface_t jlink_interface =
130 .execute_queue = jlink_execute_queue,
131 .speed = jlink_speed,
132 .speed_div = jlink_speed_div,
134 .register_commands = jlink_register_commands,
139 static void jlink_execute_end_state(jtag_command_t *cmd)
141 DEBUG_JTAG_IO("end_state: %i", cmd->cmd.end_state->end_state);
143 if (cmd->cmd.end_state->end_state != TAP_INVALID)
144 jlink_end_state(cmd->cmd.end_state->end_state);
147 static void jlink_execute_runtest(jtag_command_t *cmd)
149 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
150 cmd->cmd.runtest->num_cycles,
151 cmd->cmd.runtest->end_state);
153 if (cmd->cmd.runtest->end_state != TAP_INVALID)
154 jlink_end_state(cmd->cmd.runtest->end_state);
156 jlink_runtest(cmd->cmd.runtest->num_cycles);
159 static void jlink_execute_statemove(jtag_command_t *cmd)
161 DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
163 if (cmd->cmd.statemove->end_state != TAP_INVALID)
165 jlink_end_state(cmd->cmd.statemove->end_state);
170 static void jlink_execute_pathmove(jtag_command_t *cmd)
172 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
173 cmd->cmd.pathmove->num_states,
174 cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
176 jlink_path_move(cmd->cmd.pathmove->num_states,
177 cmd->cmd.pathmove->path);
180 static void jlink_execute_scan(jtag_command_t *cmd)
186 DEBUG_JTAG_IO("scan end in %i", cmd->cmd.scan->end_state);
188 if (cmd->cmd.scan->end_state != TAP_INVALID)
189 jlink_end_state(cmd->cmd.scan->end_state);
191 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
192 DEBUG_JTAG_IO("scan input, length = %d", scan_size);
194 #ifdef _DEBUG_USB_COMMS_
195 jlink_debug_buffer(buffer, (scan_size + 7) / 8);
197 type = jtag_scan_type(cmd->cmd.scan);
198 jlink_scan(cmd->cmd.scan->ir_scan,
199 type, buffer, scan_size, cmd->cmd.scan);
202 static void jlink_execute_reset(jtag_command_t *cmd)
204 DEBUG_JTAG_IO("reset trst: %i srst %i",
205 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
209 if (cmd->cmd.reset->trst == 1)
210 tap_set_state(TAP_RESET);
212 jlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
215 static void jlink_execute_sleep(jtag_command_t *cmd)
217 DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
219 jtag_sleep(cmd->cmd.sleep->us);
222 static void jlink_execute_command(jtag_command_t *cmd)
226 case JTAG_END_STATE: jlink_execute_end_state(cmd); break;
227 case JTAG_RUNTEST: jlink_execute_runtest(cmd); break;
228 case JTAG_STATEMOVE: jlink_execute_statemove(cmd); break;
229 case JTAG_PATHMOVE: jlink_execute_pathmove(cmd); break;
230 case JTAG_SCAN: jlink_execute_scan(cmd); break;
231 case JTAG_RESET: jlink_execute_reset(cmd); break;
232 case JTAG_SLEEP: jlink_execute_sleep(cmd); break;
234 LOG_ERROR("BUG: unknown JTAG command type encountered");
239 static int jlink_execute_queue(void)
241 jtag_command_t *cmd = jtag_command_queue;
245 jlink_execute_command(cmd);
249 return jlink_tap_execute();
252 /* Sets speed in kHz. */
253 static int jlink_speed(int speed)
257 if (speed > JLINK_MAX_SPEED)
259 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
260 speed, JLINK_MAX_SPEED);
264 /* check for RTCK setting */
268 usb_out_buffer[0] = EMU_CMD_SET_SPEED;
269 usb_out_buffer[1] = (speed >> 0) & 0xff;
270 usb_out_buffer[2] = (speed >> 8) & 0xff;
272 result = jlink_usb_write(jlink_jtag_handle, 3);
275 LOG_ERROR("J-Link setting speed failed (%d)", result);
276 return ERROR_JTAG_DEVICE_ERROR;
282 static int jlink_speed_div(int speed, int* khz)
289 static int jlink_khz(int khz, int *jtag_speed)
296 static int jlink_register_commands(struct command_context_s *cmd_ctx)
298 register_command(cmd_ctx, NULL, "jlink_info", jlink_handle_jlink_info_command, COMMAND_EXEC,
303 static int jlink_init(void)
307 jlink_jtag_handle = jlink_usb_open();
309 if (jlink_jtag_handle == 0)
311 LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions.");
312 return ERROR_JTAG_INIT_FAILED;
316 while (check_cnt < 3)
318 if (jlink_get_version_info() == ERROR_OK)
320 /* attempt to get status */
330 LOG_INFO("J-Link initial read failed, don't worry");
333 LOG_INFO("J-Link JTAG Interface ready");
337 jlink_speed(jtag_speed);
342 static int jlink_quit(void)
344 jlink_usb_close(jlink_jtag_handle);
348 /***************************************************************************/
349 /* Queue command implementations */
351 static void jlink_end_state(tap_state_t state)
353 if (tap_is_state_stable(state))
355 tap_set_end_state(state);
359 LOG_ERROR("BUG: %i is not a valid end state", state);
364 /* Goes to the end state. */
365 static void jlink_state_move(void)
369 u8 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
371 for (i = 0; i < 7; i++)
373 tms = (tms_scan >> i) & 1;
374 jlink_tap_append_step(tms, 0);
377 tap_set_state(tap_get_end_state());
380 static void jlink_path_move(int num_states, tap_state_t *path)
384 for (i = 0; i < num_states; i++)
386 if (path[i] == tap_state_transition(tap_get_state(), false))
388 jlink_tap_append_step(0, 0);
390 else if (path[i] == tap_state_transition(tap_get_state(), true))
392 jlink_tap_append_step(1, 0);
396 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path[i]));
400 tap_set_state(path[i]);
403 tap_set_end_state(tap_get_state());
406 static void jlink_runtest(int num_cycles)
410 tap_state_t saved_end_state = tap_get_end_state();
412 /* only do a state_move when we're not already in IDLE */
413 if (tap_get_state() != TAP_IDLE)
415 jlink_end_state(TAP_IDLE);
419 /* execute num_cycles */
420 for (i = 0; i < num_cycles; i++)
422 jlink_tap_append_step(0, 0);
425 /* finish in end_state */
426 jlink_end_state(saved_end_state);
427 if (tap_get_state() != tap_get_end_state())
433 static void jlink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command)
435 tap_state_t saved_end_state;
437 jlink_tap_ensure_space(1, scan_size + 8);
439 saved_end_state = tap_get_end_state();
441 /* Move to appropriate scan state */
442 jlink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
444 /* Only move if we're not already there */
445 if (tap_get_state() != tap_get_end_state())
448 jlink_end_state(saved_end_state);
451 jlink_tap_append_scan(scan_size, buffer, command);
453 /* We are in Exit1, go to Pause */
454 jlink_tap_append_step(0, 0);
456 tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
458 if (tap_get_state() != tap_get_end_state())
464 static void jlink_reset(int trst, int srst)
466 LOG_DEBUG("trst: %i, srst: %i", trst, srst);
468 /* Signals are active low */
471 jlink_simple_command(EMU_CMD_HW_RESET1);
472 jlink_end_state(TAP_RESET);
477 jlink_simple_command(EMU_CMD_HW_RESET0);
482 jlink_simple_command(EMU_CMD_HW_TRST1);
483 jlink_end_state(TAP_RESET);
488 jlink_simple_command(EMU_CMD_HW_TRST0);
492 static void jlink_simple_command(u8 command)
496 DEBUG_JTAG_IO("0x%02x", command);
498 usb_out_buffer[0] = command;
499 result = jlink_usb_write(jlink_jtag_handle, 1);
503 LOG_ERROR("J-Link command 0x%02x failed (%d)", command, result);
507 static int jlink_get_status(void)
511 jlink_simple_command(EMU_CMD_GET_STATE);
513 result = jlink_usb_read(jlink_jtag_handle, 8);
516 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result);
517 return ERROR_JTAG_DEVICE_ERROR;
520 int vref = usb_in_buffer[0] + (usb_in_buffer[1] << 8);
521 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \
522 vref / 1000, vref % 1000, \
523 usb_in_buffer[2], usb_in_buffer[3], usb_in_buffer[4], \
524 usb_in_buffer[5], usb_in_buffer[6], usb_in_buffer[7]);
527 LOG_ERROR("Vref too low. Check Target Power\n");
532 static int jlink_get_version_info(void)
536 u32 jlink_caps, jlink_max_size;
538 /* query hardware version */
539 jlink_simple_command(EMU_CMD_VERSION);
541 result = jlink_usb_read(jlink_jtag_handle, 2);
544 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result);
545 return ERROR_JTAG_DEVICE_ERROR;
548 len = buf_get_u32(usb_in_buffer, 0, 16);
549 result = jlink_usb_read(jlink_jtag_handle, len);
552 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result);
553 return ERROR_JTAG_DEVICE_ERROR;
556 usb_in_buffer[result] = 0;
557 LOG_INFO("%s", (char *)usb_in_buffer);
559 /* query hardware capabilities */
560 jlink_simple_command(EMU_CMD_GET_CAPS);
562 result = jlink_usb_read(jlink_jtag_handle, 4);
565 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)\n", result);
566 return ERROR_JTAG_DEVICE_ERROR;
569 jlink_caps = buf_get_u32(usb_in_buffer, 0, 32);
570 LOG_INFO("JLink caps 0x%x", jlink_caps);
573 /* query hardware maximum memory block */
574 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK);
576 result = jlink_usb_read(jlink_jtag_handle, 4);
579 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)\n", result);
580 return ERROR_JTAG_DEVICE_ERROR;
583 jlink_max_size = buf_get_u32(usb_in_buffer, 0, 32);
584 LOG_INFO("JLink max mem block %i", jlink_max_size);
590 static int jlink_handle_jlink_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
592 if (jlink_get_version_info() == ERROR_OK)
594 /* attempt to get status */
601 /***************************************************************************/
602 /* J-Link tap functions */
604 /* 2048 is the max value we can use here */
605 #define JLINK_TAP_BUFFER_SIZE 2048
607 static unsigned tap_length;
608 static u8 tms_buffer[JLINK_TAP_BUFFER_SIZE];
609 static u8 tdi_buffer[JLINK_TAP_BUFFER_SIZE];
610 static u8 tdo_buffer[JLINK_TAP_BUFFER_SIZE];
614 int first; /* First bit position in tdo_buffer to read */
615 int length; /* Number of bits to read */
616 scan_command_t *command; /* Corresponding scan command */
618 } pending_scan_result_t;
620 #define MAX_PENDING_SCAN_RESULTS 256
622 static int pending_scan_results_length;
623 static pending_scan_result_t pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS];
625 static void jlink_tap_init(void)
628 pending_scan_results_length = 0;
631 static void jlink_tap_ensure_space(int scans, int bits)
633 int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length;
634 int available_bits = JLINK_TAP_BUFFER_SIZE * 8 - tap_length;
636 if (scans > available_scans || bits > available_bits)
642 static void jlink_tap_append_step(int tms, int tdi)
644 int index = tap_length / 8;
646 if (index >= JLINK_TAP_BUFFER_SIZE)
648 LOG_ERROR("jlink_tap_append_step: overflow");
652 int bit_index = tap_length % 8;
653 u8 bit = 1 << bit_index;
655 // we do not pad TMS, so be sure to initialize all bits
657 tms_buffer[index] = tdi_buffer[index] = 0;
660 tms_buffer[index] |= bit;
662 tms_buffer[index] &= ~bit;
665 tdi_buffer[index] |= bit;
667 tdi_buffer[index] &= ~bit;
672 static void jlink_tap_append_scan(int length, u8 *buffer, scan_command_t *command)
674 pending_scan_result_t *pending_scan_result =
675 &pending_scan_results_buffer[pending_scan_results_length];
678 pending_scan_result->first = tap_length;
679 pending_scan_result->length = length;
680 pending_scan_result->command = command;
681 pending_scan_result->buffer = buffer;
683 for (i = 0; i < length; i++)
685 int tms = i < length - 1 ? 0 : 1;
686 int tdi = buffer[i / 8] & (1 << (i % 8));
687 jlink_tap_append_step(tms, tdi);
689 pending_scan_results_length++;
692 /* Pad and send a tap sequence to the device, and receive the answer.
693 * For the purpose of padding we assume that we are in idle or pause state. */
694 static int jlink_tap_execute(void)
703 // number of full bytes (plus one if some would be left over)
704 byte_length = TAP_SCAN_BYTES(tap_length);
706 usb_out_buffer[0] = EMU_CMD_HW_JTAG3;
707 usb_out_buffer[1] = 0;
708 usb_out_buffer[2] = (tap_length >> 0) & 0xff;
709 usb_out_buffer[3] = (tap_length >> 8) & 0xff;
710 memcpy(usb_out_buffer + 4, tms_buffer, byte_length);
711 memcpy(usb_out_buffer + 4 + byte_length, tdi_buffer, byte_length);
713 jlink_last_state = jtag_debug_state_machine(tms_buffer, tdi_buffer,
714 tap_length, jlink_last_state);
716 result = jlink_usb_message(jlink_jtag_handle, 4 + 2 * byte_length, byte_length);
717 if (result != byte_length)
719 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)", result, byte_length);
721 return ERROR_JTAG_QUEUE_FAILED;
724 memcpy(tdo_buffer, usb_in_buffer, byte_length);
726 for (i = 0; i < pending_scan_results_length; i++)
728 pending_scan_result_t *pending_scan_result = &pending_scan_results_buffer[i];
729 u8 *buffer = pending_scan_result->buffer;
730 int length = pending_scan_result->length;
731 int first = pending_scan_result->first;
732 scan_command_t *command = pending_scan_result->command;
735 buf_set_buf(tdo_buffer, first, buffer, 0, length);
737 DEBUG_JTAG_IO("pending scan result, length = %d", length);
739 #ifdef _DEBUG_USB_COMMS_
740 jlink_debug_buffer(buffer, byte_length);
743 if (jtag_read_buffer(buffer, command) != ERROR_OK)
746 return ERROR_JTAG_QUEUE_FAILED;
749 if (pending_scan_result->buffer != NULL)
751 free(pending_scan_result->buffer);
759 /*****************************************************************************/
760 /* JLink USB low-level functions */
762 static jlink_jtag_t* jlink_usb_open()
764 struct usb_bus *busses;
766 struct usb_device *dev;
768 jlink_jtag_t *result;
770 result = (jlink_jtag_t*) malloc(sizeof(jlink_jtag_t));
776 busses = usb_get_busses();
778 /* find jlink_jtag device in usb bus */
780 for (bus = busses; bus; bus = bus->next)
782 for (dev = bus->devices; dev; dev = dev->next)
784 if ((dev->descriptor.idVendor == VID) && (dev->descriptor.idProduct == PID))
786 result->usb_handle = usb_open(dev);
788 /* usb_set_configuration required under win32 */
789 usb_set_configuration(result->usb_handle, dev->config[0].bConfigurationValue);
790 usb_claim_interface(result->usb_handle, 0);
794 * This makes problems under Mac OS X. And is not needed
795 * under Windows. Hopefully this will not break a linux build
797 usb_set_altinterface(result->usb_handle, 0);
808 static void jlink_usb_close(jlink_jtag_t *jlink_jtag)
810 usb_close(jlink_jtag->usb_handle);
814 /* Send a message and receive the reply. */
815 static int jlink_usb_message(jlink_jtag_t *jlink_jtag, int out_length, int in_length)
820 result = jlink_usb_write(jlink_jtag, out_length);
821 if (result != out_length)
823 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
825 return ERROR_JTAG_DEVICE_ERROR;
828 result = jlink_usb_read(jlink_jtag, in_length);
829 if ((result != in_length) && (result != (in_length + 1)))
831 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
833 return ERROR_JTAG_DEVICE_ERROR;
836 if (result == in_length)
838 /* Must read the result from the EMU too */
839 result2 = jlink_usb_read_emu_result(jlink_jtag);
842 LOG_ERROR("jlink_usb_read_emu_result failed "
843 "(requested=1, result=%d)", result2);
844 return ERROR_JTAG_DEVICE_ERROR;
847 /* Check the result itself */
848 result2 = usb_emu_result_buffer[0];
852 /* Save the result, then remove it from return value */
853 result2 = usb_in_buffer[result--];
858 LOG_ERROR("jlink_usb_message failed with result=%d)", result2);
859 return ERROR_JTAG_DEVICE_ERROR;
865 /* calls the given usb_bulk_* function, allowing for the data to trickle in with some timeouts */
866 static int usb_bulk_with_retries(
867 int (*f)(usb_dev_handle *, int, char *, int, int),
868 usb_dev_handle *dev, int ep,
869 char *bytes, int size, int timeout)
871 int tries = 3, count = 0;
873 while (tries && (count < size))
875 int result = f(dev, ep, bytes + count, size - count, timeout);
878 else if ((-ETIMEDOUT != result) || !--tries)
884 static int wrap_usb_bulk_write(usb_dev_handle *dev, int ep,
885 char *buff, int size, int timeout)
887 /* usb_bulk_write() takes const char *buff */
888 return usb_bulk_write(dev, ep, buff, size, timeout);
891 static inline int usb_bulk_write_ex(usb_dev_handle *dev, int ep,
892 char *bytes, int size, int timeout)
894 return usb_bulk_with_retries(&wrap_usb_bulk_write,
895 dev, ep, bytes, size, timeout);
898 static inline int usb_bulk_read_ex(usb_dev_handle *dev, int ep,
899 char *bytes, int size, int timeout)
901 return usb_bulk_with_retries(&usb_bulk_read,
902 dev, ep, bytes, size, timeout);
905 /* Write data from out_buffer to USB. */
906 static int jlink_usb_write(jlink_jtag_t *jlink_jtag, int out_length)
910 if (out_length > JLINK_OUT_BUFFER_SIZE)
912 LOG_ERROR("jlink_jtag_write illegal out_length=%d (max=%d)", out_length, JLINK_OUT_BUFFER_SIZE);
916 result = usb_bulk_write_ex(jlink_jtag->usb_handle, JLINK_WRITE_ENDPOINT,
917 (char *)usb_out_buffer, out_length, JLINK_USB_TIMEOUT);
919 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length, result);
921 #ifdef _DEBUG_USB_COMMS_
922 jlink_debug_buffer(usb_out_buffer, out_length);
927 /* Read data from USB into in_buffer. */
928 static int jlink_usb_read(jlink_jtag_t *jlink_jtag, int expected_size)
930 int result = usb_bulk_read_ex(jlink_jtag->usb_handle, JLINK_READ_ENDPOINT,
931 (char *)usb_in_buffer, expected_size, JLINK_USB_TIMEOUT);
933 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result);
935 #ifdef _DEBUG_USB_COMMS_
936 jlink_debug_buffer(usb_in_buffer, result);
941 /* Read the result from the previous EMU cmd into result_buffer. */
942 static int jlink_usb_read_emu_result(jlink_jtag_t *jlink_jtag)
944 int result = usb_bulk_read_ex(jlink_jtag->usb_handle, JLINK_READ_ENDPOINT,
945 (char *)usb_emu_result_buffer, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
948 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result);
950 #ifdef _DEBUG_USB_COMMS_
951 jlink_debug_buffer(usb_emu_result_buffer, result);
956 #ifdef _DEBUG_USB_COMMS_
957 #define BYTES_PER_LINE 16
959 static void jlink_debug_buffer(u8 *buffer, int length)
966 for (i = 0; i < length; i += BYTES_PER_LINE)
968 snprintf(line, 5, "%04x", i);
969 for (j = i; j < i + BYTES_PER_LINE && j < length; j++)
971 snprintf(s, 4, " %02x", buffer[j]);
974 LOG_DEBUG("%s", line);