Code Review / openocd.git / blob
? search:


02272bd93b2278512034d9c8cc981bc317729310
[openocd.git] / src / jtag / jtag.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include "replacements.h"
25
26 #include "jtag.h"
27
28 #include "command.h"
29 #include "log.h"
30
31 #include "stdlib.h"
32 #include "string.h"
33 #include <unistd.h>
34
35 /* note that this is not marked as static as it must be available from outside jtag.c for those
36 that implement the jtag_xxx() minidriver layer
37 */
38 int jtag_error=ERROR_OK;
39
40
41 char* tap_state_strings[16] =
42 {
43 "tlr",
44 "sds", "cd", "sd", "e1d", "pd", "e2d", "ud",
45 "rti",
46 "sis", "ci", "si", "e1i", "pi", "e2i", "ui"
47 };
48
49 typedef struct cmd_queue_page_s
50 {
51 void *address;
52 size_t used;
53 struct cmd_queue_page_s *next;
54 } cmd_queue_page_t;
55
56 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
57 static cmd_queue_page_t *cmd_queue_pages = NULL;
58
59 /* tap_move[i][j]: tap movement command to go from state i to state j
60 * 0: Test-Logic-Reset
61 * 1: Run-Test/Idle
62 * 2: Shift-DR
63 * 3: Pause-DR
64 * 4: Shift-IR
65 * 5: Pause-IR
66 *
67 * SD->SD and SI->SI have to be caught in interface specific code
68 */
69 u8 tap_move[6][6] =
70 {
71 /* TLR RTI SD PD SI PI */
72 {0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* TLR */
73 {0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* RTI */
74 {0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* SD */
75 {0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* PD */
76 {0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* SI */
77 {0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* PI */
78 };
79
80 int tap_move_map[16] = {
81 0, -1, -1, 2, -1, 3, -1, -1,
82 1, -1, -1, 4, -1, 5, -1, -1
83 };
84
85 tap_transition_t tap_transitions[16] =
86 {
87 {TAP_TLR, TAP_RTI}, /* TLR */
88 {TAP_SIS, TAP_CD}, /* SDS */
89 {TAP_E1D, TAP_SD}, /* CD */
90 {TAP_E1D, TAP_SD}, /* SD */
91 {TAP_UD, TAP_PD}, /* E1D */
92 {TAP_E2D, TAP_PD}, /* PD */
93 {TAP_UD, TAP_SD}, /* E2D */
94 {TAP_SDS, TAP_RTI}, /* UD */
95 {TAP_SDS, TAP_RTI}, /* RTI */
96 {TAP_TLR, TAP_CI}, /* SIS */
97 {TAP_E1I, TAP_SI}, /* CI */
98 {TAP_E1I, TAP_SI}, /* SI */
99 {TAP_UI, TAP_PI}, /* E1I */
100 {TAP_E2I, TAP_PI}, /* PI */
101 {TAP_UI, TAP_SI}, /* E2I */
102 {TAP_SDS, TAP_RTI} /* UI */
103 };
104
105 char* jtag_event_strings[] =
106 {
107 "JTAG controller reset (TLR or TRST)"
108 };
109
110 /* kludge!!!! these are just global variables that the
111 * interface use internally. They really belong
112 * inside the drivers, but we don't want to break
113 * linking the drivers!!!!
114 */
115 enum tap_state end_state = TAP_TLR;
116 enum tap_state cur_state = TAP_TLR;
117 int jtag_trst = 0;
118 int jtag_srst = 0;
119
120 jtag_command_t *jtag_command_queue = NULL;
121 jtag_command_t **last_comand_pointer = &jtag_command_queue;
122 jtag_device_t *jtag_devices = NULL;
123 int jtag_num_devices = 0;
124 int jtag_ir_scan_size = 0;
125 enum reset_types jtag_reset_config = RESET_NONE;
126 enum tap_state cmd_queue_end_state = TAP_TLR;
127 enum tap_state cmd_queue_cur_state = TAP_TLR;
128
129 int jtag_verify_capture_ir = 1;
130
131 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
132 int jtag_nsrst_delay = 0; /* default to no nSRST delay */
133 int jtag_ntrst_delay = 0; /* default to no nTRST delay */
134
135 /* maximum number of JTAG devices expected in the chain
136 */
137 #define JTAG_MAX_CHAIN_SIZE 20
138
139 /* callbacks to inform high-level handlers about JTAG state changes */
140 jtag_event_callback_t *jtag_event_callbacks;
141
142 /* speed in kHz*/
143 static int speed1 = 0, speed2 = 0;
144 /* flag if the kHz speed was defined */
145 static int hasKHz = 0;
146
147 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
148 */
149
150 #if BUILD_ECOSBOARD == 1
151 extern jtag_interface_t eCosBoard_interface;
152 #endif
153
154 #if BUILD_PARPORT == 1
155 extern jtag_interface_t parport_interface;
156 #endif
157
158 #if BUILD_DUMMY == 1
159 extern jtag_interface_t dummy_interface;
160 #endif
161
162 #if BUILD_FT2232_FTD2XX == 1
163 extern jtag_interface_t ft2232_interface;
164 #endif
165
166 #if BUILD_FT2232_LIBFTDI == 1
167 extern jtag_interface_t ft2232_interface;
168 #endif
169
170 #if BUILD_AMTJTAGACCEL == 1
171 extern jtag_interface_t amt_jtagaccel_interface;
172 #endif
173
174 #if BUILD_EP93XX == 1
175 extern jtag_interface_t ep93xx_interface;
176 #endif
177
178 #if BUILD_AT91RM9200 == 1
179 extern jtag_interface_t at91rm9200_interface;
180 #endif
181
182 #if BUILD_GW16012 == 1
183 extern jtag_interface_t gw16012_interface;
184 #endif
185
186 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
187 extern jtag_interface_t presto_interface;
188 #endif
189
190 #if BUILD_USBPROG == 1
191 extern jtag_interface_t usbprog_interface;
192 #endif
193
194 #if BUILD_JLINK == 1
195 extern jtag_interface_t jlink_interface;
196 #endif
197
198 jtag_interface_t *jtag_interfaces[] = {
199 #if BUILD_ECOSBOARD == 1
200 &eCosBoard_interface,
201 #endif
202 #if BUILD_PARPORT == 1
203 &parport_interface,
204 #endif
205 #if BUILD_DUMMY == 1
206 &dummy_interface,
207 #endif
208 #if BUILD_FT2232_FTD2XX == 1
209 &ft2232_interface,
210 #endif
211 #if BUILD_FT2232_LIBFTDI == 1
212 &ft2232_interface,
213 #endif
214 #if BUILD_AMTJTAGACCEL == 1
215 &amt_jtagaccel_interface,
216 #endif
217 #if BUILD_EP93XX == 1
218 &ep93xx_interface,
219 #endif
220 #if BUILD_AT91RM9200 == 1
221 &at91rm9200_interface,
222 #endif
223 #if BUILD_GW16012 == 1
224 &gw16012_interface,
225 #endif
226 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
227 &presto_interface,
228 #endif
229 #if BUILD_USBPROG == 1
230 &usbprog_interface,
231 #endif
232 #if BUILD_JLINK == 1
233 &jlink_interface,
234 #endif
235 NULL,
236 };
237
238 jtag_interface_t *jtag = NULL;
239
240 /* configuration */
241 jtag_interface_t *jtag_interface = NULL;
242 int jtag_speed = 0;
243 int jtag_speed_post_reset = 0;
244
245
246 /* forward declarations */
247 void jtag_add_pathmove(int num_states, enum tap_state *path);
248 void jtag_add_runtest(int num_cycles, enum tap_state endstate);
249 void jtag_add_end_state(enum tap_state endstate);
250 void jtag_add_sleep(u32 us);
251 int jtag_execute_queue(void);
252 int jtag_cancel_queue(void);
253
254 /* jtag commands */
255 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
256 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
257 int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
258 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
259 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
260 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
261 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
262
263 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
264
265 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
266 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
267 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
268 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
269 int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
270
271 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
272
273 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
274 {
275 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
276
277 if (callback == NULL)
278 {
279 return ERROR_INVALID_ARGUMENTS;
280 }
281
282 if (*callbacks_p)
283 {
284 while ((*callbacks_p)->next)
285 callbacks_p = &((*callbacks_p)->next);
286 callbacks_p = &((*callbacks_p)->next);
287 }
288
289 (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
290 (*callbacks_p)->callback = callback;
291 (*callbacks_p)->priv = priv;
292 (*callbacks_p)->next = NULL;
293
294 return ERROR_OK;
295 }
296
297 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
298 {
299 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
300
301 if (callback == NULL)
302 {
303 return ERROR_INVALID_ARGUMENTS;
304 }
305
306 while (*callbacks_p)
307 {
308 jtag_event_callback_t **next = &((*callbacks_p)->next);
309 if ((*callbacks_p)->callback == callback)
310 {
311 free(*callbacks_p);
312 *callbacks_p = *next;
313 }
314 callbacks_p = next;
315 }
316
317 return ERROR_OK;
318 }
319
320 int jtag_call_event_callbacks(enum jtag_event event)
321 {
322 jtag_event_callback_t *callback = jtag_event_callbacks;
323
324 LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
325
326 while (callback)
327 {
328 callback->callback(event, callback->priv);
329 callback = callback->next;
330 }
331
332 return ERROR_OK;
333 }
334
335 /* returns a pointer to the pointer of the last command in queue
336 * this may be a pointer to the root pointer (jtag_command_queue)
337 * or to the next member of the last but one command
338 */
339 jtag_command_t** jtag_get_last_command_p(void)
340 {
341 /* jtag_command_t *cmd = jtag_command_queue;
342
343 if (cmd)
344 while (cmd->next)
345 cmd = cmd->next;
346 else
347 return &jtag_command_queue;
348
349 return &cmd->next;*/
350
351 return last_comand_pointer;
352 }
353
354 /* returns a pointer to the n-th device in the scan chain */
355 jtag_device_t* jtag_get_device(int num)
356 {
357 jtag_device_t *device = jtag_devices;
358 int i = 0;
359
360 while (device)
361 {
362 if (num == i)
363 return device;
364 device = device->next;
365 i++;
366 }
367
368 LOG_ERROR("jtag device number %d not defined", num);
369 exit(-1);
370 }
371
372 void* cmd_queue_alloc(size_t size)
373 {
374 cmd_queue_page_t **p_page = &cmd_queue_pages;
375 int offset;
376 u8 *t;
377
378 if (*p_page)
379 {
380 while ((*p_page)->next)
381 p_page = &((*p_page)->next);
382 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
383 p_page = &((*p_page)->next);
384 }
385
386 if (!*p_page)
387 {
388 *p_page = malloc(sizeof(cmd_queue_page_t));
389 (*p_page)->used = 0;
390 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
391 (*p_page)->next = NULL;
392 }
393
394 offset = (*p_page)->used;
395 (*p_page)->used += size;
396
397 t=(u8 *)((*p_page)->address);
398 return t + offset;
399 }
400
401 void cmd_queue_free()
402 {
403 cmd_queue_page_t *page = cmd_queue_pages;
404
405 while (page)
406 {
407 cmd_queue_page_t *last = page;
408 free(page->address);
409 page = page->next;
410 free(last);
411 }
412
413 cmd_queue_pages = NULL;
414 }
415
416 static void jtag_prelude1()
417 {
418 if (jtag_trst == 1)
419 {
420 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
421 jtag_error=ERROR_JTAG_TRST_ASSERTED;
422 return;
423 }
424
425 if (cmd_queue_end_state == TAP_TLR)
426 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
427 }
428
429 static void jtag_prelude(enum tap_state state)
430 {
431 jtag_prelude1();
432
433 if (state != -1)
434 jtag_add_end_state(state);
435
436 cmd_queue_cur_state = cmd_queue_end_state;
437 }
438
439 void jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
440 {
441 int retval;
442
443 jtag_prelude(state);
444
445 retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state);
446 if (retval!=ERROR_OK)
447 jtag_error=retval;
448 }
449
450 int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
451 {
452 jtag_command_t **last_cmd;
453 jtag_device_t *device;
454 int i, j;
455 int scan_size = 0;
456
457
458 last_cmd = jtag_get_last_command_p();
459
460 /* allocate memory for a new list member */
461 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
462 (*last_cmd)->next = NULL;
463 last_comand_pointer = &((*last_cmd)->next);
464 (*last_cmd)->type = JTAG_SCAN;
465
466 /* allocate memory for ir scan command */
467 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
468 (*last_cmd)->cmd.scan->ir_scan = 1;
469 (*last_cmd)->cmd.scan->num_fields = jtag_num_devices; /* one field per device */
470 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(jtag_num_devices * sizeof(scan_field_t));
471 (*last_cmd)->cmd.scan->end_state = state;
472
473 for (i = 0; i < jtag_num_devices; i++)
474 {
475 int found = 0;
476 device = jtag_get_device(i);
477 scan_size = device->ir_length;
478 (*last_cmd)->cmd.scan->fields[i].device = i;
479 (*last_cmd)->cmd.scan->fields[i].num_bits = scan_size;
480 (*last_cmd)->cmd.scan->fields[i].in_value = NULL;
481 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL; /* disable verification by default */
482
483 /* search the list */
484 for (j = 0; j < num_fields; j++)
485 {
486 if (i == fields[j].device)
487 {
488 found = 1;
489 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
490 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
491
492 if (jtag_verify_capture_ir)
493 {
494 if (fields[j].in_handler==NULL)
495 {
496 jtag_set_check_value((*last_cmd)->cmd.scan->fields+i, device->expected, device->expected_mask, NULL);
497 } else
498 {
499 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[j].in_handler;
500 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[j].in_handler_priv;
501 (*last_cmd)->cmd.scan->fields[i].in_check_value = device->expected;
502 (*last_cmd)->cmd.scan->fields[i].in_check_mask = device->expected_mask;
503 }
504 }
505
506 device->bypass = 0;
507 break;
508 }
509 }
510
511 if (!found)
512 {
513 /* if a device isn't listed, set it to BYPASS */
514 (*last_cmd)->cmd.scan->fields[i].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
515 (*last_cmd)->cmd.scan->fields[i].out_mask = NULL;
516 device->bypass = 1;
517
518 }
519
520 /* update device information */
521 buf_cpy((*last_cmd)->cmd.scan->fields[i].out_value, jtag_get_device(i)->cur_instr, scan_size);
522 }
523
524 return ERROR_OK;
525 }
526
527 void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
528 {
529 int retval;
530
531 jtag_prelude(state);
532
533 retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state);
534 if (retval!=ERROR_OK)
535 jtag_error=retval;
536 }
537
538 int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
539 {
540 int i;
541 jtag_command_t **last_cmd;
542
543 last_cmd = jtag_get_last_command_p();
544
545 /* allocate memory for a new list member */
546 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
547 (*last_cmd)->next = NULL;
548 last_comand_pointer = &((*last_cmd)->next);
549 (*last_cmd)->type = JTAG_SCAN;
550
551 /* allocate memory for ir scan command */
552 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
553 (*last_cmd)->cmd.scan->ir_scan = 1;
554 (*last_cmd)->cmd.scan->num_fields = num_fields;
555 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
556 (*last_cmd)->cmd.scan->end_state = state;
557
558 for (i = 0; i < num_fields; i++)
559 {
560 int num_bits = fields[i].num_bits;
561 int num_bytes = CEIL(fields[i].num_bits, 8);
562 (*last_cmd)->cmd.scan->fields[i].device = fields[i].device;
563 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
564 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
565 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
566 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
567 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
568 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
569 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
570 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
571 }
572 return ERROR_OK;
573 }
574
575 void jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
576 {
577 int retval;
578
579 jtag_prelude(state);
580
581 retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state);
582 if (retval!=ERROR_OK)
583 jtag_error=retval;
584 }
585
586 int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
587 {
588 int i, j;
589 int bypass_devices = 0;
590 int field_count = 0;
591 int scan_size;
592
593 jtag_command_t **last_cmd = jtag_get_last_command_p();
594 jtag_device_t *device = jtag_devices;
595
596 /* count devices in bypass */
597 while (device)
598 {
599 if (device->bypass)
600 bypass_devices++;
601 device = device->next;
602 }
603 if (bypass_devices >= jtag_num_devices)
604 {
605 LOG_ERROR("all devices in bypass");
606 return ERROR_JTAG_DEVICE_ERROR;
607 }
608
609 /* allocate memory for a new list member */
610 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
611 last_comand_pointer = &((*last_cmd)->next);
612 (*last_cmd)->next = NULL;
613 (*last_cmd)->type = JTAG_SCAN;
614
615 /* allocate memory for dr scan command */
616 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
617 (*last_cmd)->cmd.scan->ir_scan = 0;
618 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
619 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
620 (*last_cmd)->cmd.scan->end_state = state;
621
622 for (i = 0; i < jtag_num_devices; i++)
623 {
624 int found = 0;
625 (*last_cmd)->cmd.scan->fields[field_count].device = i;
626
627 for (j = 0; j < num_fields; j++)
628 {
629 if (i == fields[j].device)
630 {
631 found = 1;
632 scan_size = fields[j].num_bits;
633 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
634 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
635 (*last_cmd)->cmd.scan->fields[field_count].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
636 (*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
637 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value;
638 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask;
639 (*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler;
640 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv;
641 }
642 }
643 if (!found)
644 {
645 #ifdef _DEBUG_JTAG_IO_
646 /* if a device isn't listed, the BYPASS register should be selected */
647 if (!jtag_get_device(i)->bypass)
648 {
649 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
650 exit(-1);
651 }
652 #endif
653 /* program the scan field to 1 bit length, and ignore it's value */
654 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
655 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
656 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
657 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
658 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
659 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
660 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
661 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
662 }
663 else
664 {
665 #ifdef _DEBUG_JTAG_IO_
666 /* if a device is listed, the BYPASS register must not be selected */
667 if (jtag_get_device(i)->bypass)
668 {
669 LOG_ERROR("BUG: scan data for a device in BYPASS");
670 exit(-1);
671 }
672 #endif
673 }
674 }
675 return ERROR_OK;
676 }
677
678 void MINIDRIVER(interface_jtag_add_dr_out)(int device_num,
679 int num_fields,
680 const int *num_bits,
681 const u32 *value,
682 enum tap_state end_state)
683 {
684 int i;
685 int field_count = 0;
686 int scan_size;
687 int bypass_devices = 0;
688
689 jtag_command_t **last_cmd = jtag_get_last_command_p();
690 jtag_device_t *device = jtag_devices;
691 /* count devices in bypass */
692 while (device)
693 {
694 if (device->bypass)
695 bypass_devices++;
696 device = device->next;
697 }
698
699 /* allocate memory for a new list member */
700 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
701 last_comand_pointer = &((*last_cmd)->next);
702 (*last_cmd)->next = NULL;
703 (*last_cmd)->type = JTAG_SCAN;
704
705 /* allocate memory for dr scan command */
706 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
707 (*last_cmd)->cmd.scan->ir_scan = 0;
708 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
709 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
710 (*last_cmd)->cmd.scan->end_state = end_state;
711
712 for (i = 0; i < jtag_num_devices; i++)
713 {
714 (*last_cmd)->cmd.scan->fields[field_count].device = i;
715
716 if (i == device_num)
717 {
718 int j;
719 #ifdef _DEBUG_JTAG_IO_
720 /* if a device is listed, the BYPASS register must not be selected */
721 if (jtag_get_device(i)->bypass)
722 {
723 LOG_ERROR("BUG: scan data for a device in BYPASS");
724 exit(-1);
725 }
726 #endif
727 for (j = 0; j < num_fields; j++)
728 {
729 u8 out_value[4];
730 scan_size = num_bits[j];
731 buf_set_u32(out_value, 0, scan_size, value[j]);
732 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
733 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
734 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
735 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
736 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
737 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
738 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
739 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
740 }
741 } else
742 {
743 #ifdef _DEBUG_JTAG_IO_
744 /* if a device isn't listed, the BYPASS register should be selected */
745 if (!jtag_get_device(i)->bypass)
746 {
747 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
748 exit(-1);
749 }
750 #endif
751 /* program the scan field to 1 bit length, and ignore it's value */
752 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
753 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
754 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
755 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
756 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
757 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
758 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
759 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
760 }
761 }
762 }
763
764
765
766
767 void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
768 {
769 int retval;
770
771 jtag_prelude(state);
772
773 retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state);
774 if (retval!=ERROR_OK)
775 jtag_error=retval;
776 }
777
778 int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
779 {
780 int i;
781 jtag_command_t **last_cmd = jtag_get_last_command_p();
782
783 /* allocate memory for a new list member */
784 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
785 last_comand_pointer = &((*last_cmd)->next);
786 (*last_cmd)->next = NULL;
787 (*last_cmd)->type = JTAG_SCAN;
788
789 /* allocate memory for scan command */
790 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
791 (*last_cmd)->cmd.scan->ir_scan = 0;
792 (*last_cmd)->cmd.scan->num_fields = num_fields;
793 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
794 (*last_cmd)->cmd.scan->end_state = state;
795
796 for (i = 0; i < num_fields; i++)
797 {
798 int num_bits = fields[i].num_bits;
799 int num_bytes = CEIL(fields[i].num_bits, 8);
800 (*last_cmd)->cmd.scan->fields[i].device = fields[i].device;
801 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
802 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
803 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
804 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
805 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
806 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
807 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
808 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
809 }
810
811 return ERROR_OK;
812 }
813
814 void jtag_add_tlr()
815 {
816 jtag_prelude(TAP_TLR);
817
818 int retval;
819 retval=interface_jtag_add_tlr();
820 if (retval!=ERROR_OK)
821 jtag_error=retval;
822 }
823
824 int MINIDRIVER(interface_jtag_add_tlr)()
825 {
826 enum tap_state state = TAP_TLR;
827 jtag_command_t **last_cmd = jtag_get_last_command_p();
828
829 /* allocate memory for a new list member */
830 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
831 last_comand_pointer = &((*last_cmd)->next);
832 (*last_cmd)->next = NULL;
833 (*last_cmd)->type = JTAG_STATEMOVE;
834
835 (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
836 (*last_cmd)->cmd.statemove->end_state = state;
837
838
839 return ERROR_OK;
840 }
841
842 void jtag_add_pathmove(int num_states, enum tap_state *path)
843 {
844 enum tap_state cur_state=cmd_queue_cur_state;
845 int i;
846 int retval;
847
848 /* the last state has to be a stable state */
849 if (tap_move_map[path[num_states - 1]] == -1)
850 {
851 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
852 exit(-1);
853 }
854
855 for (i=0; i<num_states; i++)
856 {
857 if ((tap_transitions[cur_state].low != path[i])&&
858 (tap_transitions[cur_state].high != path[i]))
859 {
860 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[path[i]]);
861 exit(-1);
862 }
863 cur_state = path[i];
864 }
865
866 jtag_prelude1();
867
868 cmd_queue_cur_state = path[num_states - 1];
869
870 retval=interface_jtag_add_pathmove(num_states, path);
871 if (retval!=ERROR_OK)
872 jtag_error=retval;
873 }
874
875
876 int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, enum tap_state *path)
877 {
878 jtag_command_t **last_cmd = jtag_get_last_command_p();
879 int i;
880
881 /* allocate memory for a new list member */
882 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
883 last_comand_pointer = &((*last_cmd)->next);
884 (*last_cmd)->next = NULL;
885 (*last_cmd)->type = JTAG_PATHMOVE;
886
887 (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
888 (*last_cmd)->cmd.pathmove->num_states = num_states;
889 (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(enum tap_state) * num_states);
890
891 for (i = 0; i < num_states; i++)
892 (*last_cmd)->cmd.pathmove->path[i] = path[i];
893
894 return ERROR_OK;
895 }
896
897 int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, enum tap_state state)
898 {
899 jtag_command_t **last_cmd = jtag_get_last_command_p();
900
901 /* allocate memory for a new list member */
902 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
903 (*last_cmd)->next = NULL;
904 last_comand_pointer = &((*last_cmd)->next);
905 (*last_cmd)->type = JTAG_RUNTEST;
906
907 (*last_cmd)->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
908 (*last_cmd)->cmd.runtest->num_cycles = num_cycles;
909 (*last_cmd)->cmd.runtest->end_state = state;
910
911 return ERROR_OK;
912 }
913
914 void jtag_add_runtest(int num_cycles, enum tap_state state)
915 {
916 int retval;
917
918 jtag_prelude(state);
919
920 /* executed by sw or hw fifo */
921 retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
922 if (retval!=ERROR_OK)
923 jtag_error=retval;
924 }
925
926 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
927 {
928 int trst_with_tlr = 0;
929 int retval;
930
931 /* FIX!!! there are *many* different cases here. A better
932 * approach is needed for legal combinations of transitions...
933 */
934 if ((jtag_reset_config & RESET_HAS_SRST)&&
935 (jtag_reset_config & RESET_HAS_TRST)&&
936 ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
937 {
938 if (((req_tlr_or_trst&&!jtag_trst)||
939 (!req_tlr_or_trst&&jtag_trst))&&
940 ((req_srst&&!jtag_srst)||
941 (!req_srst&&jtag_srst)))
942 {
943 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
944 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
945 }
946 }
947
948 /* Make sure that jtag_reset_config allows the requested reset */
949 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
950 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
951 {
952 LOG_ERROR("BUG: requested reset would assert trst");
953 jtag_error=ERROR_FAIL;
954 return;
955 }
956
957 /* if TRST pulls SRST, we reset with TAP T-L-R */
958 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
959 {
960 trst_with_tlr = 1;
961 }
962
963 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
964 {
965 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
966 jtag_error=ERROR_FAIL;
967 return;
968 }
969
970 if (req_tlr_or_trst)
971 {
972 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
973 {
974 jtag_trst = 1;
975 } else
976 {
977 trst_with_tlr = 1;
978 }
979 } else
980 {
981 jtag_trst = 0;
982 }
983
984 jtag_srst = req_srst;
985
986 retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
987 if (retval!=ERROR_OK)
988 {
989 jtag_error=retval;
990 return;
991 }
992
993 if (jtag_srst)
994 {
995 LOG_DEBUG("SRST line asserted");
996 }
997 else
998 {
999 LOG_DEBUG("SRST line released");
1000 if (jtag_nsrst_delay)
1001 jtag_add_sleep(jtag_nsrst_delay * 1000);
1002 }
1003
1004 if (trst_with_tlr)
1005 {
1006 LOG_DEBUG("JTAG reset with TLR instead of TRST");
1007 jtag_add_end_state(TAP_TLR);
1008 jtag_add_tlr();
1009 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1010 return;
1011 }
1012
1013 if (jtag_trst)
1014 {
1015 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1016 * and inform possible listeners about this
1017 */
1018 LOG_DEBUG("TRST line asserted");
1019 cmd_queue_cur_state = TAP_TLR;
1020 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1021 }
1022 else
1023 {
1024 if (jtag_ntrst_delay)
1025 jtag_add_sleep(jtag_ntrst_delay * 1000);
1026 }
1027 }
1028
1029 int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst)
1030 {
1031 jtag_command_t **last_cmd = jtag_get_last_command_p();
1032
1033 /* allocate memory for a new list member */
1034 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1035 (*last_cmd)->next = NULL;
1036 last_comand_pointer = &((*last_cmd)->next);
1037 (*last_cmd)->type = JTAG_RESET;
1038
1039 (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
1040 (*last_cmd)->cmd.reset->trst = req_trst;
1041 (*last_cmd)->cmd.reset->srst = req_srst;
1042
1043
1044 return ERROR_OK;
1045 }
1046
1047 void jtag_add_end_state(enum tap_state state)
1048 {
1049 cmd_queue_end_state = state;
1050 if ((cmd_queue_end_state == TAP_SD)||(cmd_queue_end_state == TAP_SD))
1051 {
1052 LOG_ERROR("BUG: TAP_SD/SI can't be end state. Calling code should use a larger scan field");
1053 }
1054 }
1055
1056 int MINIDRIVER(interface_jtag_add_sleep)(u32 us)
1057 {
1058 jtag_command_t **last_cmd = jtag_get_last_command_p();
1059
1060 /* allocate memory for a new list member */
1061 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1062 (*last_cmd)->next = NULL;
1063 last_comand_pointer = &((*last_cmd)->next);
1064 (*last_cmd)->type = JTAG_SLEEP;
1065
1066 (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
1067 (*last_cmd)->cmd.sleep->us = us;
1068
1069 return ERROR_OK;
1070 }
1071
1072 void jtag_add_sleep(u32 us)
1073 {
1074 keep_alive(); /* we might be running on a very slow JTAG clk */
1075 int retval=interface_jtag_add_sleep(us);
1076 if (retval!=ERROR_OK)
1077 jtag_error=retval;
1078 return;
1079 }
1080
1081 int jtag_scan_size(scan_command_t *cmd)
1082 {
1083 int bit_count = 0;
1084 int i;
1085
1086 /* count bits in scan command */
1087 for (i = 0; i < cmd->num_fields; i++)
1088 {
1089 bit_count += cmd->fields[i].num_bits;
1090 }
1091
1092 return bit_count;
1093 }
1094
1095 int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
1096 {
1097 int bit_count = 0;
1098 int i;
1099
1100 bit_count = jtag_scan_size(cmd);
1101 *buffer = malloc(CEIL(bit_count, 8));
1102
1103 bit_count = 0;
1104
1105 for (i = 0; i < cmd->num_fields; i++)
1106 {
1107 if (cmd->fields[i].out_value)
1108 {
1109 #ifdef _DEBUG_JTAG_IO_
1110 char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > 64) ? 64 : cmd->fields[i].num_bits, 16);
1111 #endif
1112 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
1113 #ifdef _DEBUG_JTAG_IO_
1114 LOG_DEBUG("fields[%i].out_value: 0x%s", i, char_buf);
1115 free(char_buf);
1116 #endif
1117 }
1118
1119 bit_count += cmd->fields[i].num_bits;
1120 }
1121
1122 return bit_count;
1123
1124 }
1125
1126 int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
1127 {
1128 int i;
1129 int bit_count = 0;
1130 int retval;
1131
1132 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1133 retval = ERROR_OK;
1134
1135 for (i = 0; i < cmd->num_fields; i++)
1136 {
1137 /* if neither in_value nor in_handler
1138 * are specified we don't have to examine this field
1139 */
1140 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1141 {
1142 int num_bits = cmd->fields[i].num_bits;
1143 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
1144
1145 #ifdef _DEBUG_JTAG_IO_
1146 char *char_buf;
1147
1148 char_buf = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
1149 LOG_DEBUG("fields[%i].in_value: 0x%s", i, char_buf);
1150 free(char_buf);
1151 #endif
1152
1153 if (cmd->fields[i].in_value)
1154 {
1155 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1156
1157 if (cmd->fields[i].in_handler)
1158 {
1159 if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1160 {
1161 LOG_WARNING("in_handler reported a failed check");
1162 retval = ERROR_JTAG_QUEUE_FAILED;
1163 }
1164 }
1165 }
1166
1167 /* no in_value specified, but a handler takes care of the scanned data */
1168 if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
1169 {
1170 if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1171 {
1172 /* We're going to call the error:handler later, but if the in_handler
1173 * reported an error we report this failure upstream
1174 */
1175 LOG_WARNING("in_handler reported a failed check");
1176 retval = ERROR_JTAG_QUEUE_FAILED;
1177 }
1178 }
1179
1180 free(captured);
1181 }
1182 bit_count += cmd->fields[i].num_bits;
1183 }
1184
1185 return retval;
1186 }
1187
1188 int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
1189 {
1190 int retval = ERROR_OK;
1191 int num_bits = field->num_bits;
1192
1193 int compare_failed = 0;
1194
1195 if (field->in_check_mask)
1196 compare_failed = buf_cmp_mask(captured, field->in_check_value, field->in_check_mask, num_bits);
1197 else
1198 compare_failed = buf_cmp(captured, field->in_check_value, num_bits);
1199
1200 if (compare_failed)
1201 {
1202 /* An error handler could have caught the failing check
1203 * only report a problem when there wasn't a handler, or if the handler
1204 * acknowledged the error
1205 */
1206 if (compare_failed)
1207 {
1208 char *captured_char = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
1209 char *in_check_value_char = buf_to_str(field->in_check_value, (num_bits > 64) ? 64 : num_bits, 16);
1210
1211 if (field->in_check_mask)
1212 {
1213 char *in_check_mask_char;
1214 in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > 64) ? 64 : num_bits, 16);
1215 LOG_WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s check_mask: 0x%s", captured_char, in_check_value_char, in_check_mask_char);
1216 free(in_check_mask_char);
1217 }
1218 else
1219 {
1220 LOG_WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char, in_check_value_char);
1221 }
1222
1223 free(captured_char);
1224 free(in_check_value_char);
1225
1226 retval = ERROR_JTAG_QUEUE_FAILED;
1227 }
1228
1229 }
1230 return retval;
1231 }
1232
1233 /*
1234 set up checking of this field using the in_handler. The values passed in must be valid until
1235 after jtag_execute() has completed.
1236 */
1237 void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handler_t *in_error_handler)
1238 {
1239 if (value)
1240 field->in_handler = jtag_check_value;
1241 else
1242 field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1243 field->in_handler_priv = NULL;
1244 field->in_check_value = value;
1245 field->in_check_mask = mask;
1246 }
1247
1248 enum scan_type jtag_scan_type(scan_command_t *cmd)
1249 {
1250 int i;
1251 int type = 0;
1252
1253 for (i = 0; i < cmd->num_fields; i++)
1254 {
1255 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1256 type |= SCAN_IN;
1257 if (cmd->fields[i].out_value)
1258 type |= SCAN_OUT;
1259 }
1260
1261 return type;
1262 }
1263
1264 int MINIDRIVER(interface_jtag_execute_queue)(void)
1265 {
1266 int retval;
1267
1268 if (jtag==NULL)
1269 {
1270 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1271 return ERROR_FAIL;
1272 }
1273
1274 retval = jtag->execute_queue();
1275
1276 cmd_queue_free();
1277
1278 jtag_command_queue = NULL;
1279 last_comand_pointer = &jtag_command_queue;
1280
1281 return retval;
1282 }
1283
1284 int jtag_execute_queue(void)
1285 {
1286 int retval=interface_jtag_execute_queue();
1287 if (retval==ERROR_OK)
1288 {
1289 retval=jtag_error;
1290 }
1291 jtag_error=ERROR_OK;
1292 return retval;
1293 }
1294
1295 int jtag_reset_callback(enum jtag_event event, void *priv)
1296 {
1297 jtag_device_t *device = priv;
1298
1299 LOG_DEBUG("-");
1300
1301 if (event == JTAG_TRST_ASSERTED)
1302 {
1303 buf_set_ones(device->cur_instr, device->ir_length);
1304 device->bypass = 1;
1305 }
1306
1307 return ERROR_OK;
1308 }
1309
1310 void jtag_sleep(u32 us)
1311 {
1312 usleep(us);
1313 }
1314
1315 /* Try to examine chain layout according to IEEE 1149.1 §12
1316 */
1317 int jtag_examine_chain()
1318 {
1319 jtag_device_t *device = jtag_devices;
1320 scan_field_t field;
1321 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1322 int i;
1323 int bit_count;
1324 int device_count = 0;
1325 u8 zero_check = 0x0;
1326 u8 one_check = 0xff;
1327
1328 field.device = 0;
1329 field.num_bits = sizeof(idcode_buffer) * 8;
1330 field.out_value = idcode_buffer;
1331 field.out_mask = NULL;
1332 field.in_value = idcode_buffer;
1333 field.in_check_value = NULL;
1334 field.in_check_mask = NULL;
1335 field.in_handler = NULL;
1336 field.in_handler_priv = NULL;
1337
1338 for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1339 {
1340 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1341 }
1342
1343 jtag_add_plain_dr_scan(1, &field, TAP_TLR);
1344 jtag_execute_queue();
1345
1346 for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1347 {
1348 zero_check |= idcode_buffer[i];
1349 one_check &= idcode_buffer[i];
1350 }
1351
1352 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1353 if ((zero_check == 0x00) || (one_check == 0xff))
1354 {
1355 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1356 return ERROR_JTAG_INIT_FAILED;
1357 }
1358
1359 for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1360 {
1361 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1362 if ((idcode & 1) == 0)
1363 {
1364 /* LSB must not be 0, this indicates a device in bypass */
1365 device_count++;
1366
1367 bit_count += 1;
1368 }
1369 else
1370 {
1371 u32 manufacturer;
1372 u32 part;
1373 u32 version;
1374
1375 if (idcode == 0x000000FF)
1376 {
1377 /* End of chain (invalid manufacturer ID) */
1378 break;
1379 }
1380
1381 if (device)
1382 {
1383 device->idcode = idcode;
1384 device = device->next;
1385 }
1386 device_count++;
1387
1388 manufacturer = (idcode & 0xffe) >> 1;
1389 part = (idcode & 0xffff000) >> 12;
1390 version = (idcode & 0xf0000000) >> 28;
1391
1392 LOG_INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1393 idcode, manufacturer, part, version);
1394
1395 bit_count += 32;
1396 }
1397 }
1398
1399 /* see if number of discovered devices matches configuration */
1400 if (device_count != jtag_num_devices)
1401 {
1402 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1403 device_count, jtag_num_devices);
1404 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1405 return ERROR_JTAG_INIT_FAILED;
1406 }
1407
1408 return ERROR_OK;
1409 }
1410
1411 int jtag_validate_chain()
1412 {
1413 jtag_device_t *device = jtag_devices;
1414 int total_ir_length = 0;
1415 u8 *ir_test = NULL;
1416 scan_field_t field;
1417 int chain_pos = 0;
1418
1419 while (device)
1420 {
1421 total_ir_length += device->ir_length;
1422 device = device->next;
1423 }
1424
1425 total_ir_length += 2;
1426 ir_test = malloc(CEIL(total_ir_length, 8));
1427 buf_set_ones(ir_test, total_ir_length);
1428
1429 field.device = 0;
1430 field.num_bits = total_ir_length;
1431 field.out_value = ir_test;
1432 field.out_mask = NULL;
1433 field.in_value = ir_test;
1434 field.in_check_value = NULL;
1435 field.in_check_mask = NULL;
1436 field.in_handler = NULL;
1437 field.in_handler_priv = NULL;
1438
1439 jtag_add_plain_ir_scan(1, &field, TAP_TLR);
1440 jtag_execute_queue();
1441
1442 device = jtag_devices;
1443 while (device)
1444 {
1445 if (buf_get_u32(ir_test, chain_pos, 2) != 0x1)
1446 {
1447 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1448 LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
1449 free(cbuf);
1450 free(ir_test);
1451 return ERROR_JTAG_INIT_FAILED;
1452 }
1453 chain_pos += device->ir_length;
1454 device = device->next;
1455 }
1456
1457 if (buf_get_u32(ir_test, chain_pos, 2) != 0x3)
1458 {
1459 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1460 LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
1461 free(cbuf);
1462 free(ir_test);
1463 return ERROR_JTAG_INIT_FAILED;
1464 }
1465
1466 free(ir_test);
1467
1468 return ERROR_OK;
1469 }
1470
1471 int jtag_register_commands(struct command_context_s *cmd_ctx)
1472 {
1473 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
1474 COMMAND_CONFIG, NULL);
1475 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
1476 COMMAND_ANY, "set jtag speed (if supported) <reset speed> [<post reset speed, default value is reset speed>]");
1477 register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
1478 COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
1479 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
1480 COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
1481 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
1482 COMMAND_CONFIG, NULL);
1483 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
1484 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
1485 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
1486 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
1487
1488 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
1489 COMMAND_EXEC, "print current scan chain configuration");
1490
1491 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
1492 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
1493 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
1494 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
1495 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
1496 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
1497 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
1498 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1499 register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
1500
1501 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
1502 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
1503 return ERROR_OK;
1504 }
1505
1506 int jtag_interface_init(struct command_context_s *cmd_ctx)
1507 {
1508 if (jtag)
1509 return ERROR_OK;
1510
1511 if (!jtag_interface)
1512 {
1513 /* nothing was previously specified by "interface" command */
1514 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1515 return ERROR_JTAG_INVALID_INTERFACE;
1516 }
1517 if(hasKHz)
1518 {
1519 /*stay on "reset speed"*/
1520 jtag_interface->khz(speed1, &jtag_speed);
1521 jtag_interface->khz(speed2, &jtag_speed_post_reset);
1522 hasKHz = 0;
1523 }
1524
1525 if (jtag_interface->init() != ERROR_OK)
1526 return ERROR_JTAG_INIT_FAILED;
1527
1528
1529
1530 jtag = jtag_interface;
1531 return ERROR_OK;
1532 }
1533
1534 static int jtag_init_inner(struct command_context_s *cmd_ctx)
1535 {
1536 int validate_tries = 0;
1537 jtag_device_t *device;
1538 int retval;
1539
1540 LOG_DEBUG("Init JTAG chain");
1541
1542 device = jtag_devices;
1543 jtag_ir_scan_size = 0;
1544 jtag_num_devices = 0;
1545 while (device != NULL)
1546 {
1547 jtag_ir_scan_size += device->ir_length;
1548 jtag_num_devices++;
1549 device = device->next;
1550 }
1551
1552 jtag_add_tlr();
1553 if ((retval=jtag_execute_queue())!=ERROR_OK)
1554 return retval;
1555
1556 /* examine chain first, as this could discover the real chain layout */
1557 if (jtag_examine_chain() != ERROR_OK)
1558 {
1559 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1560 }
1561
1562 while (jtag_validate_chain() != ERROR_OK)
1563 {
1564 validate_tries++;
1565
1566 if (validate_tries > 5)
1567 {
1568 LOG_ERROR("Could not validate JTAG chain, exit");
1569 return ERROR_JTAG_INVALID_INTERFACE;
1570 }
1571 usleep(10000);
1572 }
1573
1574 return ERROR_OK;
1575 }
1576
1577 int jtag_init_reset(struct command_context_s *cmd_ctx)
1578 {
1579 int retval;
1580
1581 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1582 return retval;
1583
1584 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / TLR");
1585
1586 /* Reset can happen after a power cycle.
1587 *
1588 * Ideally we would only assert TRST or run TLR before the target reset.
1589 *
1590 * However w/srst_pulls_trst, trst is asserted together with the target
1591 * reset whether we want it or not.
1592 *
1593 * NB! Some targets have JTAG circuitry disabled until a
1594 * trst & srst has been asserted.
1595 *
1596 * NB! here we assume nsrst/ntrst delay are sufficient!
1597 *
1598 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1599 *
1600 */
1601 jtag_add_reset(1, 0); /* TLR or TRST */
1602 if (jtag_reset_config & RESET_HAS_SRST)
1603 {
1604 jtag_add_reset(1, 1);
1605 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
1606 jtag_add_reset(0, 1);
1607 }
1608 jtag_add_reset(0, 0);
1609 if ((retval = jtag_execute_queue()) != ERROR_OK)
1610 return retval;
1611
1612 /* Check that we can communication on the JTAG chain + eventually we want to
1613 * be able to perform enumeration only after OpenOCD has started
1614 * telnet and GDB server
1615 *
1616 * That would allow users to more easily perform any magic they need to before
1617 * reset happens.
1618 */
1619 return jtag_init_inner(cmd_ctx);
1620 }
1621
1622 int jtag_init(struct command_context_s *cmd_ctx)
1623 {
1624 int retval;
1625 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1626 return retval;
1627 if (jtag_init_inner(cmd_ctx)==ERROR_OK)
1628 {
1629 return ERROR_OK;
1630 }
1631 return jtag_init_reset(cmd_ctx);
1632 }
1633
1634
1635 static int default_khz(int khz, int *jtag_speed)
1636 {
1637 LOG_ERROR("Translation from khz to jtag_speed not implemented");
1638 return ERROR_FAIL;
1639 }
1640
1641 static int default_speed_div(int speed, int *khz)
1642 {
1643 return ERROR_FAIL;
1644 }
1645
1646 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1647 {
1648 int i;
1649
1650 /* check whether the interface is already configured */
1651 if (jtag_interface)
1652 {
1653 LOG_WARNING("Interface already configured, ignoring");
1654 return ERROR_OK;
1655 }
1656
1657 /* interface name is a mandatory argument */
1658 if (argc < 1 || args[0][0] == '\0')
1659 {
1660 return ERROR_COMMAND_SYNTAX_ERROR;
1661 }
1662
1663 for (i=0; jtag_interfaces[i]; i++)
1664 {
1665 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
1666 {
1667 if (jtag_interfaces[i]->register_commands(cmd_ctx) != ERROR_OK)
1668 exit(-1);
1669
1670 jtag_interface = jtag_interfaces[i];
1671
1672 if (jtag_interface->khz == NULL)
1673 {
1674 jtag_interface->khz = default_khz;
1675 }
1676 if (jtag_interface->speed_div == NULL)
1677 {
1678 jtag_interface->speed_div = default_speed_div;
1679 }
1680 return ERROR_OK;
1681 }
1682 }
1683
1684 /* no valid interface was found (i.e. the configuration option,
1685 * didn't match one of the compiled-in interfaces
1686 */
1687 LOG_ERROR("No valid jtag interface found (%s)", args[0]);
1688 LOG_ERROR("compiled-in jtag interfaces:");
1689 for (i = 0; jtag_interfaces[i]; i++)
1690 {
1691 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
1692 }
1693
1694 return ERROR_JTAG_INVALID_INTERFACE;
1695 }
1696
1697 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1698 {
1699 jtag_device_t **last_device_p = &jtag_devices;
1700
1701 if (*last_device_p)
1702 {
1703 while ((*last_device_p)->next)
1704 last_device_p = &((*last_device_p)->next);
1705 last_device_p = &((*last_device_p)->next);
1706 }
1707
1708 if (argc < 3)
1709 return ERROR_OK;
1710
1711 *last_device_p = malloc(sizeof(jtag_device_t));
1712 (*last_device_p)->ir_length = strtoul(args[0], NULL, 0);
1713
1714 (*last_device_p)->expected = malloc((*last_device_p)->ir_length);
1715 buf_set_u32((*last_device_p)->expected, 0, (*last_device_p)->ir_length, strtoul(args[1], NULL, 0));
1716 (*last_device_p)->expected_mask = malloc((*last_device_p)->ir_length);
1717 buf_set_u32((*last_device_p)->expected_mask, 0, (*last_device_p)->ir_length, strtoul(args[2], NULL, 0));
1718
1719 (*last_device_p)->cur_instr = malloc((*last_device_p)->ir_length);
1720 (*last_device_p)->bypass = 1;
1721 buf_set_ones((*last_device_p)->cur_instr, (*last_device_p)->ir_length);
1722
1723 (*last_device_p)->next = NULL;
1724
1725 jtag_register_event_callback(jtag_reset_callback, (*last_device_p));
1726
1727 jtag_num_devices++;
1728
1729 return ERROR_OK;
1730 }
1731
1732 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1733 {
1734 jtag_device_t *device = jtag_devices;
1735 int device_count = 0;
1736
1737 while (device)
1738 {
1739 u32 expected, expected_mask, cur_instr;
1740 expected = buf_get_u32(device->expected, 0, device->ir_length);
1741 expected_mask = buf_get_u32(device->expected_mask, 0, device->ir_length);
1742 cur_instr = buf_get_u32(device->cur_instr, 0, device->ir_length);
1743 command_print(cmd_ctx, "%i: idcode: 0x%8.8x ir length %i, ir capture 0x%x, ir mask 0x%x, current instruction 0x%x", device_count, device->idcode, device->ir_length, expected, expected_mask, cur_instr);
1744 device = device->next;
1745 device_count++;
1746 }
1747
1748 return ERROR_OK;
1749 }
1750
1751 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1752 {
1753 if (argc < 1)
1754 return ERROR_COMMAND_SYNTAX_ERROR;
1755
1756 if (argc >= 1)
1757 {
1758 if (strcmp(args[0], "none") == 0)
1759 jtag_reset_config = RESET_NONE;
1760 else if (strcmp(args[0], "trst_only") == 0)
1761 jtag_reset_config = RESET_HAS_TRST;
1762 else if (strcmp(args[0], "srst_only") == 0)
1763 jtag_reset_config = RESET_HAS_SRST;
1764 else if (strcmp(args[0], "trst_and_srst") == 0)
1765 jtag_reset_config = RESET_TRST_AND_SRST;
1766 else
1767 {
1768 LOG_ERROR("invalid reset_config argument, defaulting to none");
1769 jtag_reset_config = RESET_NONE;
1770 return ERROR_INVALID_ARGUMENTS;
1771 }
1772 }
1773
1774 if (argc >= 2)
1775 {
1776 if (strcmp(args[1], "separate") == 0)
1777 {
1778 /* seperate reset lines - default */
1779 } else
1780 {
1781 if (strcmp(args[1], "srst_pulls_trst") == 0)
1782 jtag_reset_config |= RESET_SRST_PULLS_TRST;
1783 else if (strcmp(args[1], "trst_pulls_srst") == 0)
1784 jtag_reset_config |= RESET_TRST_PULLS_SRST;
1785 else if (strcmp(args[1], "combined") == 0)
1786 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
1787 else
1788 {
1789 LOG_ERROR("invalid reset_config argument, defaulting to none");
1790 jtag_reset_config = RESET_NONE;
1791 return ERROR_INVALID_ARGUMENTS;
1792 }
1793 }
1794 }
1795
1796 if (argc >= 3)
1797 {
1798 if (strcmp(args[2], "trst_open_drain") == 0)
1799 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
1800 else if (strcmp(args[2], "trst_push_pull") == 0)
1801 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
1802 else
1803 {
1804 LOG_ERROR("invalid reset_config argument, defaulting to none");
1805 jtag_reset_config = RESET_NONE;
1806 return ERROR_INVALID_ARGUMENTS;
1807 }
1808 }
1809
1810 if (argc >= 4)
1811 {
1812 if (strcmp(args[3], "srst_push_pull") == 0)
1813 jtag_reset_config |= RESET_SRST_PUSH_PULL;
1814 else if (strcmp(args[3], "srst_open_drain") == 0)
1815 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
1816 else
1817 {
1818 LOG_ERROR("invalid reset_config argument, defaulting to none");
1819 jtag_reset_config = RESET_NONE;
1820 return ERROR_INVALID_ARGUMENTS;
1821 }
1822 }
1823
1824 return ERROR_OK;
1825 }
1826
1827 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1828 {
1829 if (argc < 1)
1830 {
1831 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1832 exit(-1);
1833 }
1834 else
1835 {
1836 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
1837 }
1838
1839 return ERROR_OK;
1840 }
1841
1842 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1843 {
1844 if (argc < 1)
1845 {
1846 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1847 exit(-1);
1848 }
1849 else
1850 {
1851 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
1852 }
1853
1854 return ERROR_OK;
1855 }
1856
1857 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1858 {
1859 int cur_speed = 0;
1860
1861 if (argc != 0)
1862 {
1863 if ((argc<1) || (argc>2))
1864 return ERROR_COMMAND_SYNTAX_ERROR;
1865
1866 LOG_DEBUG("handle jtag speed");
1867
1868 if (argc >= 1)
1869 cur_speed = jtag_speed = jtag_speed_post_reset = strtoul(args[0], NULL, 0);
1870 if (argc == 2)
1871 cur_speed = jtag_speed_post_reset = strtoul(args[1], NULL, 0);
1872
1873 /* this command can be called during CONFIG,
1874 * in which case jtag isn't initialized */
1875 if (jtag)
1876 {
1877 jtag->speed_div(jtag_speed, &speed1);
1878 jtag->speed_div(jtag_speed_post_reset, &speed2);
1879 jtag->speed(cur_speed);
1880 }
1881 }
1882 command_print(cmd_ctx, "jtag_speed: %d, %d", jtag_speed, jtag_speed_post_reset);
1883
1884 return ERROR_OK;
1885 }
1886
1887 int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1888 {
1889 LOG_DEBUG("handle jtag khz");
1890
1891 if (argc>2)
1892 return ERROR_COMMAND_SYNTAX_ERROR;
1893
1894 if(argc != 0)
1895 {
1896
1897 if (argc >= 1)
1898 speed1 = speed2 = strtoul(args[0], NULL, 0);
1899 if (argc == 2)
1900 speed2 = strtoul(args[1], NULL, 0);
1901
1902 if (jtag != NULL)
1903 {
1904 int cur_speed = 0;
1905 LOG_DEBUG("have interface set up");
1906 int speed_div1, speed_div2;
1907 if (jtag->khz(speed1, &speed_div1)!=ERROR_OK)
1908 {
1909 speed1 = speed2 = 0;
1910 return ERROR_OK;
1911 }
1912 if (jtag->khz(speed2, &speed_div2)!=ERROR_OK)
1913 {
1914 speed1 = speed2 = 0;
1915 return ERROR_OK;
1916 }
1917
1918 if (argc >= 1)
1919 cur_speed = jtag_speed = jtag_speed_post_reset = speed_div1;
1920 if (argc == 2)
1921 cur_speed = jtag_speed_post_reset = speed_div2;
1922
1923 jtag->speed(cur_speed);
1924 } else
1925 {
1926 hasKHz = 1;
1927 }
1928 }
1929 command_print(cmd_ctx, "jtag_khz: %d, %d", speed1, speed2);
1930
1931 return ERROR_OK;
1932 }
1933
1934
1935 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1936 {
1937 enum tap_state state;
1938
1939 if (argc < 1)
1940 {
1941 return ERROR_COMMAND_SYNTAX_ERROR;
1942 }
1943 else
1944 {
1945 for (state = 0; state < 16; state++)
1946 {
1947 if (strcmp(args[0], tap_state_strings[state]) == 0)
1948 {
1949 jtag_add_end_state(state);
1950 jtag_execute_queue();
1951 }
1952 }
1953 }
1954 command_print(cmd_ctx, "current endstate: %s", tap_state_strings[cmd_queue_end_state]);
1955
1956 return ERROR_OK;
1957 }
1958
1959 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1960 {
1961 int trst = -1;
1962 int srst = -1;
1963
1964 if (argc < 2)
1965 {
1966 return ERROR_COMMAND_SYNTAX_ERROR;
1967 }
1968
1969 if (args[0][0] == '1')
1970 trst = 1;
1971 else if (args[0][0] == '0')
1972 trst = 0;
1973 else
1974 {
1975 return ERROR_COMMAND_SYNTAX_ERROR;
1976 }
1977
1978 if (args[1][0] == '1')
1979 srst = 1;
1980 else if (args[1][0] == '0')
1981 srst = 0;
1982 else
1983 {
1984 return ERROR_COMMAND_SYNTAX_ERROR;
1985 }
1986
1987 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
1988 return ERROR_JTAG_INIT_FAILED;
1989
1990 jtag_add_reset(trst, srst);
1991 jtag_execute_queue();
1992
1993 return ERROR_OK;
1994 }
1995
1996 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1997 {
1998 if (argc < 1)
1999 {
2000 return ERROR_COMMAND_SYNTAX_ERROR;
2001 }
2002
2003 jtag_add_runtest(strtol(args[0], NULL, 0), -1);
2004 jtag_execute_queue();
2005
2006 return ERROR_OK;
2007
2008 }
2009
2010
2011 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2012 {
2013 int i;
2014 scan_field_t *fields;
2015
2016 if ((argc < 2) || (argc % 2))
2017 {
2018 return ERROR_COMMAND_SYNTAX_ERROR;
2019 }
2020
2021 fields = malloc(sizeof(scan_field_t) * argc / 2);
2022
2023 for (i = 0; i < argc / 2; i++)
2024 {
2025 int device = strtoul(args[i*2], NULL, 0);
2026 int field_size = jtag_get_device(device)->ir_length;
2027 fields[i].device = device;
2028 fields[i].out_value = malloc(CEIL(field_size, 8));
2029 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2030 fields[i].out_mask = NULL;
2031 fields[i].in_value = NULL;
2032 fields[i].in_check_mask = NULL;
2033 fields[i].in_handler = NULL;
2034 fields[i].in_handler_priv = NULL;
2035 }
2036
2037 jtag_add_ir_scan(argc / 2, fields, -1);
2038 jtag_execute_queue();
2039
2040 for (i = 0; i < argc / 2; i++)
2041 free(fields[i].out_value);
2042
2043 free (fields);
2044
2045 return ERROR_OK;
2046 }
2047
2048 int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2049 {
2050 int retval;
2051 scan_field_t *fields;
2052 int num_fields;
2053 int field_count = 0;
2054 int i, j, e;
2055 long device;
2056
2057 /* args[1] = device
2058 * args[2] = num_bits
2059 * args[3] = hex string
2060 * ... repeat num bits and hex string ...
2061 */
2062 if ((argc < 4) || ((argc % 2)!=0))
2063 {
2064 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2065 return JIM_ERR;
2066 }
2067
2068 for (i = 2; i < argc; i+=2)
2069 {
2070 long bits;
2071
2072 e = Jim_GetLong(interp, args[i], &bits);
2073 if (e != JIM_OK)
2074 return e;
2075 }
2076
2077 e = Jim_GetLong(interp, args[1], &device);
2078 if (e != JIM_OK)
2079 return e;
2080
2081 num_fields=(argc-2)/2;
2082 fields = malloc(sizeof(scan_field_t) * num_fields);
2083 for (i = 2; i < argc; i+=2)
2084 {
2085 long bits;
2086 int len;
2087 const char *str;
2088
2089 Jim_GetLong(interp, args[i], &bits);
2090 str = Jim_GetString(args[i+1], &len);
2091
2092 fields[field_count].device = device;
2093 fields[field_count].num_bits = bits;
2094 fields[field_count].out_value = malloc(CEIL(bits, 8));
2095 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2096 fields[field_count].out_mask = NULL;
2097 fields[field_count].in_value = fields[field_count].out_value;
2098 fields[field_count].in_check_mask = NULL;
2099 fields[field_count].in_check_value = NULL;
2100 fields[field_count].in_handler = NULL;
2101 fields[field_count++].in_handler_priv = NULL;
2102 }
2103
2104 jtag_add_dr_scan(num_fields, fields, -1);
2105 retval = jtag_execute_queue();
2106 if (retval != ERROR_OK)
2107 {
2108 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2109 Jim_AppendStrings(interp, Jim_GetResult(interp), "drscan: jtag execute failed", NULL);
2110 return JIM_ERR;
2111 }
2112
2113 field_count=0;
2114 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2115 for (i = 2; i < argc; i+=2)
2116 {
2117 long bits;
2118 char *str;
2119
2120 Jim_GetLong(interp, args[i], &bits);
2121 str = buf_to_str(fields[field_count].in_value, bits, 16);
2122 free(fields[field_count].out_value);
2123
2124 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
2125 free(str);
2126 field_count++;
2127 }
2128
2129 Jim_SetResult(interp, list);
2130
2131 free(fields);
2132
2133 return JIM_OK;
2134 }
2135
2136 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2137 {
2138 if (argc == 1)
2139 {
2140 if (strcmp(args[0], "enable") == 0)
2141 {
2142 jtag_verify_capture_ir = 1;
2143 }
2144 else if (strcmp(args[0], "disable") == 0)
2145 {
2146 jtag_verify_capture_ir = 0;
2147 } else
2148 {
2149 return ERROR_COMMAND_SYNTAX_ERROR;
2150 }
2151 } else if (argc != 0)
2152 {
2153 return ERROR_COMMAND_SYNTAX_ERROR;
2154 }
2155
2156 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
2157
2158 return ERROR_OK;
2159 }
Open On-Chip Debugger

Linking to existing account procedure

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

SSH host keys fingerprints

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