?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
JTAG/drivers: cleanup jtag_interface structs
[openocd.git] / src / jtag / drivers / vsllink.c
blobd3012906b291c85a605bfd4ac1225a5d453e0299
1 /***************************************************************************
2 * Copyright (C) 2009 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 <jtag/interface.h>
30 #include <jtag/commands.h>
31 #include "usb_common.h"
32
33 //#define _VSLLINK_IN_DEBUG_MODE_
34
35 #define VSLLINK_MODE_NORMAL 0
36 #define VSLLINK_MODE_DMA 1
37
38 static uint16_t vsllink_usb_vid;
39 static uint16_t vsllink_usb_pid;
40 static uint8_t vsllink_usb_bulkout;
41 static uint8_t vsllink_usb_bulkin;
42 static uint8_t vsllink_usb_interface;
43 static uint8_t vsllink_mode = VSLLINK_MODE_NORMAL;
44 static int VSLLINK_USB_TIMEOUT = 10000;
45
46 static int VSLLINK_BufferSize = 1024;
47
48 /* Global USB buffers */
49 static int vsllink_usb_out_buffer_idx;
50 static int vsllink_usb_in_want_length;
51 static uint8_t* vsllink_usb_in_buffer = NULL;
52 static uint8_t* vsllink_usb_out_buffer = NULL;
53
54 /* Constants for VSLLink command */
55 #define VSLLINK_CMD_CONN 0x80
56 #define VSLLINK_CMD_DISCONN 0x81
57 #define VSLLINK_CMD_SET_SPEED 0x82
58 #define VSLLINK_CMD_SET_PORT 0x90
59 #define VSLLINK_CMD_GET_PORT 0x91
60 #define VSLLINK_CMD_SET_PORTDIR 0x92
61 #define VSLLINK_CMD_HW_JTAGSEQCMD 0xA0
62 #define VSLLINK_CMD_HW_JTAGHLCMD 0xA1
63 #define VSLLINK_CMD_HW_SWDCMD 0xA2
64 #define VSLLINK_CMD_HW_JTAGRAWCMD 0xA3
65
66 #define VSLLINK_CMDJTAGSEQ_TMSBYTE 0x00
67 #define VSLLINK_CMDJTAGSEQ_TMSCLOCK 0x40
68 #define VSLLINK_CMDJTAGSEQ_SCAN 0x80
69
70 #define VSLLINK_CMDJTAGSEQ_CMDMSK 0xC0
71 #define VSLLINK_CMDJTAGSEQ_LENMSK 0x3F
72
73 #define JTAG_PINMSK_SRST (1 << 0)
74 #define JTAG_PINMSK_TRST (1 << 1)
75 #define JTAG_PINMSK_USR1 (1 << 2)
76 #define JTAG_PINMSK_USR2 (1 << 3)
77 #define JTAG_PINMSK_TCK (1 << 4)
78 #define JTAG_PINMSK_TMS (1 << 5)
79 #define JTAG_PINMSK_TDI (1 << 6)
80 #define JTAG_PINMSK_TDO (1 << 7)
81
82
83 #define VSLLINK_TAP_MOVE(from, to) VSLLINK_tap_move[tap_move_ndx(from)][tap_move_ndx(to)]
84
85 /* VSLLINK_tap_move[i][j]: tap movement command to go from state i to state j
86 * 0: Test-Logic-Reset
87 * 1: Run-Test/Idle
88 * 2: Shift-DR
89 * 3: Pause-DR
90 * 4: Shift-IR
91 * 5: Pause-IR
92 *
93 * SD->SD and SI->SI have to be caught in interface specific code
94 */
95 static uint8_t VSLLINK_tap_move[6][6] =
96 {
97 /* TLR RTI SD PD SI PI */
98 {0xff, 0x7f, 0x2f, 0x0a, 0x37, 0x16}, /* TLR */
99 {0xff, 0x00, 0x45, 0x05, 0x4b, 0x0b}, /* RTI */
100 {0xff, 0x61, 0x00, 0x01, 0x0f, 0x2f}, /* SD */
101 {0xfe, 0x60, 0x40, 0x5c, 0x3c, 0x5e}, /* PD */
102 {0xff, 0x61, 0x07, 0x17, 0x00, 0x01}, /* SI */
103 {0xfe, 0x60, 0x38, 0x5c, 0x40, 0x5e} /* PI */
104 };
105
106 struct insert_insignificant_operation {
107 unsigned char insert_value;
108 unsigned char insert_position;
109 };
110
111 static struct insert_insignificant_operation VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[6][6] =
112 {
113 /* stuff offset */
114 {/* TLR */
115 {1, 0,}, /* TLR */
116 {1, 0,}, /* RTI */
117 {1, 0,}, /* SD */
118 {1, 0,}, /* PD */
119 {1, 0,}, /* SI */
120 {1, 0,}}, /* PI */
121 {/* RTI */
122 {1, 0,}, /* TLR */
123 {0, 0,}, /* RTI */
124 {0, 4,}, /* SD */
125 {0, 7,}, /* PD */
126 {0, 5,}, /* SI */
127 {0, 7,}}, /* PI */
128 {/* SD */
129 {0, 0,}, /* TLR */
130 {0, 0,}, /* RTI */
131 {0, 0,}, /* SD */
132 {0, 0,}, /* PD */
133 {0, 0,}, /* SI */
134 {0, 0,}}, /* PI */
135 {/* PD */
136 {0, 0,}, /* TLR */
137 {0, 0,}, /* RTI */
138 {0, 0,}, /* SD */
139 {0, 0,}, /* PD */
140 {0, 0,}, /* SI */
141 {0, 0,}}, /* PI */
142 {/* SI */
143 {0, 0,}, /* TLR */
144 {0, 0,}, /* RTI */
145 {0, 0,}, /* SD */
146 {0, 0,}, /* PD */
147 {0, 0,}, /* SI */
148 {0, 0,}}, /* PI */
149 {/* PI */
150 {0, 0,}, /* TLR */
151 {0, 0,}, /* RTI */
152 {0, 0,}, /* SD */
153 {0, 0,}, /* PD */
154 {0, 0,}, /* SI */
155 {0, 0,}}, /* PI */
156 };
157
158 static uint8_t VSLLINK_BIT_MSK[8] =
159 {
160 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f
161 };
162
163 struct pending_scan_result {
164 int offset;
165 int length; /* Number of bits to read */
166 struct scan_command *command; /* Corresponding scan command */
167 uint8_t *buffer;
168 };
169
170 #define MAX_PENDING_SCAN_RESULTS 256
171
172 static int pending_scan_results_length;
173 static struct pending_scan_result pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS];
174
175 /* Queue command functions */
176 static void vsllink_end_state(tap_state_t state);
177 static void vsllink_state_move_dma(void);
178 static void vsllink_state_move_normal(void);
179 static void (*vsllink_state_move)(void);
180 static void vsllink_path_move_dma(int num_states, tap_state_t *path);
181 static void vsllink_path_move_normal(int num_states, tap_state_t *path);
182 static void (*vsllink_path_move)(int num_states, tap_state_t *path);
183 static void vsllink_runtest(int num_cycles);
184 static void vsllink_stableclocks_dma(int num_cycles, int tms);
185 static void vsllink_stableclocks_normal(int num_cycles, int tms);
186 static void (*vsllink_stableclocks)(int num_cycles, int tms);
187 static void vsllink_scan_dma(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command);
188 static void vsllink_scan_normal(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command);
189 static void (*vsllink_scan)(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command);
190 static void vsllink_reset(int trst, int srst);
191 static void vsllink_simple_command(uint8_t command);
192 static int vsllink_connect(void);
193 static int vsllink_disconnect(void);
194
195 /* VSLLink tap buffer functions */
196 static void vsllink_tap_append_step(int tms, int tdi);
197 static void vsllink_tap_init_dma(void);
198 static void vsllink_tap_init_normal(void);
199 static void (*vsllink_tap_init)(void);
200 static int vsllink_tap_execute_dma(void);
201 static int vsllink_tap_execute_normal(void);
202 static int (*vsllink_tap_execute)(void);
203 static void vsllink_tap_ensure_space_dma(int scans, int length);
204 static void vsllink_tap_ensure_space_normal(int scans, int length);
205 static void (*vsllink_tap_ensure_space)(int scans, int length);
206 static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, struct scan_command *command);
207 static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, struct scan_command *command, int offset);
208
209 /* VSLLink lowlevel functions */
210 struct vsllink {
211 struct usb_dev_handle* usb_handle;
212 };
213
214 static struct vsllink *vsllink_usb_open(void);
215 static void vsllink_usb_close(struct vsllink *vsllink);
216 static int vsllink_usb_message(struct vsllink *vsllink, int out_length, int in_length);
217 static int vsllink_usb_write(struct vsllink *vsllink, int out_length);
218 static int vsllink_usb_read(struct vsllink *vsllink);
219
220 #if defined _DEBUG_USB_COMMS_ || defined _DEBUG_JTAG_IO_
221 static void vsllink_debug_buffer(uint8_t *buffer, int length);
222 #endif
223
224 static int vsllink_tms_data_len = 0;
225 static uint8_t* vsllink_tms_cmd_pos;
226
227 static int tap_length = 0;
228 static int tap_buffer_size = 0;
229 static uint8_t *tms_buffer = NULL;
230 static uint8_t *tdi_buffer = NULL;
231 static uint8_t *tdo_buffer = NULL;
232 static int last_tms;
233
234 static struct vsllink* vsllink_handle = NULL;
235
236 static void reset_command_pointer(void)
237 {
238 if (vsllink_mode == VSLLINK_MODE_NORMAL)
239 {
240 vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGSEQCMD;
241 vsllink_usb_out_buffer_idx = 3;
242 }
243 else
244 {
245 tap_length = 0;
246 }
247 }
248
249 static int vsllink_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 DEBUG_JTAG_IO("--------------------------------- vsllink -------------------------------------");
257
258 reset_command_pointer();
259 while (cmd != NULL)
260 {
261 switch (cmd->type)
262 {
263 case JTAG_RUNTEST:
264 DEBUG_JTAG_IO("runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles, \
265 tap_state_name(cmd->cmd.runtest->end_state));
266
267 vsllink_end_state(cmd->cmd.runtest->end_state);
268 vsllink_runtest(cmd->cmd.runtest->num_cycles);
269 break;
270
271 case JTAG_STATEMOVE:
272 DEBUG_JTAG_IO("statemove end in %s", tap_state_name(cmd->cmd.statemove->end_state));
273
274 vsllink_end_state(cmd->cmd.statemove->end_state);
275 vsllink_state_move();
276 break;
277
278 case JTAG_PATHMOVE:
279 DEBUG_JTAG_IO("pathmove: %i states, end in %s", \
280 cmd->cmd.pathmove->num_states, \
281 tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]));
282
283 vsllink_path_move(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path);
284 break;
285
286 case JTAG_SCAN:
287 vsllink_end_state(cmd->cmd.scan->end_state);
288
289 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
290 if (cmd->cmd.scan->ir_scan)
291 {
292 DEBUG_JTAG_IO("JTAG Scan write IR(%d bits), end in %s:", scan_size, tap_state_name(cmd->cmd.scan->end_state));
293 }
294 else
295 {
296 DEBUG_JTAG_IO("JTAG Scan write DR(%d bits), end in %s:", scan_size, tap_state_name(cmd->cmd.scan->end_state));
297 }
298
299 #ifdef _DEBUG_JTAG_IO_
300 vsllink_debug_buffer(buffer, (scan_size + 7) >> 3);
301 #endif
302
303 type = jtag_scan_type(cmd->cmd.scan);
304
305 vsllink_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size, cmd->cmd.scan);
306 break;
307
308 case JTAG_RESET:
309 DEBUG_JTAG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
310
311 vsllink_tap_execute();
312
313 if (cmd->cmd.reset->trst == 1)
314 {
315 tap_set_state(TAP_RESET);
316 }
317 vsllink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
318 break;
319
320 case JTAG_SLEEP:
321 DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
322 vsllink_tap_execute();
323 jtag_sleep(cmd->cmd.sleep->us);
324 break;
325
326 case JTAG_STABLECLOCKS:
327 DEBUG_JTAG_IO("add %d clocks", cmd->cmd.stableclocks->num_cycles);
328 switch (tap_get_state())
329 {
330 case TAP_RESET:
331 // tms should be '1' to stay in TAP_RESET mode
332 scan_size = 1;
333 break;
334 case TAP_DRSHIFT:
335 case TAP_IDLE:
336 case TAP_DRPAUSE:
337 case TAP_IRSHIFT:
338 case TAP_IRPAUSE:
339 // in other mode, tms should be '0'
340 scan_size = 0;
341 break; /* above stable states are OK */
342 default:
343 LOG_ERROR("jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
344 tap_state_name(tap_get_state()));
345 exit(-1);
346 }
347 vsllink_stableclocks(cmd->cmd.stableclocks->num_cycles, scan_size);
348 break;
349
350 default:
351 LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd->type);
352 exit(-1);
353 }
354 cmd = cmd->next;
355 }
356
357 return vsllink_tap_execute();
358 }
359
360 static int vsllink_speed(int speed)
361 {
362 int result;
363
364 vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_SPEED;
365 vsllink_usb_out_buffer[1] = (speed >> 0) & 0xff;
366 vsllink_usb_out_buffer[2] = (speed >> 8) & 0xFF;
367
368 result = vsllink_usb_write(vsllink_handle, 3);
369
370 if (result == 3)
371 {
372 return ERROR_OK;
373 }
374 else
375 {
376 LOG_ERROR("VSLLink setting speed failed (%d)", result);
377 return ERROR_JTAG_DEVICE_ERROR;
378 }
379
380 return ERROR_OK;
381 }
382
383 static int vsllink_khz(int khz, int *jtag_speed)
384 {
385 *jtag_speed = khz;
386
387 return ERROR_OK;
388 }
389
390 static int vsllink_speed_div(int jtag_speed, int *khz)
391 {
392 *khz = jtag_speed;
393
394 return ERROR_OK;
395 }
396
397 static int vsllink_init(void)
398 {
399 int check_cnt, to_tmp;
400 int result;
401 char version_str[100];
402
403 vsllink_usb_in_buffer = malloc(VSLLINK_BufferSize);
404 vsllink_usb_out_buffer = malloc(VSLLINK_BufferSize);
405 if ((vsllink_usb_in_buffer == NULL) || (vsllink_usb_out_buffer == NULL))
406 {
407 LOG_ERROR("Not enough memory");
408 exit(-1);
409 }
410
411 vsllink_handle = vsllink_usb_open();
412
413 if (vsllink_handle == 0)
414 {
415 LOG_ERROR("Can't find USB JTAG Interface! Please check connection and permissions.");
416 return ERROR_JTAG_INIT_FAILED;
417 }
418 LOG_DEBUG("vsllink found on %04X:%04X", vsllink_usb_vid, vsllink_usb_pid);
419
420 to_tmp = VSLLINK_USB_TIMEOUT;
421 VSLLINK_USB_TIMEOUT = 100;
422 check_cnt = 0;
423 while (check_cnt < 5)
424 {
425 vsllink_simple_command(0x00);
426 result = vsllink_usb_read(vsllink_handle);
427
428 if (result > 2)
429 {
430 vsllink_usb_in_buffer[result] = 0;
431 VSLLINK_BufferSize = vsllink_usb_in_buffer[0] + (vsllink_usb_in_buffer[1] << 8);
432 strncpy(version_str, (char *)vsllink_usb_in_buffer + 2, sizeof(version_str));
433 LOG_INFO("%s", version_str);
434
435 // free the pre-alloc memroy
436 free(vsllink_usb_in_buffer);
437 free(vsllink_usb_out_buffer);
438 vsllink_usb_in_buffer = NULL;
439 vsllink_usb_out_buffer = NULL;
440
441 // alloc new memory
442 vsllink_usb_in_buffer = malloc(VSLLINK_BufferSize);
443 vsllink_usb_out_buffer = malloc(VSLLINK_BufferSize);
444 if ((vsllink_usb_in_buffer == NULL) || (vsllink_usb_out_buffer == NULL))
445 {
446 LOG_ERROR("Not enough memory");
447 exit(-1);
448 }
449 else
450 {
451 LOG_INFO("buffer size for USB is %d bytes", VSLLINK_BufferSize);
452 }
453 // alloc memory for dma mode
454 if (vsllink_mode == VSLLINK_MODE_DMA)
455 {
456 tap_buffer_size = (VSLLINK_BufferSize - 3) / 2;
457 tms_buffer = (uint8_t*)malloc(tap_buffer_size);
458 tdi_buffer = (uint8_t*)malloc(tap_buffer_size);
459 tdo_buffer = (uint8_t*)malloc(tap_buffer_size);
460 if ((tms_buffer == NULL) || (tdi_buffer == NULL) || (tdo_buffer == NULL))
461 {
462 LOG_ERROR("Not enough memory");
463 exit(-1);
464 }
465 }
466 break;
467 }
468 vsllink_simple_command(VSLLINK_CMD_DISCONN);
469 check_cnt++;
470 }
471 if (check_cnt == 3)
472 {
473 // It's dangerout to proced
474 LOG_ERROR("VSLLink initial failed");
475 exit(-1);
476 }
477 VSLLINK_USB_TIMEOUT = to_tmp;
478
479 // connect to vsllink
480 vsllink_connect();
481 // initialize function pointers
482 if (vsllink_mode == VSLLINK_MODE_NORMAL)
483 {
484 // normal mode
485 vsllink_state_move = vsllink_state_move_normal;
486 vsllink_path_move = vsllink_path_move_normal;
487 vsllink_stableclocks = vsllink_stableclocks_normal;
488 vsllink_scan = vsllink_scan_normal;
489
490 vsllink_tap_init = vsllink_tap_init_normal;
491 vsllink_tap_execute = vsllink_tap_execute_normal;
492 vsllink_tap_ensure_space = vsllink_tap_ensure_space_normal;
493
494 LOG_INFO("vsllink run in NORMAL mode");
495 }
496 else
497 {
498 // dma mode
499 vsllink_state_move = vsllink_state_move_dma;
500 vsllink_path_move = vsllink_path_move_dma;
501 vsllink_stableclocks = vsllink_stableclocks_dma;
502 vsllink_scan = vsllink_scan_dma;
503
504 vsllink_tap_init = vsllink_tap_init_dma;
505 vsllink_tap_execute = vsllink_tap_execute_dma;
506 vsllink_tap_ensure_space = vsllink_tap_ensure_space_dma;
507
508 LOG_INFO("vsllink run in DMA mode");
509 }
510
511 // Set SRST and TRST to output, Set USR1 and USR2 to input
512 vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_PORTDIR;
513 vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST | JTAG_PINMSK_USR1 | JTAG_PINMSK_USR2;
514 vsllink_usb_out_buffer[2] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST;
515 if (vsllink_usb_write(vsllink_handle, 3) != 3)
516 {
517 LOG_ERROR("VSLLink USB send data error");
518 exit(-1);
519 }
520
521 vsllink_reset(0, 0);
522
523 LOG_INFO("VSLLink JTAG Interface ready");
524
525 vsllink_tap_init();
526
527 return ERROR_OK;
528 }
529
530 static int vsllink_quit(void)
531 {
532 if ((vsllink_usb_in_buffer != NULL) && (vsllink_usb_out_buffer != NULL))
533 {
534 // Set all pins to input
535 vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_PORTDIR;
536 vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST | JTAG_PINMSK_USR1 | JTAG_PINMSK_USR2;
537 vsllink_usb_out_buffer[2] = 0;
538 if (vsllink_usb_write(vsllink_handle, 3) != 3)
539 {
540 LOG_ERROR("VSLLink USB send data error");
541 exit(-1);
542 }
543
544 // disconnect
545 vsllink_disconnect();
546 vsllink_usb_close(vsllink_handle);
547 vsllink_handle = NULL;
548 }
549
550 if (vsllink_usb_in_buffer != NULL)
551 {
552 free(vsllink_usb_in_buffer);
553 vsllink_usb_in_buffer = NULL;
554 }
555 if (vsllink_usb_out_buffer != NULL)
556 {
557 free(vsllink_usb_out_buffer);
558 vsllink_usb_out_buffer = NULL;
559 }
560
561 return ERROR_OK;
562 }
563
564 /***************************************************************************/
565 /* Queue command implementations */
566 static int vsllink_disconnect(void)
567 {
568 vsllink_simple_command(VSLLINK_CMD_DISCONN);
569 return ERROR_OK;
570 }
571
572 static int vsllink_connect(void)
573 {
574 char vsllink_str[100];
575
576 vsllink_usb_out_buffer[0] = VSLLINK_CMD_CONN;
577 vsllink_usb_out_buffer[1] = vsllink_mode;
578 vsllink_usb_message(vsllink_handle, 2, 0);
579 if (vsllink_usb_read(vsllink_handle) > 2)
580 {
581 strncpy(vsllink_str, (char *)vsllink_usb_in_buffer + 2, sizeof(vsllink_str));
582 LOG_INFO("%s", vsllink_str);
583 }
584
585 return ERROR_OK;
586 }
587
588 // when vsllink_tms_data_len > 0, vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] is the byte that need to be appended.
589 // length of VSLLINK_CMDJTAGSEQ_TMSBYTE has been set, no need to set it here.
590 static void vsllink_append_tms(void)
591 {
592 uint8_t tms_scan = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state());
593 uint16_t tms2;
594 struct insert_insignificant_operation *insert = \
595 &VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_ndx(tap_get_state())][tap_move_ndx(tap_get_end_state())];
596
597 if (((tap_get_state() != TAP_RESET) && (tap_get_state() != TAP_IDLE) && (tap_get_state() != TAP_DRPAUSE) && (tap_get_state() != TAP_IRPAUSE)) || \
598 (vsllink_tms_data_len <= 0) || (vsllink_tms_data_len >= 8) || \
599 (vsllink_tms_cmd_pos == NULL))
600 {
601 LOG_ERROR("There MUST be some bugs in the driver");
602 exit(-1);
603 }
604
605 tms2 = (tms_scan & VSLLINK_BIT_MSK[insert->insert_position]) << \
606 vsllink_tms_data_len;
607 if (insert->insert_value == 1)
608 {
609 tms2 |= VSLLINK_BIT_MSK[8 - vsllink_tms_data_len] << \
610 (vsllink_tms_data_len + insert->insert_position);
611 }
612 tms2 |= (tms_scan >> insert->insert_position) << \
613 (8 + insert->insert_position);
614
615 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (tms2 >> 0) & 0xff;
616 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tms2 >> 8) & 0xff;
617
618 vsllink_tms_data_len = 0;
619 vsllink_tms_cmd_pos = NULL;
620 }
621
622 static void vsllink_end_state(tap_state_t state)
623 {
624 if (tap_is_state_stable(state))
625 {
626 tap_set_end_state(state);
627 }
628 else
629 {
630 LOG_ERROR("BUG: %i is not a valid end state", state);
631 exit(-1);
632 }
633 }
634
635 /* Goes to the end state. */
636 static void vsllink_state_move_normal(void)
637 {
638 if (vsllink_tms_data_len > 0)
639 {
640 vsllink_append_tms();
641 }
642 else
643 {
644 vsllink_tap_ensure_space(0, 2);
645
646 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE;
647 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state());
648 }
649
650 tap_set_state(tap_get_end_state());
651 }
652 static void vsllink_state_move_dma(void)
653 {
654 int i, insert_length = (tap_length % 8) ? (8 - (tap_length % 8)) : 0;
655 struct insert_insignificant_operation *insert = \
656 &VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_ndx(tap_get_state())][tap_move_ndx(tap_get_end_state())];
657 uint8_t tms_scan = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state());
658
659 if (tap_get_state() == TAP_RESET)
660 {
661 vsllink_tap_ensure_space(0, 8);
662
663 for (i = 0; i < 8; i++)
664 {
665 vsllink_tap_append_step(1, 0);
666 }
667 }
668
669 if (insert_length > 0)
670 {
671 vsllink_tap_ensure_space(0, 16);
672
673 for (i = 0; i < insert->insert_position; i++)
674 {
675 vsllink_tap_append_step((tms_scan >> i) & 1, 0);
676 }
677 for (i = 0; i < insert_length; i++)
678 {
679 vsllink_tap_append_step(insert->insert_value, 0);
680 }
681 for (i = insert->insert_position; i < 8; i++)
682 {
683 vsllink_tap_append_step((tms_scan >> i) & 1, 0);
684 }
685 }
686 else
687 {
688 vsllink_tap_ensure_space(0, 8);
689
690 for (i = 0; i < 8; i++)
691 {
692 vsllink_tap_append_step((tms_scan >> i) & 1, 0);
693 }
694 }
695
696 tap_set_state(tap_get_end_state());
697 }
698
699 // write tms from current vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx]
700 static void vsllink_add_path(int start, int num, tap_state_t *path)
701 {
702 int i;
703
704 for (i = start; i < (start + num); i++)
705 {
706 if ((i & 7) == 0)
707 {
708 if (i > 0)
709 {
710 vsllink_usb_out_buffer_idx++;
711 }
712 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = 0;
713 }
714
715 if (path[i - start] == tap_state_transition(tap_get_state(), true))
716 {
717 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] |= 1 << (i & 7);
718 }
719 else if (path[i - start] == tap_state_transition(tap_get_state(), false))
720 {
721 // nothing to do
722 }
723 else
724 {
725 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path[i]));
726 exit(-1);
727 }
728 tap_set_state(path[i - start]);
729 }
730 if ((i > 0) && ((i & 7) == 0))
731 {
732 vsllink_usb_out_buffer_idx++;
733 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = 0;
734 }
735
736 tap_set_end_state(tap_get_state());
737 }
738
739 static void vsllink_path_move_normal(int num_states, tap_state_t *path)
740 {
741 int i, tms_len, tms_cmd_pos, path_idx = 0;
742
743 if (vsllink_tms_data_len > 0)
744 {
745 // there are vsllink_tms_data_len more tms bits to be shifted
746 // so there are vsllink_tms_data_len + num_states tms bits in all
747 tms_len = vsllink_tms_data_len + num_states;
748 if (tms_len <= 16)
749 {
750 // merge into last tms shift
751 if (tms_len < 8)
752 {
753 // just append tms data to the last tms byte
754 vsllink_add_path(vsllink_tms_data_len, num_states, path);
755 }
756 else if (tms_len == 8)
757 {
758 // end last tms shift command
759 (*vsllink_tms_cmd_pos)--;
760 vsllink_add_path(vsllink_tms_data_len, num_states, path);
761 }
762 else if (tms_len < 16)
763 {
764 if ((*vsllink_tms_cmd_pos & VSLLINK_CMDJTAGSEQ_LENMSK) < VSLLINK_CMDJTAGSEQ_LENMSK)
765 {
766 // every tms shift command can contain VSLLINK_CMDJTAGSEQ_LENMSK + 1 bytes in most
767 // there is enought tms length in the current tms shift command
768 (*vsllink_tms_cmd_pos)++;
769 vsllink_add_path(vsllink_tms_data_len, num_states, path);
770 }
771 else
772 {
773 // every tms shift command can contain VSLLINK_CMDJTAGSEQ_LENMSK + 1 bytes in most
774 // not enough tms length in the current tms shift command
775 // so a new command should be added
776 // first decrease byte length of last tms shift command
777 (*vsllink_tms_cmd_pos)--;
778 // append tms data to the last tms byte
779 vsllink_add_path(vsllink_tms_data_len, 8 - vsllink_tms_data_len, path);
780 path += 8 - vsllink_tms_data_len;
781 // add new command(3 bytes)
782 vsllink_tap_ensure_space(0, 3);
783 vsllink_tms_cmd_pos = &vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx];
784 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | 1;
785 vsllink_add_path(0, num_states - (8 - vsllink_tms_data_len), path);
786 }
787 }
788 else if (tms_len == 16)
789 {
790 // end last tms shift command
791 vsllink_add_path(vsllink_tms_data_len, num_states, path);
792 }
793
794 vsllink_tms_data_len = (vsllink_tms_data_len + num_states) & 7;
795 if (vsllink_tms_data_len == 0)
796 {
797 vsllink_tms_cmd_pos = NULL;
798 }
799 num_states = 0;
800 }
801 else
802 {
803 vsllink_add_path(vsllink_tms_data_len, 16 - vsllink_tms_data_len, path);
804
805 path += 16 - vsllink_tms_data_len;
806 num_states -= 16 - vsllink_tms_data_len;
807 vsllink_tms_data_len = 0;
808 vsllink_tms_cmd_pos = NULL;
809 }
810 }
811
812 if (num_states > 0)
813 {
814 // Normal operation, don't need to append tms data
815 vsllink_tms_data_len = num_states & 7;
816
817 while (num_states > 0)
818 {
819 if (num_states > ((VSLLINK_CMDJTAGSEQ_LENMSK + 1) * 8))
820 {
821 i = (VSLLINK_CMDJTAGSEQ_LENMSK + 1) * 8;
822 }
823 else
824 {
825 i = num_states;
826 }
827 tms_len = (i + 7) >> 3;
828 vsllink_tap_ensure_space(0, tms_len + 2);
829 tms_cmd_pos = vsllink_usb_out_buffer_idx;
830 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | (tms_len - 1);
831
832 vsllink_add_path(0, i, path + path_idx);
833
834 path_idx += i;
835 num_states -= i;
836 }
837
838 if (vsllink_tms_data_len > 0)
839 {
840 if (tms_len < (VSLLINK_CMDJTAGSEQ_LENMSK + 1))
841 {
842 vsllink_tms_cmd_pos = &vsllink_usb_out_buffer[tms_cmd_pos];
843 (*vsllink_tms_cmd_pos)++;
844 }
845 else
846 {
847 vsllink_usb_out_buffer[tms_cmd_pos]--;
848
849 tms_len = vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx];
850 vsllink_tap_ensure_space(0, 3);
851 vsllink_tms_cmd_pos = &vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx];
852 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | 1;
853 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = tms_len;
854 }
855 }
856 }
857 }
858 static void vsllink_path_move_dma(int num_states, tap_state_t *path)
859 {
860 int i, j = 0;
861
862 if (tap_length & 7)
863 {
864 if ((8 - (tap_length & 7)) < num_states)
865 {
866 j = 8 - (tap_length & 7);
867 }
868 else
869 {
870 j = num_states;
871 }
872 for (i = 0; i < j; i++)
873 {
874 if (path[i] == tap_state_transition(tap_get_state(), false))
875 {
876 vsllink_tap_append_step(0, 0);
877 }
878 else if (path[i] == tap_state_transition(tap_get_state(), true))
879 {
880 vsllink_tap_append_step(1, 0);
881 }
882 else
883 {
884 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path[i]));
885 exit(-1);
886 }
887 tap_set_state(path[i]);
888 }
889 num_states -= j;
890 }
891
892 if (num_states > 0)
893 {
894 vsllink_tap_ensure_space(0, num_states);
895
896 for (i = 0; i < num_states; i++)
897 {
898 if (path[j + i] == tap_state_transition(tap_get_state(), false))
899 {
900 vsllink_tap_append_step(0, 0);
901 }
902 else if (path[j + i] == tap_state_transition(tap_get_state(), true))
903 {
904 vsllink_tap_append_step(1, 0);
905 }
906 else
907 {
908 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path[i]));
909 exit(-1);
910 }
911 tap_set_state(path[j + i]);
912 }
913 }
914
915 tap_set_end_state(tap_get_state());
916 }
917
918 static void vsllink_stableclocks_normal(int num_cycles, int tms)
919 {
920 int tms_len;
921 uint16_t tms_append_byte;
922
923 if (vsllink_tms_data_len > 0)
924 {
925 // there are vsllink_tms_data_len more tms bits to be shifted
926 // so there are vsllink_tms_data_len + num_cycles tms bits in all
927 tms_len = vsllink_tms_data_len + num_cycles;
928 if (tms > 0)
929 {
930 // append '1' for tms
931 tms_append_byte = (uint16_t)((((1 << num_cycles) - 1) << vsllink_tms_data_len) & 0xFFFF);
932 }
933 else
934 {
935 // append '0' for tms
936 tms_append_byte = 0;
937 }
938 if (tms_len <= 16)
939 {
940 // merge into last tms shift
941 if (tms_len < 8)
942 {
943 // just add to vsllink_tms_data_len
944 // same result if tun through
945 //vsllink_tms_data_len += num_cycles;
946 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] |= (uint8_t)(tms_append_byte & 0xFF);
947 }
948 else if (tms_len == 8)
949 {
950 // end last tms shift command
951 // just reduce it, and append last tms byte
952 (*vsllink_tms_cmd_pos)--;
953 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (uint8_t)(tms_append_byte & 0xFF);
954 }
955 else if (tms_len < 16)
956 {
957 if ((*vsllink_tms_cmd_pos & VSLLINK_CMDJTAGSEQ_LENMSK) < VSLLINK_CMDJTAGSEQ_LENMSK)
958 {
959 // every tms shift command can contain VSLLINK_CMDJTAGSEQ_LENMSK + 1 bytes in most
960 // there is enought tms length in the current tms shift command
961 // increase the tms byte length by 1 and set the last byte to 0
962 (*vsllink_tms_cmd_pos)++;
963 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (uint8_t)(tms_append_byte & 0xFF);
964 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = (uint8_t)(tms_append_byte >> 8);
965 }
966 else
967 {
968 // every tms shift command can contain VSLLINK_CMDJTAGSEQ_LENMSK + 1 bytes in most
969 // not enough tms length in the current tms shift command
970 // so a new command should be added
971 // first decrease byte length of last tms shift command
972 (*vsllink_tms_cmd_pos)--;
973 // append last tms byte and move the command pointer to the next empty position
974 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (uint8_t)(tms_append_byte & 0xFF);
975 // add new command(3 bytes)
976 vsllink_tap_ensure_space(0, 3);
977 vsllink_tms_cmd_pos = &vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx];
978 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | 1;
979 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = (uint8_t)(tms_append_byte >> 8);
980 }
981 }
982 else if (tms_len == 16)
983 {
984 // end last tms shift command
985 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (uint8_t)(tms_append_byte & 0xFF);
986 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (uint8_t)(tms_append_byte >> 8);
987 }
988
989 vsllink_tms_data_len = tms_len & 7;
990 if (vsllink_tms_data_len == 0)
991 {
992 vsllink_tms_cmd_pos = NULL;
993 }
994 num_cycles = 0;
995 }
996 else
997 {
998 // more shifts will be needed
999 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (uint8_t)(tms_append_byte & 0xFF);
1000 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (uint8_t)(tms_append_byte >> 8);
1001
1002 num_cycles -= 16 - vsllink_tms_data_len;
1003 vsllink_tms_data_len = 0;
1004 vsllink_tms_cmd_pos = NULL;
1005 }
1006 }
1007 // from here vsllink_tms_data_len == 0 or num_cycles == 0
1008
1009 if (vsllink_tms_data_len > 0)
1010 {
1011 // num_cycles == 0
1012 // no need to shift
1013 if (num_cycles > 0)
1014 {
1015 LOG_ERROR("There MUST be some bugs in the driver");
1016 exit(-1);
1017 }
1018 }
1019 else
1020 {
1021 // get number of bytes left to be sent
1022 tms_len = num_cycles >> 3;
1023 if (tms_len > 0)
1024 {
1025 vsllink_tap_ensure_space(1, 5);
1026 // if tms_len > 0, vsllink_tms_data_len == 0
1027 // so just add new command
1028 // LSB of the command byte is the tms value when do the shifting
1029 if (tms > 0)
1030 {
1031 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSCLOCK | 1;
1032 }
1033 else
1034 {
1035 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSCLOCK;
1036 }
1037 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tms_len >> 0) & 0xff;
1038 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tms_len >> 8) & 0xff;
1039 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tms_len >> 16) & 0xff;
1040 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tms_len >> 24) & 0xff;
1041
1042 vsllink_usb_in_want_length += 1;
1043 pending_scan_results_buffer[pending_scan_results_length].buffer = NULL;
1044 pending_scan_results_length++;
1045
1046 if (tms_len > 0xFFFF)
1047 {
1048 vsllink_tap_execute();
1049 }
1050 }
1051
1052 // post-process
1053 vsllink_tms_data_len = num_cycles & 7;
1054 if (vsllink_tms_data_len > 0)
1055 {
1056 vsllink_tap_ensure_space(0, 3);
1057 vsllink_tms_cmd_pos = &vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx];
1058 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | 1;
1059 if (tms > 0)
1060 {
1061 // append '1' for tms
1062 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = (1 << vsllink_tms_data_len) - 1;
1063 }
1064 else
1065 {
1066 // append '0' for tms
1067 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = 0x00;
1068 }
1069 }
1070 }
1071 }
1072 static void vsllink_stableclocks_dma(int num_cycles, int tms)
1073 {
1074 int i, cur_cycles;
1075
1076 if (tap_length & 7)
1077 {
1078 if ((8 - (tap_length & 7)) < num_cycles)
1079 {
1080 cur_cycles = 8 - (tap_length & 7);
1081 }
1082 else
1083 {
1084 cur_cycles = num_cycles;
1085 }
1086 for (i = 0; i < cur_cycles; i++)
1087 {
1088 vsllink_tap_append_step(tms, 0);
1089 }
1090 num_cycles -= cur_cycles;
1091 }
1092
1093 while (num_cycles > 0)
1094 {
1095 if (num_cycles > 8 * tap_buffer_size)
1096 {
1097 cur_cycles = 8 * tap_buffer_size;
1098 }
1099 else
1100 {
1101 cur_cycles = num_cycles;
1102 }
1103
1104 vsllink_tap_ensure_space(0, cur_cycles);
1105
1106 for (i = 0; i < cur_cycles; i++)
1107 {
1108 vsllink_tap_append_step(tms, 0);
1109 }
1110
1111 num_cycles -= cur_cycles;
1112 }
1113 }
1114
1115 static void vsllink_runtest(int num_cycles)
1116 {
1117 tap_state_t saved_end_state = tap_get_end_state();
1118
1119 if (tap_get_state() != TAP_IDLE)
1120 {
1121 // enter into IDLE state
1122 vsllink_end_state(TAP_IDLE);
1123 vsllink_state_move();
1124 }
1125
1126 vsllink_stableclocks(num_cycles, 0);
1127
1128 // post-process
1129 // set end_state
1130 vsllink_end_state(saved_end_state);
1131 tap_set_state(TAP_IDLE);
1132 if (tap_get_end_state() != TAP_IDLE)
1133 {
1134 vsllink_state_move();
1135 }
1136 }
1137
1138 static void vsllink_scan_normal(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command)
1139 {
1140 tap_state_t saved_end_state;
1141 uint8_t bits_left, tms_tmp, tdi_len;
1142 int i;
1143
1144 if (0 == scan_size)
1145 {
1146 return;
1147 }
1148
1149 tdi_len = ((scan_size + 7) >> 3);
1150 if ((tdi_len + 7) > VSLLINK_BufferSize)
1151 {
1152 LOG_ERROR("Your implementation of VSLLink has not enough buffer");
1153 exit(-1);
1154 }
1155
1156 saved_end_state = tap_get_end_state();
1157
1158 /* Move to appropriate scan state */
1159 vsllink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
1160
1161 if (vsllink_tms_data_len > 0)
1162 {
1163 if (tap_get_state() == tap_get_end_state())
1164 {
1165 // already in IRSHIFT or DRSHIFT state
1166 // merge tms data in the last tms shift command into next scan command
1167 if (*vsllink_tms_cmd_pos < 1)
1168 {
1169 LOG_ERROR("There MUST be some bugs in the driver");
1170 exit(-1);
1171 }
1172 else if (*vsllink_tms_cmd_pos < 2)
1173 {
1174 tms_tmp = vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx];
1175 vsllink_usb_out_buffer_idx--;
1176 }
1177 else
1178 {
1179 tms_tmp = vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx];
1180 *vsllink_tms_cmd_pos -= 2;
1181 }
1182
1183 vsllink_tap_ensure_space(1, tdi_len + 7);
1184 // VSLLINK_CMDJTAGSEQ_SCAN ored by 1 means that tms_before is valid
1185 // which is merged from the last tms shift command
1186 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_SCAN | 1;
1187 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1) >> 0) & 0xff;
1188 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1) >> 8) & 0xff;
1189 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = tms_tmp;
1190 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = buffer[0] << (8 - vsllink_tms_data_len);
1191
1192 for (i = 0; i < tdi_len; i++)
1193 {
1194 buffer[i] >>= 8 - vsllink_tms_data_len;
1195 if (i != tdi_len)
1196 {
1197 buffer[i] += buffer[i + 1] << vsllink_tms_data_len;
1198 }
1199 }
1200
1201 vsllink_tap_append_scan_normal(scan_size - vsllink_tms_data_len, buffer, command, vsllink_tms_data_len);
1202 scan_size -= 8 - vsllink_tms_data_len;
1203 vsllink_tms_data_len = 0;
1204 }
1205 else
1206 {
1207 vsllink_state_move();
1208 vsllink_tap_ensure_space(1, tdi_len + 5);
1209
1210 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_SCAN;
1211 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tdi_len >> 0) & 0xff;
1212 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tdi_len >> 8) & 0xff;
1213
1214 vsllink_tap_append_scan_normal(scan_size, buffer, command, 0);
1215 }
1216 }
1217 else
1218 {
1219 vsllink_tap_ensure_space(1, tdi_len + 7);
1220
1221 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_SCAN | 1;
1222 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1) >> 0) & 0xff;
1223 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1)>> 8) & 0xff;
1224 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state());
1225 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0;
1226
1227 vsllink_tap_append_scan_normal(scan_size, buffer, command, 8);
1228 }
1229 vsllink_end_state(saved_end_state);
1230
1231 bits_left = scan_size & 0x07;
1232 tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
1233
1234 if (bits_left > 0)
1235 {
1236 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 1 << (bits_left - 1);
1237 }
1238 else
1239 {
1240 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 1 << 7;
1241 }
1242
1243 if (tap_get_state() != tap_get_end_state())
1244 {
1245 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state());
1246 }
1247 else
1248 {
1249 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0;
1250 }
1251
1252 tap_set_state(tap_get_end_state());
1253 }
1254 static void vsllink_scan_dma(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command)
1255 {
1256 tap_state_t saved_end_state;
1257
1258 saved_end_state = tap_get_end_state();
1259
1260 /* Move to appropriate scan state */
1261 vsllink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
1262
1263 vsllink_state_move();
1264 vsllink_end_state(saved_end_state);
1265
1266 /* Scan */
1267 vsllink_tap_append_scan_dma(scan_size, buffer, command);
1268
1269 tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
1270 while (tap_length % 8 != 0)
1271 {
1272 // more 0s in Pause
1273 vsllink_tap_append_step(0, 0);
1274 }
1275
1276 if (tap_get_state() != tap_get_end_state())
1277 {
1278 vsllink_state_move();
1279 }
1280 }
1281
1282 static void vsllink_reset(int trst, int srst)
1283 {
1284 int result;
1285
1286 LOG_DEBUG("trst: %i, srst: %i", trst, srst);
1287
1288 /* Signals are active low */
1289 vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_PORT;
1290 vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST;
1291 vsllink_usb_out_buffer[2] = 0;
1292 if (srst == 0)
1293 {
1294 vsllink_usb_out_buffer[2] |= JTAG_PINMSK_SRST;
1295 }
1296 if (trst == 0)
1297 {
1298 vsllink_usb_out_buffer[2] |= JTAG_PINMSK_TRST;
1299 }
1300
1301 result = vsllink_usb_write(vsllink_handle, 3);
1302 if (result != 3)
1303 {
1304 LOG_ERROR("VSLLink command VSLLINK_CMD_SET_PORT failed (%d)", result);
1305 }
1306 }
1307
1308 static void vsllink_simple_command(uint8_t command)
1309 {
1310 int result;
1311
1312 DEBUG_JTAG_IO("0x%02x", command);
1313
1314 vsllink_usb_out_buffer[0] = command;
1315 result = vsllink_usb_write(vsllink_handle, 1);
1316
1317 if (result != 1)
1318 {
1319 LOG_ERROR("VSLLink command 0x%02x failed (%d)", command, result);
1320 }
1321 }
1322
1323 COMMAND_HANDLER(vsllink_handle_mode_command)
1324 {
1325 if (CMD_ARGC != 1) {
1326 LOG_ERROR("parameter error, should be one parameter for VID");
1327 return ERROR_FAIL;
1328 }
1329
1330 if (!strcmp(CMD_ARGV[0], "normal"))
1331 {
1332 vsllink_mode = VSLLINK_MODE_NORMAL;
1333 }
1334 else if (!strcmp(CMD_ARGV[0], "dma"))
1335 {
1336 vsllink_mode = VSLLINK_MODE_DMA;
1337 }
1338 else
1339 {
1340 LOG_ERROR("invalid vsllink_mode: %s", CMD_ARGV[0]);
1341 return ERROR_FAIL;
1342 }
1343
1344 return ERROR_OK;
1345 }
1346
1347 COMMAND_HANDLER(vsllink_handle_usb_vid_command)
1348 {
1349 if (CMD_ARGC != 1)
1350 {
1351 LOG_ERROR("parameter error, should be one parameter for VID");
1352 return ERROR_OK;
1353 }
1354
1355 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], vsllink_usb_vid);
1356 return ERROR_OK;
1357 }
1358
1359 COMMAND_HANDLER(vsllink_handle_usb_pid_command)
1360 {
1361 if (CMD_ARGC != 1)
1362 {
1363 LOG_ERROR("parameter error, should be one parameter for PID");
1364 return ERROR_OK;
1365 }
1366 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], vsllink_usb_pid);
1367 return ERROR_OK;
1368 }
1369
1370 COMMAND_HANDLER(vsllink_handle_usb_bulkin_command)
1371 {
1372 if (CMD_ARGC != 1)
1373 {
1374 LOG_ERROR("parameter error, should be one parameter for BULKIN endpoint");
1375 return ERROR_OK;
1376 }
1377
1378 COMMAND_PARSE_NUMBER(u8, CMD_ARGV[0], vsllink_usb_bulkin);
1379
1380 vsllink_usb_bulkin |= 0x80;
1381
1382 return ERROR_OK;
1383 }
1384
1385 COMMAND_HANDLER(vsllink_handle_usb_bulkout_command)
1386 {
1387 if (CMD_ARGC != 1)
1388 {
1389 LOG_ERROR("parameter error, should be one parameter for BULKOUT endpoint");
1390 return ERROR_OK;
1391 }
1392
1393 COMMAND_PARSE_NUMBER(u8, CMD_ARGV[0], vsllink_usb_bulkout);
1394
1395 vsllink_usb_bulkout &= ~0x80;
1396
1397 return ERROR_OK;
1398 }
1399
1400 COMMAND_HANDLER(vsllink_handle_usb_interface_command)
1401 {
1402 if (CMD_ARGC != 1)
1403 {
1404 LOG_ERROR("parameter error, should be one parameter for interface number");
1405 return ERROR_OK;
1406 }
1407
1408 COMMAND_PARSE_NUMBER(u8, CMD_ARGV[0], vsllink_usb_interface);
1409 return ERROR_OK;
1410 }
1411
1412 /***************************************************************************/
1413 /* VSLLink tap functions */
1414
1415 static void vsllink_tap_init_normal(void)
1416 {
1417 vsllink_usb_out_buffer_idx = 0;
1418 vsllink_usb_in_want_length = 0;
1419 pending_scan_results_length = 0;
1420 }
1421 static void vsllink_tap_init_dma(void)
1422 {
1423 tap_length = 0;
1424 pending_scan_results_length = 0;
1425 }
1426
1427 static void vsllink_tap_ensure_space_normal(int scans, int length)
1428 {
1429 int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length;
1430 int available_bytes = VSLLINK_BufferSize - vsllink_usb_out_buffer_idx;
1431
1432 if (scans > available_scans || length > available_bytes)
1433 {
1434 vsllink_tap_execute();
1435 }
1436 }
1437 static void vsllink_tap_ensure_space_dma(int scans, int length)
1438 {
1439 int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length;
1440 int available_bytes = tap_buffer_size * 8 - tap_length;
1441
1442 if (scans > available_scans || length > available_bytes)
1443 {
1444 vsllink_tap_execute();
1445 }
1446 }
1447
1448 static void vsllink_tap_append_step(int tms, int tdi)
1449 {
1450 last_tms = tms;
1451 int index = tap_length / 8;
1452
1453 if (index < tap_buffer_size)
1454 {
1455 int bit_index = tap_length % 8;
1456 uint8_t bit = 1 << bit_index;
1457
1458 if (tms)
1459 {
1460 tms_buffer[index] |= bit;
1461 }
1462 else
1463 {
1464 tms_buffer[index] &= ~bit;
1465 }
1466
1467 if (tdi)
1468 {
1469 tdi_buffer[index] |= bit;
1470 }
1471 else
1472 {
1473 tdi_buffer[index] &= ~bit;
1474 }
1475
1476 tap_length++;
1477 }
1478 else
1479 {
1480 LOG_ERROR("buffer overflow, tap_length=%d", tap_length);
1481 }
1482 }
1483
1484 static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, struct scan_command *command, int offset)
1485 {
1486 struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
1487 int i;
1488
1489 if (offset > 0)
1490 {
1491 vsllink_usb_in_want_length += ((length + 7) >> 3) + 1;
1492 }
1493 else
1494 {
1495 vsllink_usb_in_want_length += (length + 7) >> 3;
1496 }
1497 pending_scan_result->length = length;
1498 pending_scan_result->offset = offset;
1499 pending_scan_result->command = command;
1500 pending_scan_result->buffer = buffer;
1501
1502 for (i = 0; i < ((length + 7) >> 3); i++)
1503 {
1504 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = buffer[i];
1505 }
1506
1507 pending_scan_results_length++;
1508 }
1509 static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, struct scan_command *command)
1510 {
1511 struct pending_scan_result *pending_scan_result;
1512 int len_tmp, len_all, i;
1513
1514 len_all = 0;
1515 while (len_all < length)
1516 {
1517 if ((length - len_all) > tap_buffer_size * 8)
1518 {
1519 len_tmp = tap_buffer_size * 8;
1520 }
1521 else
1522 {
1523 len_tmp = length - len_all;
1524 }
1525
1526 vsllink_tap_ensure_space(1, (len_tmp + 7) & ~7);
1527
1528 pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
1529 pending_scan_result->offset = tap_length;
1530 pending_scan_result->length = len_tmp;
1531 pending_scan_result->command = command;
1532 pending_scan_result->buffer = buffer + len_all / 8;
1533
1534 for (i = 0; i < len_tmp; i++)
1535 {
1536 vsllink_tap_append_step(((len_all + i) < length-1 ? 0 : 1), (buffer[(len_all + i)/8] >> ((len_all + i)%8)) & 1);
1537 }
1538
1539 pending_scan_results_length++;
1540 len_all += len_tmp;
1541 }
1542 }
1543
1544 /* Pad and send a tap sequence to the device, and receive the answer.
1545 * For the purpose of padding we assume that we are in reset or idle or pause state. */
1546 static int vsllink_tap_execute_normal(void)
1547 {
1548 int i;
1549 int result;
1550 int first = 0;
1551
1552 if (vsllink_tms_data_len > 0)
1553 {
1554 if ((tap_get_state() != TAP_RESET) && (tap_get_state() != TAP_IDLE) && (tap_get_state() != TAP_IRPAUSE) && (tap_get_state() != TAP_DRPAUSE))
1555 {
1556 LOG_WARNING("%s is not in RESET or IDLE or PAUSR state", tap_state_name(tap_get_state()));
1557 }
1558
1559 if (vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] & (1 << (vsllink_tms_data_len - 1)))
1560 {
1561 // last tms bit is '1'
1562 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= 0xFF << vsllink_tms_data_len;
1563 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0xFF;
1564 vsllink_tms_data_len = 0;
1565 }
1566 else
1567 {
1568 // last tms bit is '0'
1569 vsllink_usb_out_buffer_idx++;
1570 vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0;
1571 vsllink_tms_data_len = 0;
1572 }
1573 }
1574
1575 if (vsllink_usb_out_buffer_idx > 3)
1576 {
1577 if (vsllink_usb_out_buffer[0] == VSLLINK_CMD_HW_JTAGSEQCMD)
1578 {
1579 vsllink_usb_out_buffer[1] = (vsllink_usb_out_buffer_idx >> 0) & 0xff;
1580 vsllink_usb_out_buffer[2] = (vsllink_usb_out_buffer_idx >> 8) & 0xff;
1581 }
1582
1583 result = vsllink_usb_message(vsllink_handle, vsllink_usb_out_buffer_idx, vsllink_usb_in_want_length);
1584
1585 if (result == vsllink_usb_in_want_length)
1586 {
1587 for (i = 0; i < pending_scan_results_length; i++)
1588 {
1589 struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[i];
1590 uint8_t *buffer = pending_scan_result->buffer;
1591 int length = pending_scan_result->length;
1592 int offset = pending_scan_result->offset;
1593 struct scan_command *command = pending_scan_result->command;
1594
1595 if (buffer != NULL)
1596 {
1597 // IRSHIFT or DRSHIFT
1598 buf_set_buf(vsllink_usb_in_buffer, first * 8 + offset, buffer, 0, length);
1599 first += (length + offset + 7) >> 3;
1600
1601 DEBUG_JTAG_IO("JTAG scan read(%d bits):", length);
1602 #ifdef _DEBUG_JTAG_IO_
1603 vsllink_debug_buffer(buffer, (length + 7) >> 3);
1604 #endif
1605
1606 if (jtag_read_buffer(buffer, command) != ERROR_OK)
1607 {
1608 vsllink_tap_init();
1609 return ERROR_JTAG_QUEUE_FAILED;
1610 }
1611
1612 free(pending_scan_result->buffer);
1613 pending_scan_result->buffer = NULL;
1614 }
1615 else
1616 {
1617 first++;
1618 }
1619 }
1620 }
1621 else
1622 {
1623 LOG_ERROR("vsllink_tap_execute, wrong result %d, expected %d", result, vsllink_usb_in_want_length);
1624 return ERROR_JTAG_QUEUE_FAILED;
1625 }
1626
1627 vsllink_tap_init();
1628 }
1629 reset_command_pointer();
1630
1631 return ERROR_OK;
1632 }
1633 static int vsllink_tap_execute_dma(void)
1634 {
1635 int byte_length;
1636 int i;
1637 int result;
1638
1639 if (tap_length > 0)
1640 {
1641 /* Pad last byte so that tap_length is divisible by 8 */
1642 while (tap_length % 8 != 0)
1643 {
1644 /* More of the last TMS value keeps us in the same state,
1645 * analogous to free-running JTAG interfaces. */
1646 vsllink_tap_append_step(last_tms, 0);
1647 }
1648 byte_length = tap_length / 8;
1649
1650 vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGRAWCMD;
1651 vsllink_usb_out_buffer[1] = ((byte_length * 2 + 3) >> 0) & 0xff; // package size
1652 vsllink_usb_out_buffer[2] = ((byte_length * 2 + 3) >> 8) & 0xff;
1653
1654 memcpy(&vsllink_usb_out_buffer[3], tdi_buffer, byte_length);
1655 memcpy(&vsllink_usb_out_buffer[3 + byte_length], tms_buffer, byte_length);
1656
1657 result = vsllink_usb_message(vsllink_handle, 3 + 2 * byte_length, byte_length);
1658 if (result == byte_length)
1659 {
1660 for (i = 0; i < pending_scan_results_length; i++)
1661 {
1662 struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[i];
1663 uint8_t *buffer = pending_scan_result->buffer;
1664 int length = pending_scan_result->length;
1665 int first = pending_scan_result->offset;
1666
1667 struct scan_command *command = pending_scan_result->command;
1668 buf_set_buf(vsllink_usb_in_buffer, first, buffer, 0, length);
1669
1670 DEBUG_JTAG_IO("JTAG scan read(%d bits, from %d bits):", length, first);
1671 #ifdef _DEBUG_JTAG_IO_
1672 vsllink_debug_buffer(buffer, (length + 7) >> 3);
1673 #endif
1674
1675 if (jtag_read_buffer(buffer, command) != ERROR_OK)
1676 {
1677 vsllink_tap_init();
1678 return ERROR_JTAG_QUEUE_FAILED;
1679 }
1680
1681 if (pending_scan_result->buffer != NULL)
1682 {
1683 free(pending_scan_result->buffer);
1684 }
1685 }
1686 }
1687 else
1688 {
1689 LOG_ERROR("vsllink_tap_execute, wrong result %d, expected %d", result, byte_length);
1690 return ERROR_JTAG_QUEUE_FAILED;
1691 }
1692
1693 vsllink_tap_init();
1694 }
1695
1696 return ERROR_OK;
1697 }
1698
1699 /*****************************************************************************/
1700 /* VSLLink USB low-level functions */
1701
1702 static struct vsllink* vsllink_usb_open(void)
1703 {
1704 usb_init();
1705
1706 const uint16_t vids[] = { vsllink_usb_vid, 0 };
1707 const uint16_t pids[] = { vsllink_usb_pid, 0 };
1708 struct usb_dev_handle *dev;
1709 if (jtag_usb_open(vids, pids, &dev) != ERROR_OK)
1710 return NULL;
1711
1712 /* usb_set_configuration required under win32 */
1713 struct usb_device *udev = usb_device(dev);
1714 int ret = usb_set_configuration(dev, udev->config[0].bConfigurationValue);
1715 if (ret != 0)
1716 {
1717 LOG_ERROR("fail to set configuration to %d (error %d)."
1718 "Not enough permissions for the device?",
1719 udev->config[0].bConfigurationValue, ret);
1720 return NULL;
1721 }
1722 ret = usb_claim_interface(dev, vsllink_usb_interface);
1723 if (ret != 0)
1724 {
1725 LOG_ERROR("fail to claim interface %d, %d returned",
1726 vsllink_usb_interface, ret);
1727 return NULL;
1728 }
1729 #if 0
1730 /*
1731 * This makes problems under Mac OS X. And is not needed
1732 * under Windows. Hopefully this will not break a linux build
1733 */
1734 usb_set_altinterface(dev, 0);
1735 #endif
1736
1737 struct vsllink *result = malloc(sizeof(struct vsllink));
1738 result->usb_handle = dev;
1739 return result;
1740 }
1741
1742 static void vsllink_usb_close(struct vsllink *vsllink)
1743 {
1744 int ret;
1745
1746 ret = usb_release_interface(vsllink->usb_handle, vsllink_usb_interface);
1747 if (ret != 0)
1748 {
1749 LOG_ERROR("fail to release interface %d, %d returned", vsllink_usb_interface, ret);
1750 exit(-1);
1751 }
1752
1753 ret = usb_close(vsllink->usb_handle);
1754 if (ret != 0)
1755 {
1756 LOG_ERROR("fail to close usb, %d returned", ret);
1757 exit(-1);
1758 }
1759
1760 free(vsllink);
1761 }
1762
1763 /* Send a message and receive the reply. */
1764 static int vsllink_usb_message(struct vsllink *vsllink, int out_length, int in_length)
1765 {
1766 int result;
1767
1768 result = vsllink_usb_write(vsllink, out_length);
1769 if (result == out_length)
1770 {
1771 if (in_length > 0)
1772 {
1773 result = vsllink_usb_read(vsllink);
1774 if (result == in_length)
1775 {
1776 return result;
1777 }
1778 else
1779 {
1780 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", in_length, result);
1781 return -1;
1782 }
1783 }
1784 return 0;
1785 }
1786 else
1787 {
1788 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)", out_length, result);
1789 return -1;
1790 }
1791 }
1792
1793 /* Write data from out_buffer to USB. */
1794 static int vsllink_usb_write(struct vsllink *vsllink, int out_length)
1795 {
1796 int result;
1797
1798 if (out_length > VSLLINK_BufferSize)
1799 {
1800 LOG_ERROR("vsllink_write illegal out_length=%d (max=%d)", out_length, VSLLINK_BufferSize);
1801 return -1;
1802 }
1803
1804 result = usb_bulk_write(vsllink->usb_handle, vsllink_usb_bulkout, \
1805 (char *)vsllink_usb_out_buffer, out_length, VSLLINK_USB_TIMEOUT);
1806
1807 DEBUG_JTAG_IO("vsllink_usb_write, out_length = %d, result = %d", out_length, result);
1808
1809 #ifdef _DEBUG_USB_COMMS_
1810 LOG_DEBUG("USB out:");
1811 vsllink_debug_buffer(vsllink_usb_out_buffer, out_length);
1812 #endif
1813
1814 #ifdef _VSLLINK_IN_DEBUG_MODE_
1815 usleep(100000);
1816 #endif
1817
1818 return result;
1819 }
1820
1821 /* Read data from USB into in_buffer. */
1822 static int vsllink_usb_read(struct vsllink *vsllink)
1823 {
1824 int result = usb_bulk_read(vsllink->usb_handle, vsllink_usb_bulkin, \
1825 (char *)vsllink_usb_in_buffer, VSLLINK_BufferSize, VSLLINK_USB_TIMEOUT);
1826
1827 DEBUG_JTAG_IO("vsllink_usb_read, result = %d", result);
1828
1829 #ifdef _DEBUG_USB_COMMS_
1830 LOG_DEBUG("USB in:");
1831 vsllink_debug_buffer(vsllink_usb_in_buffer, result);
1832 #endif
1833 return result;
1834 }
1835
1836 #define BYTES_PER_LINE 16
1837
1838 #if defined _DEBUG_USB_COMMS_ || defined _DEBUG_JTAG_IO_
1839 static void vsllink_debug_buffer(uint8_t *buffer, int length)
1840 {
1841 char line[81];
1842 char s[4];
1843 int i;
1844 int j;
1845
1846 for (i = 0; i < length; i += BYTES_PER_LINE)
1847 {
1848 snprintf(line, 5, "%04x", i);
1849 for (j = i; j < i + BYTES_PER_LINE && j < length; j++)
1850 {
1851 snprintf(s, 4, " %02x", buffer[j]);
1852 strcat(line, s);
1853 }
1854 LOG_DEBUG("%s", line);
1855 }
1856 }
1857 #endif // _DEBUG_USB_COMMS_ || _DEBUG_JTAG_IO_
1858
1859 static const struct command_registration vsllink_command_handlers[] = {
1860 {
1861 .name = "vsllink_usb_vid",
1862 .handler = &vsllink_handle_usb_vid_command,
1863 .mode = COMMAND_CONFIG,
1864 },
1865 {
1866 .name = "vsllink_usb_pid",
1867 .handler = &vsllink_handle_usb_pid_command,
1868 .mode = COMMAND_CONFIG,
1869 },
1870 {
1871 .name = "vsllink_usb_bulkin",
1872 .handler = &vsllink_handle_usb_bulkin_command,
1873 .mode = COMMAND_CONFIG,
1874 },
1875 {
1876 .name = "vsllink_usb_bulkout",
1877 .handler = &vsllink_handle_usb_bulkout_command,
1878 .mode = COMMAND_CONFIG,
1879 },
1880 {
1881 .name = "vsllink_usb_interface",
1882 .handler = &vsllink_handle_usb_interface_command,
1883 .mode = COMMAND_CONFIG,
1884 },
1885 {
1886 .name = "vsllink_mode",
1887 .handler = &vsllink_handle_mode_command,
1888 .mode = COMMAND_CONFIG,
1889 },
1890 COMMAND_REGISTRATION_DONE
1891 };
1892
1893 struct jtag_interface vsllink_interface = {
1894 .name = "vsllink",
1895 .commands = vsllink_command_handlers,
1896
1897 .init = vsllink_init,
1898 .quit = vsllink_quit,
1899 .khz = vsllink_khz,
1900 .speed = vsllink_speed,
1901 .speed_div = vsllink_speed_div,
1902 .execute_queue = vsllink_execute_queue,
1903 };
Official OpenOCD Mirror