Code Review / openocd.git / blob
? search:


f58dc9240ca8e05c90dcaafab4607d348a28e555
[openocd.git] / src / jtag / drivers / opendous.c
1 /***************************************************************************
2 * *
3 * Copyright (C) 2009 by Cahya Wirawan <cahya@gmx.at> *
4 * Based on opendous driver by Vladimir Fonov *
5 * *
6 * Copyright (C) 2009 by Vladimir Fonov <vladimir.fonov@gmai.com> *
7 * Based on J-link driver by Juergen Stuber *
8 * *
9 * Copyright (C) 2007 by Juergen Stuber <juergen@jstuber.net> *
10 * based on Dominic Rath's and Benedikt Sauter's usbprog.c *
11 * *
12 * Copyright (C) 2008 by Spencer Oliver *
13 * spen@spen-soft.co.uk *
14 * *
15 * This program is free software; you can redistribute it and/or modify *
16 * it under the terms of the GNU General Public License as published by *
17 * the Free Software Foundation; either version 2 of the License, or *
18 * (at your option) any later version. *
19 * *
20 * This program is distributed in the hope that it will be useful, *
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
23 * GNU General Public License for more details. *
24 * *
25 * You should have received a copy of the GNU General Public License *
26 * along with this program; if not, write to the *
27 * Free Software Foundation, Inc., *
28 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
29 ***************************************************************************/
30
31 #ifdef HAVE_CONFIG_H
32 #include "config.h"
33 #endif
34
35 #include <jtag/interface.h>
36 #include <jtag/commands.h>
37 #include "libusb_common.h"
38 #include <string.h>
39 #include <sys/timeb.h>
40 #include <time.h>
41
42 #define OPENDOUS_MAX_VIDS_PIDS 4
43 /* define some probes with similar interface */
44 struct opendous_probe {
45 char *name;
46 uint16_t VID[OPENDOUS_MAX_VIDS_PIDS];
47 uint16_t PID[OPENDOUS_MAX_VIDS_PIDS];
48 uint8_t READ_EP;
49 uint8_t WRITE_EP;
50 uint8_t CONTROL_TRANSFER;
51 int BUFFERSIZE;
52 };
53
54 static struct opendous_probe opendous_probes[] = {
55 {"usbprog-jtag", {0x1781, 0}, {0x0C63, 0}, 0x82, 0x02, 0x00, 510 },
56 {"opendous", {0x1781, 0x03EB, 0}, {0xC0C0, 0x204F, 0}, 0x81, 0x02, 0x00, 360 },
57 {"usbvlab", {0x16C0, 0}, {0x05DC, 0}, 0x81, 0x02, 0x01, 360 },
58 {NULL, {0x0000}, {0x0000}, 0x00, 0x00, 0x00, 0 }
59 };
60
61 #define OPENDOUS_WRITE_ENDPOINT (opendous_probe->WRITE_EP)
62 #define OPENDOUS_READ_ENDPOINT (opendous_probe->READ_EP)
63
64 static unsigned int opendous_hw_jtag_version = 1;
65
66 #define OPENDOUS_USB_TIMEOUT 1000
67
68 #define OPENDOUS_USB_BUFFER_SIZE (opendous_probe->BUFFERSIZE)
69 #define OPENDOUS_IN_BUFFER_SIZE (OPENDOUS_USB_BUFFER_SIZE)
70 #define OPENDOUS_OUT_BUFFER_SIZE (OPENDOUS_USB_BUFFER_SIZE)
71
72 /* Global USB buffers */
73 static uint8_t *usb_in_buffer;
74 static uint8_t *usb_out_buffer;
75
76 /* Constants for OPENDOUS command */
77
78 #define OPENDOUS_MAX_SPEED 66
79 #define OPENDOUS_MAX_TAP_TRANSMIT ((opendous_probe->BUFFERSIZE)-10)
80 #define OPENDOUS_MAX_INPUT_DATA (OPENDOUS_MAX_TAP_TRANSMIT*4)
81
82 /* TAP */
83 #define OPENDOUS_TAP_BUFFER_SIZE 65536
84
85 struct pending_scan_result {
86 int first; /* First bit position in tdo_buffer to read */
87 int length; /* Number of bits to read */
88 struct scan_command *command; /* Corresponding scan command */
89 uint8_t *buffer;
90 };
91
92 static int pending_scan_results_length;
93 static struct pending_scan_result *pending_scan_results_buffer;
94
95 #define MAX_PENDING_SCAN_RESULTS (OPENDOUS_MAX_INPUT_DATA)
96
97 /* JTAG usb commands */
98 #define JTAG_CMD_TAP_OUTPUT 0x0
99 #define JTAG_CMD_SET_TRST 0x1
100 #define JTAG_CMD_SET_SRST 0x2
101 #define JTAG_CMD_READ_INPUT 0x3
102 #define JTAG_CMD_TAP_OUTPUT_EMU 0x4
103 #define JTAG_CMD_SET_DELAY 0x5
104 #define JTAG_CMD_SET_SRST_TRST 0x6
105 #define JTAG_CMD_READ_CONFIG 0x7
106
107 /* usbvlab control transfer */
108 #define FUNC_START_BOOTLOADER 30
109 #define FUNC_WRITE_DATA 0x50
110 #define FUNC_READ_DATA 0x51
111
112 static char *opendous_type;
113 static struct opendous_probe *opendous_probe;
114
115 /* External interface functions */
116 static int opendous_execute_queue(void);
117 static int opendous_init(void);
118 static int opendous_quit(void);
119
120 /* Queue command functions */
121 static void opendous_end_state(tap_state_t state);
122 static void opendous_state_move(void);
123 static void opendous_path_move(int num_states, tap_state_t *path);
124 static void opendous_runtest(int num_cycles);
125 static void opendous_scan(int ir_scan, enum scan_type type, uint8_t *buffer,
126 int scan_size, struct scan_command *command);
127 static void opendous_reset(int trst, int srst);
128 static void opendous_simple_command(uint8_t command, uint8_t _data);
129 static int opendous_get_status(void);
130
131 /* opendous tap buffer functions */
132 static void opendous_tap_init(void);
133 static int opendous_tap_execute(void);
134 static void opendous_tap_ensure_space(int scans, int bits);
135 static void opendous_tap_append_step(int tms, int tdi);
136 static void opendous_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command);
137
138 /* opendous lowlevel functions */
139 struct opendous_jtag {
140 struct jtag_libusb_device_handle *usb_handle;
141 };
142
143 static struct opendous_jtag *opendous_usb_open(void);
144 static void opendous_usb_close(struct opendous_jtag *opendous_jtag);
145 static int opendous_usb_message(struct opendous_jtag *opendous_jtag, int out_length, int in_length);
146 static int opendous_usb_write(struct opendous_jtag *opendous_jtag, int out_length);
147 static int opendous_usb_read(struct opendous_jtag *opendous_jtag);
148
149 /* helper functions */
150 int opendous_get_version_info(void);
151
152 #ifdef _DEBUG_USB_COMMS_
153 char time_str[50];
154 static void opendous_debug_buffer(uint8_t *buffer, int length);
155 char *opendous_get_time(char *);
156 #endif
157
158 static struct opendous_jtag *opendous_jtag_handle;
159
160 /***************************************************************************/
161 /* External interface implementation */
162
163 COMMAND_HANDLER(opendous_handle_opendous_type_command)
164 {
165 if (CMD_ARGC == 0)
166 return ERROR_OK;
167
168 /* only if the cable name wasn't overwritten by cmdline */
169 if (opendous_type == NULL) {
170 /* REVISIT first verify that it's listed in cables[] ... */
171 opendous_type = strdup(CMD_ARGV[0]);
172 }
173
174 /* REVISIT it's probably worth returning the current value ... */
175
176 return ERROR_OK;
177 }
178
179 COMMAND_HANDLER(opendous_handle_opendous_info_command)
180 {
181 if (opendous_get_version_info() == ERROR_OK) {
182 /* attempt to get status */
183 opendous_get_status();
184 }
185
186 return ERROR_OK;
187 }
188
189 COMMAND_HANDLER(opendous_handle_opendous_hw_jtag_command)
190 {
191 switch (CMD_ARGC) {
192 case 0:
193 command_print(CMD_CTX, "opendous hw jtag %i", opendous_hw_jtag_version);
194 break;
195
196 case 1: {
197 int request_version = atoi(CMD_ARGV[0]);
198 switch (request_version) {
199 case 2:
200 case 3:
201 opendous_hw_jtag_version = request_version;
202 break;
203
204 default:
205 return ERROR_COMMAND_SYNTAX_ERROR;
206 }
207 break;
208 }
209
210 default:
211 return ERROR_COMMAND_SYNTAX_ERROR;
212 }
213
214 return ERROR_OK;
215 }
216
217 static const struct command_registration opendous_command_handlers[] = {
218 {
219 .name = "opendous_info",
220 .handler = &opendous_handle_opendous_info_command,
221 .mode = COMMAND_EXEC,
222 .help = "show opendous info",
223 },
224 {
225 .name = "opendous_hw_jtag",
226 .handler = &opendous_handle_opendous_hw_jtag_command,
227 .mode = COMMAND_EXEC,
228 .help = "access opendous HW JTAG command version",
229 .usage = "[2|3]",
230 },
231 {
232 .name = "opendous_type",
233 .handler = &opendous_handle_opendous_type_command,
234 .mode = COMMAND_CONFIG,
235 .help = "set opendous type",
236 .usage = "[usbvlab|usbprog-jtag|opendous]",
237 },
238 COMMAND_REGISTRATION_DONE
239 };
240
241 struct jtag_interface opendous_interface = {
242 .name = "opendous",
243 .commands = opendous_command_handlers,
244 .execute_queue = opendous_execute_queue,
245 .init = opendous_init,
246 .quit = opendous_quit,
247 };
248
249 static int opendous_execute_queue(void)
250 {
251 struct jtag_command *cmd = jtag_command_queue;
252 int scan_size;
253 enum scan_type type;
254 uint8_t *buffer;
255
256 while (cmd != NULL) {
257 switch (cmd->type) {
258 case JTAG_RUNTEST:
259 DEBUG_JTAG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, \
260 cmd->cmd.runtest->end_state);
261
262 if (cmd->cmd.runtest->end_state != -1)
263 opendous_end_state(cmd->cmd.runtest->end_state);
264 opendous_runtest(cmd->cmd.runtest->num_cycles);
265 break;
266
267 case JTAG_TLR_RESET:
268 DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
269
270 if (cmd->cmd.statemove->end_state != -1)
271 opendous_end_state(cmd->cmd.statemove->end_state);
272 opendous_state_move();
273 break;
274
275 case JTAG_PATHMOVE:
276 DEBUG_JTAG_IO("pathmove: %i states, end in %i", \
277 cmd->cmd.pathmove->num_states, \
278 cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
279
280 opendous_path_move(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path);
281 break;
282
283 case JTAG_SCAN:
284 DEBUG_JTAG_IO("scan end in %i", cmd->cmd.scan->end_state);
285
286 if (cmd->cmd.scan->end_state != -1)
287 opendous_end_state(cmd->cmd.scan->end_state);
288
289 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
290 DEBUG_JTAG_IO("scan input, length = %d", scan_size);
291
292 #ifdef _DEBUG_USB_COMMS_
293 opendous_debug_buffer(buffer, (scan_size + 7) / 8);
294 #endif
295 type = jtag_scan_type(cmd->cmd.scan);
296 opendous_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size, cmd->cmd.scan);
297 break;
298
299 case JTAG_RESET:
300 DEBUG_JTAG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
301
302 opendous_tap_execute();
303
304 if (cmd->cmd.reset->trst == 1)
305 tap_set_state(TAP_RESET);
306 opendous_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
307 break;
308
309 case JTAG_SLEEP:
310 DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
311 opendous_tap_execute();
312 jtag_sleep(cmd->cmd.sleep->us);
313 break;
314
315 default:
316 LOG_ERROR("BUG: unknown JTAG command type encountered");
317 exit(-1);
318 }
319 cmd = cmd->next;
320 }
321 return opendous_tap_execute();
322 }
323
324 static int opendous_init(void)
325 {
326 int check_cnt;
327 struct opendous_probe *cur_opendous_probe;
328
329 cur_opendous_probe = opendous_probes;
330
331 if (opendous_type == NULL) {
332 opendous_type = strdup("opendous");
333 LOG_WARNING("No opendous_type specified, using default 'opendous'");
334 }
335
336 while (cur_opendous_probe->name) {
337 if (strcmp(cur_opendous_probe->name, opendous_type) == 0) {
338 opendous_probe = cur_opendous_probe;
339 break;
340 }
341 cur_opendous_probe++;
342 }
343
344 if (!opendous_probe) {
345 LOG_ERROR("No matching cable found for %s", opendous_type);
346 return ERROR_JTAG_INIT_FAILED;
347 }
348
349
350 usb_in_buffer = malloc(opendous_probe->BUFFERSIZE);
351 usb_out_buffer = malloc(opendous_probe->BUFFERSIZE);
352
353 pending_scan_results_buffer = (struct pending_scan_result *)
354 malloc(MAX_PENDING_SCAN_RESULTS * sizeof(struct pending_scan_result));
355
356 opendous_jtag_handle = opendous_usb_open();
357
358 if (opendous_jtag_handle == 0) {
359 LOG_ERROR("Cannot find opendous Interface! Please check connection and permissions.");
360 return ERROR_JTAG_INIT_FAILED;
361 }
362
363 check_cnt = 0;
364 while (check_cnt < 3) {
365 if (opendous_get_version_info() == ERROR_OK) {
366 /* attempt to get status */
367 opendous_get_status();
368 break;
369 }
370
371 check_cnt++;
372 }
373
374 LOG_INFO("opendous JTAG Interface ready");
375
376 opendous_reset(0, 0);
377 opendous_tap_init();
378
379 return ERROR_OK;
380 }
381
382 static int opendous_quit(void)
383 {
384 opendous_usb_close(opendous_jtag_handle);
385
386 if (usb_out_buffer) {
387 free(usb_out_buffer);
388 usb_out_buffer = NULL;
389 }
390
391 if (usb_in_buffer) {
392 free(usb_in_buffer);
393 usb_in_buffer = NULL;
394 }
395
396 if (pending_scan_results_buffer) {
397 free(pending_scan_results_buffer);
398 pending_scan_results_buffer = NULL;
399 }
400
401 if (opendous_type) {
402 free(opendous_type);
403 opendous_type = NULL;
404 }
405
406 return ERROR_OK;
407 }
408
409 /***************************************************************************/
410 /* Queue command implementations */
411
412 void opendous_end_state(tap_state_t state)
413 {
414 if (tap_is_state_stable(state))
415 tap_set_end_state(state);
416 else {
417 LOG_ERROR("BUG: %i is not a valid end state", state);
418 exit(-1);
419 }
420 }
421
422 /* Goes to the end state. */
423 void opendous_state_move(void)
424 {
425 int i;
426 int tms = 0;
427 uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
428 uint8_t tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
429
430 for (i = 0; i < tms_scan_bits; i++) {
431 tms = (tms_scan >> i) & 1;
432 opendous_tap_append_step(tms, 0);
433 }
434
435 tap_set_state(tap_get_end_state());
436 }
437
438 void opendous_path_move(int num_states, tap_state_t *path)
439 {
440 int i;
441
442 for (i = 0; i < num_states; i++) {
443 if (path[i] == tap_state_transition(tap_get_state(), false))
444 opendous_tap_append_step(0, 0);
445 else if (path[i] == tap_state_transition(tap_get_state(), true))
446 opendous_tap_append_step(1, 0);
447 else {
448 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
449 tap_state_name(tap_get_state()), tap_state_name(path[i]));
450 exit(-1);
451 }
452
453 tap_set_state(path[i]);
454 }
455
456 tap_set_end_state(tap_get_state());
457 }
458
459 void opendous_runtest(int num_cycles)
460 {
461 int i;
462
463 tap_state_t saved_end_state = tap_get_end_state();
464
465 /* only do a state_move when we're not already in IDLE */
466 if (tap_get_state() != TAP_IDLE) {
467 opendous_end_state(TAP_IDLE);
468 opendous_state_move();
469 }
470
471 /* execute num_cycles */
472 for (i = 0; i < num_cycles; i++)
473 opendous_tap_append_step(0, 0);
474
475 /* finish in end_state */
476 opendous_end_state(saved_end_state);
477 if (tap_get_state() != tap_get_end_state())
478 opendous_state_move();
479 }
480
481 void opendous_scan(int ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command)
482 {
483 tap_state_t saved_end_state;
484
485 opendous_tap_ensure_space(1, scan_size + 8);
486
487 saved_end_state = tap_get_end_state();
488
489 /* Move to appropriate scan state */
490 opendous_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
491
492 if (tap_get_state() != tap_get_end_state())
493 opendous_state_move();
494
495 opendous_end_state(saved_end_state);
496
497 /* Scan */
498 opendous_tap_append_scan(scan_size, buffer, command);
499
500 /* We are in Exit1, go to Pause */
501 opendous_tap_append_step(0, 0);
502
503 tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
504
505 if (tap_get_state() != tap_get_end_state())
506 opendous_state_move();
507 }
508
509 void opendous_reset(int trst, int srst)
510 {
511 LOG_DEBUG("trst: %i, srst: %i", trst, srst);
512
513 /* Signals are active low */
514 #if 0
515 if (srst == 0)
516 opendous_simple_command(JTAG_CMD_SET_SRST, 1);
517 else if (srst == 1)
518 opendous_simple_command(JTAG_CMD_SET_SRST, 0);
519
520 if (trst == 0)
521 opendous_simple_command(JTAG_CMD_SET_TRST, 1);
522 else if (trst == 1)
523 opendous_simple_command(JTAG_CMD_SET_TRST, 0);
524 #endif
525
526 srst = srst ? 0 : 1;
527 trst = trst ? 0 : 2;
528 opendous_simple_command(JTAG_CMD_SET_SRST_TRST, srst | trst);
529 }
530
531 void opendous_simple_command(uint8_t command, uint8_t _data)
532 {
533 int result;
534
535 DEBUG_JTAG_IO("0x%02x 0x%02x", command, _data);
536
537 usb_out_buffer[0] = 2;
538 usb_out_buffer[1] = 0;
539 usb_out_buffer[2] = command;
540 usb_out_buffer[3] = _data;
541
542 result = opendous_usb_message(opendous_jtag_handle, 4, 1);
543 if (result != 1)
544 LOG_ERROR("opendous command 0x%02x failed (%d)", command, result);
545 }
546
547 int opendous_get_status(void)
548 {
549 return ERROR_OK;
550 }
551
552 int opendous_get_version_info(void)
553 {
554 return ERROR_OK;
555 }
556
557 /***************************************************************************/
558 /* Estick tap functions */
559
560 static int tap_length;
561 static uint8_t tms_buffer[OPENDOUS_TAP_BUFFER_SIZE];
562 static uint8_t tdo_buffer[OPENDOUS_TAP_BUFFER_SIZE];
563
564 static int last_tms;
565
566 void opendous_tap_init(void)
567 {
568 tap_length = 0;
569 pending_scan_results_length = 0;
570 }
571
572 void opendous_tap_ensure_space(int scans, int bits)
573 {
574 int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length;
575 int available_bits = OPENDOUS_TAP_BUFFER_SIZE / 2 - tap_length;
576
577 if ((scans > available_scans) || (bits > available_bits))
578 opendous_tap_execute();
579 }
580
581 void opendous_tap_append_step(int tms, int tdi)
582 {
583 last_tms = tms;
584 unsigned char _tms = tms ? 1 : 0;
585 unsigned char _tdi = tdi ? 1 : 0;
586
587 opendous_tap_ensure_space(0, 1);
588
589 int tap_index = tap_length / 4;
590 int bits = (tap_length % 4) * 2;
591
592 if (tap_length < OPENDOUS_TAP_BUFFER_SIZE) {
593 if (!bits)
594 tms_buffer[tap_index] = 0;
595
596 tms_buffer[tap_index] |= (_tdi << bits)|(_tms << (bits + 1)) ;
597 tap_length++;
598 } else
599 LOG_ERROR("opendous_tap_append_step, overflow");
600 }
601
602 void opendous_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command)
603 {
604 DEBUG_JTAG_IO("append scan, length = %d", length);
605
606 struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
607 int i;
608
609 pending_scan_result->first = tap_length;
610 pending_scan_result->length = length;
611 pending_scan_result->command = command;
612 pending_scan_result->buffer = buffer;
613
614 for (i = 0; i < length; i++)
615 opendous_tap_append_step((i < length-1 ? 0 : 1), (buffer[i / 8] >> (i % 8)) & 1);
616 pending_scan_results_length++;
617 }
618
619 /* Pad and send a tap sequence to the device, and receive the answer.
620 * For the purpose of padding we assume that we are in idle or pause state. */
621 int opendous_tap_execute(void)
622 {
623 int byte_length;
624 int i, j;
625 int result;
626
627 #ifdef _DEBUG_USB_COMMS_
628 int byte_length_out;
629 #endif
630
631 if (tap_length > 0) {
632
633 /* memset(tdo_buffer,0,OPENDOUS_TAP_BUFFER_SIZE); */
634 /* LOG_INFO("OPENDOUS tap execute %d",tap_length); */
635 byte_length = (tap_length + 3) / 4;
636
637 #ifdef _DEBUG_USB_COMMS_
638 byte_length_out = (tap_length + 7) / 8;
639 LOG_DEBUG("opendous is sending %d bytes", byte_length);
640 #endif
641
642 for (j = 0, i = 0; j < byte_length;) {
643
644 int receive;
645 int transmit = byte_length - j;
646 if (transmit > OPENDOUS_MAX_TAP_TRANSMIT) {
647 transmit = OPENDOUS_MAX_TAP_TRANSMIT;
648 receive = (OPENDOUS_MAX_TAP_TRANSMIT) / 2;
649 usb_out_buffer[2] = JTAG_CMD_TAP_OUTPUT;
650 } else {
651 usb_out_buffer[2] = JTAG_CMD_TAP_OUTPUT | ((tap_length % 4) << 4);
652 receive = (transmit + 1) / 2;
653 }
654 usb_out_buffer[0] = (transmit + 1) & 0xff;
655 usb_out_buffer[1] = ((transmit + 1) >> 8) & 0xff;
656
657 memmove(usb_out_buffer + 3, tms_buffer + j, transmit);
658 result = opendous_usb_message(opendous_jtag_handle, 3 + transmit, receive);
659 if (result != receive) {
660 LOG_ERROR("opendous_tap_execute, wrong result %d, expected %d", result, receive);
661 return ERROR_JTAG_QUEUE_FAILED;
662 }
663
664 memmove(tdo_buffer + i, usb_in_buffer, receive);
665 i += receive;
666 j += transmit;
667 }
668
669 #ifdef _DEBUG_USB_COMMS_
670 LOG_DEBUG("opendous tap result %d", byte_length_out);
671 opendous_debug_buffer(tdo_buffer, byte_length_out);
672 #endif
673
674 /* LOG_INFO("eStick tap execute %d",tap_length); */
675 for (i = 0; i < pending_scan_results_length; i++) {
676
677 struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[i];
678 uint8_t *buffer = pending_scan_result->buffer;
679 int length = pending_scan_result->length;
680 int first = pending_scan_result->first;
681 struct scan_command *command = pending_scan_result->command;
682
683 /* Copy to buffer */
684 buf_set_buf(tdo_buffer, first, buffer, 0, length);
685
686 DEBUG_JTAG_IO("pending scan result, length = %d", length);
687
688 #ifdef _DEBUG_USB_COMMS_
689 opendous_debug_buffer(buffer, byte_length_out);
690 #endif
691
692 if (jtag_read_buffer(buffer, command) != ERROR_OK) {
693 opendous_tap_init();
694 return ERROR_JTAG_QUEUE_FAILED;
695 }
696
697 if (pending_scan_result->buffer != NULL)
698 free(pending_scan_result->buffer);
699 }
700
701 opendous_tap_init();
702 }
703
704 return ERROR_OK;
705 }
706
707 /*****************************************************************************/
708 /* Estick USB low-level functions */
709
710 struct opendous_jtag *opendous_usb_open(void)
711 {
712 struct opendous_jtag *result;
713
714 struct jtag_libusb_device_handle *devh;
715 if (jtag_libusb_open(opendous_probe->VID, opendous_probe->PID, &devh) != ERROR_OK)
716 return NULL;
717
718 jtag_libusb_set_configuration(devh, 0);
719 jtag_libusb_claim_interface(devh, 0);
720
721 result = (struct opendous_jtag *) malloc(sizeof(struct opendous_jtag));
722 result->usb_handle = devh;
723 return result;
724 }
725
726 void opendous_usb_close(struct opendous_jtag *opendous_jtag)
727 {
728 jtag_libusb_close(opendous_jtag->usb_handle);
729 free(opendous_jtag);
730 }
731
732 /* Send a message and receive the reply. */
733 int opendous_usb_message(struct opendous_jtag *opendous_jtag, int out_length, int in_length)
734 {
735 int result;
736
737 result = opendous_usb_write(opendous_jtag, out_length);
738 if (result == out_length) {
739 result = opendous_usb_read(opendous_jtag);
740 if (result == in_length)
741 return result;
742 else {
743 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", in_length, result);
744 return -1;
745 }
746 } else {
747 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)", out_length, result);
748 return -1;
749 }
750 }
751
752 /* Write data from out_buffer to USB. */
753 int opendous_usb_write(struct opendous_jtag *opendous_jtag, int out_length)
754 {
755 int result;
756
757 if (out_length > OPENDOUS_OUT_BUFFER_SIZE) {
758 LOG_ERROR("opendous_jtag_write illegal out_length=%d (max=%d)", out_length, OPENDOUS_OUT_BUFFER_SIZE);
759 return -1;
760 }
761
762 #ifdef _DEBUG_USB_COMMS_
763 LOG_DEBUG("%s: USB write begin", opendous_get_time(time_str));
764 #endif
765 if (opendous_probe->CONTROL_TRANSFER) {
766 result = jtag_libusb_control_transfer(opendous_jtag->usb_handle,
767 LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT,
768 FUNC_WRITE_DATA, 0, 0, (char *) usb_out_buffer, out_length, OPENDOUS_USB_TIMEOUT);
769 } else {
770 result = jtag_libusb_bulk_write(opendous_jtag->usb_handle, OPENDOUS_WRITE_ENDPOINT, \
771 (char *)usb_out_buffer, out_length, OPENDOUS_USB_TIMEOUT);
772 }
773 #ifdef _DEBUG_USB_COMMS_
774 LOG_DEBUG("%s: USB write end: %d bytes", opendous_get_time(time_str), result);
775 #endif
776
777 DEBUG_JTAG_IO("opendous_usb_write, out_length = %d, result = %d", out_length, result);
778
779 #ifdef _DEBUG_USB_COMMS_
780 opendous_debug_buffer(usb_out_buffer, out_length);
781 #endif
782 return result;
783 }
784
785 /* Read data from USB into in_buffer. */
786 int opendous_usb_read(struct opendous_jtag *opendous_jtag)
787 {
788 #ifdef _DEBUG_USB_COMMS_
789 LOG_DEBUG("%s: USB read begin", opendous_get_time(time_str));
790 #endif
791 int result;
792 if (opendous_probe->CONTROL_TRANSFER) {
793 result = jtag_libusb_control_transfer(opendous_jtag->usb_handle,
794 LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_IN,
795 FUNC_READ_DATA, 0, 0, (char *) usb_in_buffer, OPENDOUS_IN_BUFFER_SIZE, OPENDOUS_USB_TIMEOUT);
796 } else {
797 result = jtag_libusb_bulk_read(opendous_jtag->usb_handle, OPENDOUS_READ_ENDPOINT,
798 (char *)usb_in_buffer, OPENDOUS_IN_BUFFER_SIZE, OPENDOUS_USB_TIMEOUT);
799 }
800 #ifdef _DEBUG_USB_COMMS_
801 LOG_DEBUG("%s: USB read end: %d bytes", opendous_get_time(time_str), result);
802 #endif
803 DEBUG_JTAG_IO("opendous_usb_read, result = %d", result);
804
805 #ifdef _DEBUG_USB_COMMS_
806 opendous_debug_buffer(usb_in_buffer, result);
807 #endif
808 return result;
809 }
810
811 #ifdef _DEBUG_USB_COMMS_
812 #define BYTES_PER_LINE 16
813
814 void opendous_debug_buffer(uint8_t *buffer, int length)
815 {
816 char line[81];
817 char s[4];
818 int i;
819 int j;
820
821 for (i = 0; i < length; i += BYTES_PER_LINE) {
822 snprintf(line, 5, "%04x", i);
823 for (j = i; j < i + BYTES_PER_LINE && j < length; j++) {
824 snprintf(s, 4, " %02x", buffer[j]);
825 strcat(line, s);
826 }
827 LOG_DEBUG("%s", line);
828 }
829 }
830
831 char *opendous_get_time(char *str)
832 {
833 struct timeb timebuffer;
834 char *timeline;
835
836 ftime(&timebuffer);
837 timeline = ctime(&(timebuffer.time));
838 snprintf(str, 49, "%.8s.%hu", &timeline[11], timebuffer.millitm);
839 return str;
840 }
841 #endif
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)