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