?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Warnings cleanup ... finish up earlier commit
[openocd.git] / src / jtag / vsllink.c
blobcc85c5c1d2cee19a41f62309236df09b85a3b234
1 /***************************************************************************
2 * Copyright (C) 2007 by Simon Qian <SimonQian@SimonQian.com> *
3 * *
4 * This program is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
8 * *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
13 * *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program; if not, write to the *
16 * Free Software Foundation, Inc., *
17 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
18 ***************************************************************************/
19
20 /* Versaloon is a programming tool for multiple MCUs.
21 * OpenOCD and MSP430 supports are distributed under GPLv2.
22 * You can find it at http://www.SimonQian.com/en/Versaloon.
23 */
24
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28
29 #include "replacements.h"
30
31 #include "jtag.h"
32
33 #include <usb.h>
34 #include <string.h>
35
36 #include "log.h"
37
38 //#define _VSLLINK_IN_DEBUG_MODE_
39
40 /* enable this to view USB communication
41 */
42 #if 0
43 #define _DEBUG_USB_COMMS_
44 #endif
45
46 #ifdef _DEBUG_JTAG_IO_
47 #define DEBUG_JTAG_IO(expr ...) LOG_DEBUG(expr)
48 #else
49 #define DEBUG_JTAG_IO(expr ...)
50 #endif
51
52 #define VID 0x03EB
53 #define PID 0x2103
54 #define VSLLINK_WRITE_ENDPOINT 0x02
55 #define VSLLINK_READ_ENDPOINT 0x82
56
57 u16 vsllink_vid = VID;
58 u16 vsllink_pid = PID;
59 u8 vsllink_bulkout = VSLLINK_WRITE_ENDPOINT;
60 u8 vsllink_bulkin = VSLLINK_READ_ENDPOINT;
61
62 #define VSLLINK_USB_TIMEOUT 1000
63
64 static int VSLLINK_BufferSize = 1024;
65
66 /* Global USB buffers */
67 static int vsllink_usb_out_buffer_idx;
68 static int vsllink_usb_in_want_length;
69 static u8* vsllink_usb_in_buffer = NULL;
70 static u8* vsllink_usb_out_buffer = NULL;
71
72 /* Constants for VSLLink command */
73 #define VSLLINK_CMD_CONN 0x80
74 #define VSLLINK_CMD_DISCONN 0x81
75 #define VSLLINK_CMD_SET_SPEED 0x82
76 #define VSLLINK_CMD_SET_PORT 0x90
77 #define VSLLINK_CMD_GET_PORT 0x91
78 #define VSLLINK_CMD_SET_PORTDIR 0x92
79 #define VSLLINK_CMD_HW_JTAGSEQCMD 0xA0
80
81 #define VSLLINK_CMDJTAGSEQ_TMSBYTE 0x00
82 #define VSLLINK_CMDJTAGSEQ_SCAN 0x80
83
84 #define VSLLINK_CMDJTAGSEQ_CMDMSK 0xC0
85 #define VSLLINK_CMDJTAGSEQ_LENMSK 0x3F
86
87 #define JTAG_PINMSK_SRST (1 << 0)
88 #define JTAG_PINMSK_TRST (1 << 1)
89 #define JTAG_PINMSK_USR1 (1 << 2)
90 #define JTAG_PINMSK_USR2 (1 << 3)
91 #define JTAG_PINMSK_TCK (1 << 4)
92 #define JTAG_PINMSK_TMS (1 << 5)
93 #define JTAG_PINMSK_TDI (1 << 6)
94 #define JTAG_PINMSK_TDO (1 << 7)
95
96
97 #define VSLLINK_TAP_MOVE(from, to) VSLLINK_tap_move[tap_move_map[from]][tap_move_map[to]]
98
99 /* VSLLINK_tap_move[i][j]: tap movement command to go from state i to state j
100 * 0: Test-Logic-Reset
101 * 1: Run-Test/Idle
102 * 2: Shift-DR
103 * 3: Pause-DR
104 * 4: Shift-IR
105 * 5: Pause-IR
106 *
107 * SD->SD and SI->SI have to be caught in interface specific code
108 */
109 u8 VSLLINK_tap_move[6][6] =
110 {
111 /* TLR RTI SD PD SI PI */
112 {0xff, 0x00, 0x2f, 0x0a, 0x37, 0x16}, /* TLR */
113 {0xff, 0x00, 0x45, 0x05, 0x4b, 0x0b}, /* RTI */
114 {0xff, 0x61, 0x00, 0x01, 0x0f, 0x2f}, /* SD */
115 {0xff, 0x60, 0x40, 0x17, 0x3c, 0x2f}, /* PD */
116 {0xff, 0x61, 0x07, 0x17, 0x00, 0x01}, /* SI */
117 {0xff, 0x60, 0x38, 0x17, 0x40, 0x2f} /* PI */
118 };
119
120 u8 VSLLINK_TAP_MOVE_FROM_E1[6] =
121 {
122 // TLR RTI SD PD SI PI
123 0xff, 0x60, 0x38, 0x5c, 0x3c, 0x5E
124 };
125
126 u8 VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[7][6][2] =
127 {
128 /* stuff offset */
129 {/* TLR */
130 {1, 0,}, /* TLR */
131 {1, 0,}, /* RTI */
132 {1, 0,}, /* SD */
133 {1, 0,}, /* PD */
134 {1, 0,}, /* SI */
135 {1, 0,}}, /* PI */
136 {/* RTI */
137 {1, 0,}, /* TLR */
138 {0, 0,}, /* RTI */
139 {0, 4,}, /* SD */
140 {0, 7,}, /* PD */
141 {0, 5,}, /* SI */
142 {0, 7,}}, /* PI */
143 {/* SD */
144 {0, 0,}, /* TLR */
145 {0, 0,}, /* RTI */
146 {0, 0,}, /* SD */
147 {0, 0,}, /* PD */
148 {0, 0,}, /* SI */
149 {0, 0,}}, /* PI */
150 {/* PD */
151 {0, 0,}, /* TLR */
152 {0, 0,}, /* RTI */
153 {0, 0,}, /* SD */
154 {0, 0,}, /* PD */
155 {0, 0,}, /* SI */
156 {0, 0,}}, /* PI */
157 {/* SI */
158 {0, 0,}, /* TLR */
159 {0, 0,}, /* RTI */
160 {0, 0,}, /* SD */
161 {0, 0,}, /* PD */
162 {0, 0,}, /* SI */
163 {0, 0,}}, /* PI */
164 {/* PI */
165 {0, 0,}, /* TLR */
166 {0, 0,}, /* RTI */
167 {0, 0,}, /* SD */
168 {0, 0,}, /* PD */
169 {0, 0,}, /* SI */
170 {0, 0,}}, /* PI */
171 };
172
173 u8 VSLLINK_BIT_MSK[8] =
174 {
175 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f
176 };
177
178 /* External interface functions */
179 int vsllink_execute_queue(void);
180 int vsllink_speed(int speed);
181 int vsllink_khz(int khz, int *jtag_speed);
182 int vsllink_speed_div(int jtag_speed, int *khz);
183 int vsllink_register_commands(struct command_context_s *cmd_ctx);
184 int vsllink_init(void);
185 int vsllink_quit(void);
186
187 /* CLI command handler functions */
188 int vsllink_handle_usb_vid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
189 int vsllink_handle_usb_pid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
190 int vsllink_handle_usb_bulkin_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
191 int vsllink_handle_usb_bulkout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
192
193 /* Queue command functions */
194 void vsllink_end_state(enum tap_state state);
195 void vsllink_state_move(void);
196 void vsllink_path_move(int num_states, enum tap_state *path);
197 void vsllink_runtest(int num_cycles);
198 void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command);
199 void vsllink_reset(int trst, int srst);
200 void vsllink_simple_command(u8 command);
201
202 /* VSLLink tap buffer functions */
203 void vsllink_tap_init(void);
204 int vsllink_tap_execute(void);
205 void vsllink_tap_ensure_space(int scans, int bytes);
206 void vsllink_tap_append_scan(int length, u8 *buffer, scan_command_t *command, int offset);
207
208 /* VSLLink lowlevel functions */
209 typedef struct vsllink_jtag
210 {
211 struct usb_dev_handle* usb_handle;
212 } vsllink_jtag_t;
213
214 vsllink_jtag_t *vsllink_usb_open(void);
215 void vsllink_usb_close(vsllink_jtag_t *vsllink_jtag);
216 int vsllink_usb_message(vsllink_jtag_t *vsllink_jtag, int out_length, int in_length);
217 int vsllink_usb_write(vsllink_jtag_t *vsllink_jtag, int out_length);
218 int vsllink_usb_read(vsllink_jtag_t *vsllink_jtag);
219
220 void vsllink_debug_buffer(u8 *buffer, int length);
221
222 int vsllink_tms_data_len = 0;
223 u8* vsllink_tms_cmd_pos;
224
225 vsllink_jtag_t* vsllink_jtag_handle;
226
227 /***************************************************************************/
228 /* External interface implementation */
229
230 jtag_interface_t vsllink_interface =
231 {
232 .name = "vsllink",
233 .execute_queue = vsllink_execute_queue,
234 .speed = vsllink_speed,
235 .khz = vsllink_khz,
236 .speed_div = vsllink_speed_div,
237 .register_commands = vsllink_register_commands,
238 .init = vsllink_init,
239 .quit = vsllink_quit
240 };
241
242 int vsllink_execute_queue(void)
243 {
244 jtag_command_t *cmd = jtag_command_queue;
245 int scan_size;
246 enum scan_type type;
247 u8 *buffer;
248
249 DEBUG_JTAG_IO("--------------------------------------------------------------------------------");
250
251 vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGSEQCMD;
252 vsllink_usb_out_buffer_idx = 3;
253 while (cmd != NULL)
254 {
255 switch (cmd->type)
256 {
257 case JTAG_END_STATE:
258 DEBUG_JTAG_IO("end_state: %i", cmd->cmd.end_state->end_state);
259
260 if (cmd->cmd.end_state->end_state != -1)
261 {
262 vsllink_end_state(cmd->cmd.end_state->end_state);
263 }
264 break;
265
266 case JTAG_RUNTEST:
267 DEBUG_JTAG_IO( "runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, \
268 cmd->cmd.runtest->end_state);
269
270 if (cmd->cmd.runtest->end_state != -1)
271 {
272 vsllink_end_state(cmd->cmd.runtest->end_state);
273 }
274 vsllink_runtest(cmd->cmd.runtest->num_cycles);
275 break;
276
277 case JTAG_STATEMOVE:
278 DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
279
280 if (cmd->cmd.statemove->end_state != -1)
281 {
282 vsllink_end_state(cmd->cmd.statemove->end_state);
283 }
284 vsllink_state_move();
285 break;
286
287 case JTAG_PATHMOVE:
288 DEBUG_JTAG_IO("pathmove: %i states, end in %i", \
289 cmd->cmd.pathmove->num_states, \
290 cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
291
292 vsllink_path_move(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path);
293 break;
294
295 case JTAG_SCAN:
296 if (cmd->cmd.scan->end_state != -1)
297 {
298 vsllink_end_state(cmd->cmd.scan->end_state);
299 }
300
301 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
302 if (cmd->cmd.scan->ir_scan)
303 {
304 DEBUG_JTAG_IO("JTAG Scan write IR(%d bits), end in %d:", scan_size, cmd->cmd.scan->end_state);
305 }
306 else
307 {
308 DEBUG_JTAG_IO("JTAG Scan write DR(%d bits), end in %d:", scan_size, cmd->cmd.scan->end_state);
309 }
310
311 #ifdef _DEBUG_JTAG_IO_
312 vsllink_debug_buffer(buffer, (scan_size + 7) >> 3);
313 #endif
314
315 type = jtag_scan_type(cmd->cmd.scan);
316
317 vsllink_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size, cmd->cmd.scan);
318 break;
319
320 case JTAG_RESET:
321 DEBUG_JTAG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
322
323 vsllink_tap_execute();
324
325 if (cmd->cmd.reset->trst == 1)
326 {
327 cur_state = TAP_RESET;
328 }
329 vsllink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
330
331 vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGSEQCMD;
332 vsllink_usb_out_buffer_idx = 3;
333 break;
334
335 case JTAG_SLEEP:
336 DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
337 vsllink_tap_execute();
338 jtag_sleep(cmd->cmd.sleep->us);
339 break;
340
341 default:
342 LOG_ERROR("BUG: unknown JTAG command type encountered");
343 exit(-1);
344 }
345 cmd = cmd->next;
346 }
347
348 return vsllink_tap_execute();
349 }
350
351 int vsllink_speed(int speed)
352 {
353 int result;
354
355 vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_SPEED;
356 vsllink_usb_out_buffer[1] = (speed >> 0) & 0xff;
357 vsllink_usb_out_buffer[2] = (speed >> 8) & 0xFF;
358
359 result = vsllink_usb_write(vsllink_jtag_handle, 3);
360
361 if (result == 3)
362 {
363 return ERROR_OK;
364 }
365 else
366 {
367 LOG_ERROR("VSLLink setting speed failed (%d)", result);
368 return ERROR_JTAG_DEVICE_ERROR;
369 }
370
371 return ERROR_OK;
372 }
373
374 int vsllink_khz(int khz, int *jtag_speed)
375 {
376 *jtag_speed = khz;
377
378 return ERROR_OK;
379 }
380
381 int vsllink_speed_div(int jtag_speed, int *khz)
382 {
383 *khz = jtag_speed;
384
385 return ERROR_OK;
386 }
387
388 int vsllink_register_commands(struct command_context_s *cmd_ctx)
389 {
390 register_command(cmd_ctx, NULL, "vsllink_usb_vid", vsllink_handle_usb_vid_command,
391 COMMAND_CONFIG, NULL);
392 register_command(cmd_ctx, NULL, "vsllink_usb_pid", vsllink_handle_usb_pid_command,
393 COMMAND_CONFIG, NULL);
394 register_command(cmd_ctx, NULL, "vsllink_usb_bulkin", vsllink_handle_usb_bulkin_command,
395 COMMAND_CONFIG, NULL);
396 register_command(cmd_ctx, NULL, "vsllink_usb_bulkout", vsllink_handle_usb_bulkout_command,
397 COMMAND_CONFIG, NULL);
398
399 return ERROR_OK;
400 }
401
402 int vsllink_init(void)
403 {
404 int check_cnt;
405 int result;
406 char version_str[100];
407
408 vsllink_usb_in_buffer = malloc(VSLLINK_BufferSize);
409 vsllink_usb_out_buffer = malloc(VSLLINK_BufferSize);
410 if ((vsllink_usb_in_buffer == NULL) || (vsllink_usb_out_buffer == NULL))
411 {
412 LOG_ERROR("Not enough memory");
413 exit(-1);
414 }
415
416 vsllink_jtag_handle = vsllink_usb_open();
417
418 if (vsllink_jtag_handle == 0)
419 {
420 LOG_ERROR("Can't find USB JTAG Interface! Please check connection and permissions.");
421 return ERROR_JTAG_INIT_FAILED;
422 }
423
424 check_cnt = 0;
425 while (check_cnt < 3)
426 {
427 vsllink_simple_command(VSLLINK_CMD_CONN);
428 result = vsllink_usb_read(vsllink_jtag_handle);
429
430 if (result > 2)
431 {
432 vsllink_usb_in_buffer[result] = 0;
433 VSLLINK_BufferSize = vsllink_usb_in_buffer[0] + (vsllink_usb_in_buffer[1] << 8);
434 strncpy(version_str, (char *)vsllink_usb_in_buffer + 2, sizeof(version_str));
435 LOG_INFO(version_str);
436
437 // free the pre-alloc memroy
438 free(vsllink_usb_in_buffer);
439 free(vsllink_usb_out_buffer);
440 vsllink_usb_in_buffer = NULL;
441 vsllink_usb_out_buffer = NULL;
442
443 // alloc new memory
444 vsllink_usb_in_buffer = malloc(VSLLINK_BufferSize);
445 vsllink_usb_out_buffer = malloc(VSLLINK_BufferSize);
446 if ((vsllink_usb_in_buffer == NULL) || (vsllink_usb_out_buffer == NULL))
447 {
448 LOG_ERROR("Not enough memory");
449 exit(-1);
450 }
451 else
452 {
453 LOG_INFO("buffer size for USB is %d bytes", VSLLINK_BufferSize);
454 }
455 break;
456 }
457 vsllink_simple_command(VSLLINK_CMD_DISCONN);
458
459 check_cnt++;
460 }
461
462 if (check_cnt == 3)
463 {
464 // It's dangerout to proced
465 LOG_ERROR("VSLLink initial failed");
466 exit(-1);
467 }
468
469 // Set SRST and TRST to output, Set USR1 and USR2 to input
470 vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_PORTDIR;
471 vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST | JTAG_PINMSK_USR1 | JTAG_PINMSK_USR2;
472 vsllink_usb_out_buffer[2] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST;
473 result = vsllink_usb_write(vsllink_jtag_handle, 3);
474 if (result != 3)
475 {
476 LOG_ERROR("VSLLink USB send data error");
477 exit(-1);
478 }
479
480 vsllink_reset(0, 0);
481
482 LOG_INFO("VSLLink JTAG Interface ready");
483
484 vsllink_tap_init();
485
486 return ERROR_OK;
487 }
488
489 int vsllink_quit(void)
490 {
491 if ((vsllink_usb_in_buffer != NULL) && (vsllink_usb_out_buffer != NULL))
492 {
493 vsllink_simple_command(VSLLINK_CMD_DISCONN);
494 vsllink_usb_close(vsllink_jtag_handle);
495 }
496
497 if (vsllink_usb_in_buffer != NULL)
498 {
499 free(vsllink_usb_in_buffer);
500 }
501 if (vsllink_usb_out_buffer != NULL)
502 {
503 free(vsllink_usb_out_buffer);
504 }
505 return ERROR_OK;
506 }
507
508 // when vsllink_tms_data_len > 0, vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] is the byte that need to be appended.
509 // length of VSLLINK_CMDJTAGSEQ_TMSBYTE has been set.
510 void VSLLINK_add_tms_from_RTI(enum tap_state state)
511 {
512 u8 tms_scan = VSLLINK_TAP_MOVE(TAP_IDLE, state);
513 u16 tms2;
514
515 if ((cur_state != TAP_IDLE) || (state == TAP_IDLE) || (vsllink_tms_data_len <= 0) || (vsllink_tms_data_len >= 8) || (vsllink_tms_cmd_pos == NULL))
516 {
517 LOG_ERROR("There MUST be some bugs in the driver");
518 exit(-1);
519 }
520
521 tms2 = (tms_scan & VSLLINK_BIT_MSK[VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[1][tap_move_map[state]][1]]) << vsllink_tms_data_len;
522 if (VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[1][tap_move_map[state]][0] == 1)
523 {
524 tms2 |= VSLLINK_BIT_MSK[8 - vsllink_tms_data_len] << (vsllink_tms_data_len + VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[1][tap_move_map[state]][1]);
525 }
526 tms2 |= (tms_scan >> VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[1][tap_move_map[state]][1]) << (8 + VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[1][tap_move_map[state]][1]);
527
528 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (tms2 >> 0) & 0xff;
529 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tms2 >> 8) & 0xff;
530
531 vsllink_tms_data_len = 0;
532 vsllink_tms_cmd_pos = NULL;
533 }
534
535 /***************************************************************************/
536 /* Queue command implementations */
537
538 void vsllink_end_state(enum tap_state state)
539 {
540 if (tap_move_map[state] != -1)
541 {
542 end_state = state;
543 }
544 else
545 {
546 LOG_ERROR("BUG: %i is not a valid end state", state);
547 exit(-1);
548 }
549 }
550
551 /* Goes to the end state. */
552 void vsllink_state_move(void)
553 {
554 if (vsllink_tms_data_len > 0)
555 {
556 VSLLINK_add_tms_from_RTI(end_state);
557 }
558 else
559 {
560 vsllink_tap_ensure_space(0, 2);
561
562 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE;
563 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(cur_state, end_state);
564 }
565
566 cur_state = end_state;
567 }
568
569 // write tms from current vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx]
570 void vsllink_add_path(int start, int num, enum tap_state *path)
571 {
572 int i;
573
574 for (i = start; i < (start + num); i++)
575 {
576 if ((i & 7) == 0)
577 {
578 if (i > 0)
579 {
580 vsllink_usb_out_buffer[++vsllink_usb_out_buffer_idx] = 0;
581 }
582 else
583 {
584 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = 0;
585 }
586 }
587
588 if (path[i - start] == tap_transitions[cur_state].high)
589 {
590 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] |= 1 << (i & 7);
591 }
592 else
593 {
594 LOG_ERROR("BUG: %d -> %d isn't a valid TAP transition", cur_state, path[i]);
595 exit(-1);
596 }
597
598 cur_state = path[i];
599 }
600 end_state = cur_state;
601 }
602
603 void vsllink_path_move(int num_states, enum tap_state *path)
604 {
605 int i, tms_len, tms_cmd_pos, path_idx = 0;
606
607 if (vsllink_tms_data_len > 0)
608 {
609 if ((vsllink_tms_data_len + num_states) < 8)
610 {
611 vsllink_add_path(vsllink_tms_data_len, num_states, path);
612 num_states = 0;
613 }
614 else if ((vsllink_tms_data_len + num_states) < 16)
615 {
616 if ((*vsllink_tms_cmd_pos & VSLLINK_CMDJTAGSEQ_LENMSK) \
617 < VSLLINK_CMDJTAGSEQ_LENMSK)
618 {
619 *vsllink_tms_cmd_pos++;
620 vsllink_add_path(vsllink_tms_data_len, num_states, path);
621 }
622 else
623 {
624 // need a new VSLLINK_CMDJTAGSEQ_TMSBYTE command
625 // if vsllink_tms_data_len > 0, length of VSLLINK_CMDJTAGSEQ_TMSBYTE MUST be > 1(tms_len > 2)
626 *vsllink_tms_cmd_pos--;
627 vsllink_add_path(vsllink_tms_data_len, 8 - vsllink_tms_data_len, path);
628 vsllink_usb_out_buffer_idx++;
629 vsllink_tap_ensure_space(0, 3);
630 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | 1;
631 vsllink_tms_cmd_pos = vsllink_usb_out_buffer + vsllink_usb_out_buffer_idx;
632 vsllink_add_path(vsllink_tms_data_len, num_states + vsllink_tms_data_len - 8, path + 8 - vsllink_tms_data_len);
633 }
634 vsllink_tms_data_len = (vsllink_tms_data_len + num_states) & 7;
635 num_states = 0;
636 }
637 else
638 {
639 vsllink_add_path(vsllink_tms_data_len, 16 - vsllink_tms_data_len, path);
640 path_idx = 16 - vsllink_tms_data_len;
641 vsllink_usb_out_buffer_idx++;
642
643 num_states -= 16 - vsllink_tms_data_len;
644 path += 16 - vsllink_tms_data_len;
645 vsllink_tms_data_len = 0;
646 vsllink_tms_cmd_pos = NULL;
647 }
648 }
649
650 if (num_states > 0)
651 {
652 // Normal operation, don't need to append tms data
653 vsllink_tms_data_len = num_states & 7;
654
655 while (num_states > 0)
656 {
657 if (num_states > ((VSLLINK_CMDJTAGSEQ_LENMSK + 1) * 8))
658 {
659 i = (VSLLINK_CMDJTAGSEQ_LENMSK + 1) * 8;
660 }
661 else
662 {
663 i = num_states;
664 }
665 tms_len = (i + 7) >> 3;
666 vsllink_tap_ensure_space(0, tms_len + 2);
667 tms_cmd_pos = vsllink_usb_out_buffer_idx;
668 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | (tms_len - 1);
669
670 vsllink_add_path(0, i, path + path_idx);
671
672 path_idx += i;
673 num_states -= i;
674 }
675
676 if (vsllink_tms_data_len > 0)
677 {
678 if (tms_len < (VSLLINK_CMDJTAGSEQ_LENMSK + 1))
679 {
680 vsllink_usb_out_buffer[tms_cmd_pos]++;
681 vsllink_usb_out_buffer = vsllink_usb_out_buffer + tms_cmd_pos;
682 }
683 else
684 {
685 vsllink_usb_out_buffer[tms_cmd_pos]--;
686 tms_len = vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx];
687 vsllink_tap_ensure_space(0, 3);
688 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | 1;
689 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = tms_len;
690 }
691 }
692 }
693 }
694
695 void vsllink_runtest(int num_cycles)
696 {
697 int i, j;
698 int tms_len, first_tms = 0, tms_cmd_pos;
699 enum tap_state saved_end_state = end_state;
700
701 if (cur_state != TAP_IDLE)
702 {
703 vsllink_end_state(TAP_IDLE);
704
705 if (vsllink_tms_data_len > 0)
706 {
707 VSLLINK_add_tms_from_RTI(end_state);
708 }
709 else
710 {
711 first_tms = 1;
712 }
713 }
714
715 if (vsllink_tms_data_len > 0)
716 {
717 // cur_state == TAP_IDLE
718 if ((vsllink_tms_data_len + num_cycles) < 8)
719 {
720 vsllink_tms_data_len += num_cycles;
721 num_cycles = 0;
722 }
723 else if ((vsllink_tms_data_len + num_cycles) < 16)
724 {
725 if ((*vsllink_tms_cmd_pos & VSLLINK_CMDJTAGSEQ_LENMSK) \
726 < VSLLINK_CMDJTAGSEQ_LENMSK)
727 {
728 *vsllink_tms_cmd_pos++;
729 vsllink_usb_out_buffer[++vsllink_usb_out_buffer_idx] = 0;
730 }
731 else
732 {
733 // need a new VSLLINK_CMDJTAGSEQ_TMSBYTE command
734 // if vsllink_tms_data_len > 0, length of VSLLINK_CMDJTAGSEQ_TMSBYTE MUST be > 1(tms_len > 2)
735 *vsllink_tms_cmd_pos--;
736 vsllink_tap_ensure_space(0, 3);
737 vsllink_usb_out_buffer[++vsllink_usb_out_buffer_idx] = VSLLINK_CMDJTAGSEQ_TMSBYTE | 1;
738 vsllink_tms_cmd_pos = vsllink_usb_out_buffer + vsllink_usb_out_buffer_idx;
739 vsllink_usb_out_buffer[++vsllink_usb_out_buffer_idx] = 0;
740 }
741 vsllink_tms_data_len = (vsllink_tms_data_len + num_cycles) & 7;
742 num_cycles = 0;
743 }
744 else
745 {
746 vsllink_usb_out_buffer[++vsllink_usb_out_buffer_idx] = 0;
747 vsllink_usb_out_buffer_idx++;
748
749 num_cycles -= 16 - vsllink_tms_data_len;
750 vsllink_tms_data_len = 0;
751 vsllink_tms_cmd_pos = NULL;
752 }
753 }
754
755 tms_len = ((num_cycles + 7) >> 3) + first_tms;
756 if (tms_len > 0)
757 {
758 // Normal operation, don't need to append tms data
759 vsllink_tms_data_len = num_cycles & 7;
760
761 if (vsllink_tms_data_len > 0)
762 {
763 tms_len += 1;
764 }
765 // tms_len includes the length of tms byte to append
766
767 // Make sure there is enough space
768 // 1 more byte maybe needed for the last tms move
769 vsllink_tap_ensure_space(0, (tms_len / VSLLINK_CMDJTAGSEQ_LENMSK) + tms_len + 1);
770
771 while(tms_len > 0)
772 {
773 if (tms_len > (VSLLINK_CMDJTAGSEQ_LENMSK + 1))
774 {
775 i = VSLLINK_CMDJTAGSEQ_LENMSK + 1;
776 }
777 else
778 {
779 i = tms_len;
780 }
781
782 tms_cmd_pos = vsllink_usb_out_buffer_idx;
783
784 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | (i - 1);
785
786 if (first_tms)
787 {
788 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(cur_state, end_state);
789 first_tms = 0;
790 j = i - 1;
791 }
792 else
793 {
794 j = i;
795 }
796
797 while (j-- > 0)
798 {
799 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0;
800 }
801
802 tms_len -= i;
803 }
804
805 // post process vsllink_usb_out_buffer_idx
806 if (vsllink_tms_data_len > 0)
807 {
808 vsllink_usb_out_buffer_idx -= 2;
809 }
810
811 // Set end_state
812 vsllink_end_state(saved_end_state);
813 cur_state = TAP_IDLE;
814 if (saved_end_state != TAP_IDLE)
815 {
816 if (vsllink_tms_data_len > 0)
817 {
818 VSLLINK_add_tms_from_RTI(end_state);
819 }
820 else
821 {
822 if (i < (VSLLINK_CMDJTAGSEQ_LENMSK + 1))
823 {
824 vsllink_usb_out_buffer[tms_cmd_pos]++;
825 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(TAP_IDLE, end_state);
826 }
827 else
828 {
829 vsllink_tap_ensure_space(0, 2);
830 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE;
831 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(TAP_IDLE, end_state);
832 }
833 }
834 cur_state = saved_end_state;
835 }
836
837 if (vsllink_tms_data_len > 0)
838 {
839 vsllink_tms_cmd_pos = vsllink_usb_out_buffer + tms_cmd_pos;
840 }
841 }
842 else
843 {
844 // Set end_state if no RTI shifts
845 vsllink_end_state(saved_end_state);
846 cur_state = TAP_IDLE;
847 if (saved_end_state != TAP_IDLE)
848 {
849 vsllink_tap_ensure_space(0, 2);
850 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE;
851 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(TAP_IDLE, end_state);
852
853 cur_state = saved_end_state;
854 }
855 }
856 }
857
858 void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command)
859 {
860 enum tap_state saved_end_state;
861 u8 bits_left, tms_tmp, tdi_len;
862 int i;
863
864 tdi_len = ((scan_size + 7) >> 3);
865 if ((tdi_len + 7) > VSLLINK_BufferSize)
866 {
867 LOG_ERROR("Your implementation of VSLLink has not enough buffer");
868 exit(-1);
869 }
870
871 saved_end_state = end_state;
872
873 /* Move to appropriate scan state */
874 vsllink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
875
876 if (vsllink_tms_data_len > 0)
877 {
878 if (cur_state == end_state)
879 {
880 *vsllink_tms_cmd_pos--;
881 tms_tmp = vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx];
882 vsllink_tap_ensure_space(1, tdi_len + 7);
883
884 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_SCAN | 1;
885 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1) >> 0) & 0xff;
886 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1)>> 8) & 0xff;
887 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = tms_tmp;
888 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = buffer[0] << (8 - vsllink_tms_data_len);
889
890 for (i = 0; i < tdi_len; i++)
891 {
892 buffer[i] >>= 8 - vsllink_tms_data_len;
893 if (i != tdi_len)
894 {
895 buffer[i] += buffer[i + 1] << vsllink_tms_data_len;
896 }
897 }
898
899 vsllink_tap_append_scan(scan_size - vsllink_tms_data_len, buffer, command, vsllink_tms_data_len);
900 scan_size -= 8 - vsllink_tms_data_len;
901 }
902 else
903 {
904 VSLLINK_add_tms_from_RTI(end_state);
905 vsllink_tap_ensure_space(1, tdi_len + 5);
906
907 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_SCAN;
908 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tdi_len >> 0) & 0xff;
909 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tdi_len >> 8) & 0xff;
910
911 vsllink_tap_append_scan(scan_size, buffer, command, 0);
912 }
913 }
914 else
915 {
916 vsllink_tap_ensure_space(1, tdi_len + 7);
917
918 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_SCAN | 1;
919 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1) >> 0) & 0xff;
920 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1)>> 8) & 0xff;
921 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(cur_state, end_state);
922 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0;
923
924 vsllink_tap_append_scan(scan_size, buffer, command, 8);
925 }
926 vsllink_end_state(saved_end_state);
927
928 bits_left = scan_size & 0x07;
929 cur_state = ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE;
930
931 if (bits_left > 0)
932 {
933 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 1 << (bits_left - 1);
934 }
935 else
936 {
937 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 1 << 7;
938 }
939
940 if (cur_state != end_state)
941 {
942 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE_FROM_E1[tap_move_map[end_state]];
943 }
944 else
945 {
946 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0;
947 }
948
949 cur_state = end_state;
950 }
951
952 void vsllink_reset(int trst, int srst)
953 {
954 int result;
955
956 LOG_DEBUG("trst: %i, srst: %i", trst, srst);
957
958 /* Signals are active low */
959 vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_PORT;
960 vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST;
961 vsllink_usb_out_buffer[2] = 0;
962 if (srst == 0)
963 {
964 vsllink_usb_out_buffer[2] |= JTAG_PINMSK_SRST;
965 }
966 if (trst == 0)
967 {
968 vsllink_usb_out_buffer[2] |= JTAG_PINMSK_TRST;
969 }
970
971 result = vsllink_usb_write(vsllink_jtag_handle, 3);
972 if (result != 3)
973 {
974 LOG_ERROR("VSLLink command VSLLINK_CMD_SET_PORT failed (%d)", result);
975 }
976 }
977
978 void vsllink_simple_command(u8 command)
979 {
980 int result;
981
982 DEBUG_JTAG_IO("0x%02x", command);
983
984 vsllink_usb_out_buffer[0] = command;
985 result = vsllink_usb_write(vsllink_jtag_handle, 1);
986
987 if (result != 1)
988 {
989 LOG_ERROR("VSLLink command 0x%02x failed (%d)", command, result);
990 }
991 }
992
993 int vsllink_handle_usb_vid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
994 {
995 if (argc != 1) {
996 LOG_ERROR("parameter error, should be one parameter for VID");
997 return ERROR_OK;
998 }
999
1000 vsllink_vid = strtol(args[0], NULL, 0);
1001
1002 return ERROR_OK;
1003 }
1004
1005 int vsllink_handle_usb_pid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1006 {
1007 if (argc != 1) {
1008 LOG_ERROR("parameter error, should be one parameter for PID");
1009 return ERROR_OK;
1010 }
1011
1012 vsllink_pid = strtol(args[0], NULL, 0);
1013
1014 return ERROR_OK;
1015 }
1016
1017 int vsllink_handle_usb_bulkin_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1018 {
1019 if (argc != 1) {
1020 LOG_ERROR("parameter error, should be one parameter for BULKIN endpoint");
1021 return ERROR_OK;
1022 }
1023
1024 vsllink_bulkin = strtol(args[0], NULL, 0) | 0x80;
1025
1026 return ERROR_OK;
1027 }
1028
1029 int vsllink_handle_usb_bulkout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1030 {
1031 if (argc != 1) {
1032 LOG_ERROR("parameter error, should be one parameter for BULKOUT endpoint");
1033 return ERROR_OK;
1034 }
1035
1036 vsllink_bulkout = strtol(args[0], NULL, 0);
1037
1038 return ERROR_OK;
1039 }
1040
1041 /***************************************************************************/
1042 /* VSLLink tap functions */
1043
1044 typedef struct
1045 {
1046 int length; /* Number of bits to read */
1047 int offset;
1048 scan_command_t *command; /* Corresponding scan command */
1049 u8 *buffer;
1050 } pending_scan_result_t;
1051
1052 #define MAX_PENDING_SCAN_RESULTS 256
1053
1054 static int pending_scan_results_length;
1055 static pending_scan_result_t pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS];
1056
1057
1058 void vsllink_tap_init()
1059 {
1060 vsllink_usb_out_buffer_idx = 0;
1061 vsllink_usb_in_want_length = 0;
1062 pending_scan_results_length = 0;
1063 }
1064
1065 void vsllink_tap_ensure_space(int scans, int bytes)
1066 {
1067 int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length;
1068 int available_bytes = VSLLINK_BufferSize - vsllink_usb_out_buffer_idx;
1069
1070 if (scans > available_scans || bytes > available_bytes)
1071 {
1072 vsllink_tap_execute();
1073 vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGSEQCMD;
1074 vsllink_usb_out_buffer_idx = 3;
1075 }
1076 }
1077
1078 void vsllink_tap_append_scan(int length, u8 *buffer, scan_command_t *command, int offset)
1079 {
1080 pending_scan_result_t *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
1081 int i;
1082
1083 if (offset > 0)
1084 {
1085 vsllink_usb_in_want_length += ((length + 7) >> 3) + 1;
1086 }
1087 else
1088 {
1089 vsllink_usb_in_want_length += (length + 7) >> 3;
1090 }
1091 pending_scan_result->length = length;
1092 pending_scan_result->offset = offset;
1093 pending_scan_result->command = command;
1094 pending_scan_result->buffer = buffer;
1095
1096 for (i = 0; i < ((length + 7) >> 3); i++)
1097 {
1098 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = buffer[i];
1099 }
1100
1101 pending_scan_results_length++;
1102 }
1103
1104 /* Pad and send a tap sequence to the device, and receive the answer.
1105 * For the purpose of padding we assume that we are in idle or pause state. */
1106 int vsllink_tap_execute()
1107 {
1108 int i;
1109 int result;
1110 int first = 0;
1111
1112 if (vsllink_tms_data_len > 0)
1113 {
1114 if (vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] & (1 << (vsllink_tms_data_len - 1)))
1115 {
1116 // last tms bit is '1'
1117 // the only possible state is TLR, no need to control the number of shifts in RLT
1118 // There MUST be some errors in the code
1119 LOG_ERROR("last tms bit is '1'");
1120 exit(-1);
1121 }
1122 else
1123 {
1124 // last tms bit is '0'
1125 vsllink_usb_out_buffer_idx++;
1126 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0;
1127 vsllink_tms_data_len = 0;
1128 }
1129 }
1130
1131 if (vsllink_usb_out_buffer_idx > 3)
1132 {
1133 if (vsllink_usb_out_buffer[0] == VSLLINK_CMD_HW_JTAGSEQCMD)
1134 {
1135 vsllink_usb_out_buffer[1] = (vsllink_usb_out_buffer_idx >> 0) & 0xff;
1136 vsllink_usb_out_buffer[2] = (vsllink_usb_out_buffer_idx >> 8) & 0xff;
1137 }
1138
1139 result = vsllink_usb_message(vsllink_jtag_handle, vsllink_usb_out_buffer_idx, vsllink_usb_in_want_length);
1140
1141 if (result == vsllink_usb_in_want_length)
1142 {
1143 for (i = 0; i < pending_scan_results_length; i++)
1144 {
1145 pending_scan_result_t *pending_scan_result = &pending_scan_results_buffer[i];
1146 u8 *buffer = pending_scan_result->buffer;
1147 int length = pending_scan_result->length;
1148 int offset = pending_scan_result->offset;
1149 scan_command_t *command = pending_scan_result->command;
1150
1151 /* Copy to buffer */
1152 buf_set_buf(vsllink_usb_in_buffer, first * 8 + offset, buffer, 0, length);
1153 first += (length + offset + 7) >> 3;
1154
1155 DEBUG_JTAG_IO("JTAG scan read(%d bits):", length);
1156 #ifdef _DEBUG_JTAG_IO_
1157 vsllink_debug_buffer(buffer, (length + 7) >> 3);
1158 #endif
1159
1160 if (jtag_read_buffer(buffer, command) != ERROR_OK)
1161 {
1162 vsllink_tap_init();
1163 return ERROR_JTAG_QUEUE_FAILED;
1164 }
1165
1166 if (pending_scan_result->buffer != NULL)
1167 {
1168 free(pending_scan_result->buffer);
1169 pending_scan_result->buffer = NULL;
1170 }
1171 }
1172 }
1173 else
1174 {
1175 LOG_ERROR("vsllink_tap_execute, wrong result %d, expected %d", result, vsllink_usb_in_want_length);
1176 return ERROR_JTAG_QUEUE_FAILED;
1177 }
1178
1179 vsllink_tap_init();
1180 }
1181
1182 return ERROR_OK;
1183 }
1184
1185 /*****************************************************************************/
1186 /* VSLLink USB low-level functions */
1187
1188 vsllink_jtag_t* vsllink_usb_open()
1189 {
1190 struct usb_bus *busses;
1191 struct usb_bus *bus;
1192 struct usb_device *dev;
1193
1194 vsllink_jtag_t *result;
1195
1196 result = (vsllink_jtag_t*) malloc(sizeof(vsllink_jtag_t));
1197
1198 usb_init();
1199 usb_find_busses();
1200 usb_find_devices();
1201
1202 busses = usb_get_busses();
1203
1204 /* find vsllink_jtag device in usb bus */
1205
1206 for (bus = busses; bus; bus = bus->next)
1207 {
1208 for (dev = bus->devices; dev; dev = dev->next)
1209 {
1210 if ((dev->descriptor.idVendor == vsllink_vid) && (dev->descriptor.idProduct == vsllink_pid))
1211 {
1212 result->usb_handle = usb_open(dev);
1213
1214 /* usb_set_configuration required under win32 */
1215 usb_set_configuration(result->usb_handle, dev->config[0].bConfigurationValue);
1216 usb_claim_interface(result->usb_handle, 0);
1217
1218 #if 0
1219 /*
1220 * This makes problems under Mac OS X. And is not needed
1221 * under Windows. Hopefully this will not break a linux build
1222 */
1223 usb_set_altinterface(result->usb_handle, 0);
1224 #endif
1225 return result;
1226 }
1227 }
1228 }
1229
1230 free(result);
1231 return NULL;
1232 }
1233
1234 void vsllink_usb_close(vsllink_jtag_t *vsllink_jtag)
1235 {
1236 usb_close(vsllink_jtag->usb_handle);
1237 free(vsllink_jtag);
1238 }
1239
1240 /* Send a message and receive the reply. */
1241 int vsllink_usb_message(vsllink_jtag_t *vsllink_jtag, int out_length, int in_length)
1242 {
1243 int result;
1244
1245 result = vsllink_usb_write(vsllink_jtag, out_length);
1246 if (result == out_length)
1247 {
1248 if (in_length > 0)
1249 {
1250 result = vsllink_usb_read(vsllink_jtag);
1251 if (result == in_length )
1252 {
1253 return result;
1254 }
1255 else
1256 {
1257 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", in_length, result);
1258 return -1;
1259 }
1260 }
1261 return 0;
1262 }
1263 else
1264 {
1265 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)", out_length, result);
1266 return -1;
1267 }
1268 }
1269
1270 /* Write data from out_buffer to USB. */
1271 int vsllink_usb_write(vsllink_jtag_t *vsllink_jtag, int out_length)
1272 {
1273 int result;
1274
1275 if (out_length > VSLLINK_BufferSize)
1276 {
1277 LOG_ERROR("vsllink_jtag_write illegal out_length=%d (max=%d)", out_length, VSLLINK_BufferSize);
1278 return -1;
1279 }
1280
1281 result = usb_bulk_write(vsllink_jtag->usb_handle, vsllink_bulkout, \
1282 (char *)vsllink_usb_out_buffer, out_length, VSLLINK_USB_TIMEOUT);
1283
1284 DEBUG_JTAG_IO("vsllink_usb_write, out_length = %d, result = %d", out_length, result);
1285
1286 #ifdef _DEBUG_USB_COMMS_
1287 LOG_DEBUG("USB out:");
1288 vsllink_debug_buffer(vsllink_usb_out_buffer, out_length);
1289 #endif
1290
1291 #ifdef _VSLLINK_IN_DEBUG_MODE_
1292 usleep(100000);
1293 #endif
1294
1295 return result;
1296 }
1297
1298 /* Read data from USB into in_buffer. */
1299 int vsllink_usb_read(vsllink_jtag_t *vsllink_jtag)
1300 {
1301 int result = usb_bulk_read(vsllink_jtag->usb_handle, vsllink_bulkin, \
1302 (char *)vsllink_usb_in_buffer, VSLLINK_BufferSize, VSLLINK_USB_TIMEOUT);
1303
1304 DEBUG_JTAG_IO("vsllink_usb_read, result = %d", result);
1305
1306 #ifdef _DEBUG_USB_COMMS_
1307 LOG_DEBUG("USB in:");
1308 vsllink_debug_buffer(vsllink_usb_in_buffer, result);
1309 #endif
1310 return result;
1311 }
1312
1313 #define BYTES_PER_LINE 16
1314
1315 void vsllink_debug_buffer(u8 *buffer, int length)
1316 {
1317 char line[81];
1318 char s[4];
1319 int i;
1320 int j;
1321
1322 for (i = 0; i < length; i += BYTES_PER_LINE)
1323 {
1324 snprintf(line, 5, "%04x", i);
1325 for (j = i; j < i + BYTES_PER_LINE && j < length; j++)
1326 {
1327 snprintf(s, 4, " %02x", buffer[j]);
1328 strcat(line, s);
1329 }
1330 LOG_DEBUG(line);
1331 }
1332 }
Official OpenOCD Mirror