zy1000: add version command to print FPGA version and timestamps
[openocd.git] / src / jtag / zy1000 / zy1000.c
1 /***************************************************************************
2 * Copyright (C) 2007-2008 by √ėyvind Harboe *
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 #ifdef HAVE_CONFIG_H
20 #include "config.h"
21 #endif
22
23 #include "embeddedice.h"
24 #include "minidriver.h"
25 #include "interface.h"
26 #include "zy1000_version.h"
27
28 #include <cyg/hal/hal_io.h> // low level i/o
29 #include <cyg/hal/hal_diag.h>
30
31 #include <time.h>
32
33 #define ZYLIN_VERSION GIT_ZY1000_VERSION
34 #define ZYLIN_DATE __DATE__
35 #define ZYLIN_TIME __TIME__
36 #define ZYLIN_OPENOCD GIT_OPENOCD_VERSION
37 #define ZYLIN_OPENOCD_VERSION "ZY1000 " ZYLIN_VERSION " " ZYLIN_DATE
38
39 /* low level command set
40 */
41 void zy1000_reset(int trst, int srst);
42
43
44 int zy1000_speed(int speed);
45 int zy1000_register_commands(struct command_context *cmd_ctx);
46 int zy1000_init(void);
47 int zy1000_quit(void);
48
49 /* interface commands */
50 int zy1000_handle_zy1000_port_command(struct command_context *cmd_ctx, char *cmd, char **args, int argc);
51
52 static int zy1000_khz(int khz, int *jtag_speed)
53 {
54 if (khz == 0)
55 {
56 *jtag_speed = 0;
57 }
58 else
59 {
60 *jtag_speed = 64000/khz;
61 }
62 return ERROR_OK;
63 }
64
65 static int zy1000_speed_div(int speed, int *khz)
66 {
67 if (speed == 0)
68 {
69 *khz = 0;
70 }
71 else
72 {
73 *khz = 64000/speed;
74 }
75
76 return ERROR_OK;
77 }
78
79 static bool readPowerDropout(void)
80 {
81 cyg_uint32 state;
82 // sample and clear power dropout
83 HAL_WRITE_UINT32(ZY1000_JTAG_BASE + 0x10, 0x80);
84 HAL_READ_UINT32(ZY1000_JTAG_BASE + 0x10, state);
85 bool powerDropout;
86 powerDropout = (state & 0x80) != 0;
87 return powerDropout;
88 }
89
90
91 static bool readSRST(void)
92 {
93 cyg_uint32 state;
94 // sample and clear SRST sensing
95 HAL_WRITE_UINT32(ZY1000_JTAG_BASE + 0x10, 0x00000040);
96 HAL_READ_UINT32(ZY1000_JTAG_BASE + 0x10, state);
97 bool srstAsserted;
98 srstAsserted = (state & 0x40) != 0;
99 return srstAsserted;
100 }
101
102 static int zy1000_srst_asserted(int *srst_asserted)
103 {
104 *srst_asserted = readSRST();
105 return ERROR_OK;
106 }
107
108 static int zy1000_power_dropout(int *dropout)
109 {
110 *dropout = readPowerDropout();
111 return ERROR_OK;
112 }
113
114
115 struct jtag_interface zy1000_interface =
116 {
117 .name = "ZY1000",
118 .execute_queue = NULL,
119 .speed = zy1000_speed,
120 .register_commands = zy1000_register_commands,
121 .init = zy1000_init,
122 .quit = zy1000_quit,
123 .khz = zy1000_khz,
124 .speed_div = zy1000_speed_div,
125 .power_dropout = zy1000_power_dropout,
126 .srst_asserted = zy1000_srst_asserted,
127 };
128
129 void zy1000_reset(int trst, int srst)
130 {
131 LOG_DEBUG("zy1000 trst=%d, srst=%d", trst, srst);
132 if (!srst)
133 {
134 ZY1000_POKE(ZY1000_JTAG_BASE + 0x14, 0x00000001);
135 }
136 else
137 {
138 /* Danger!!! if clk != 0 when in
139 * idle in TAP_IDLE, reset halt on str912 will fail.
140 */
141 ZY1000_POKE(ZY1000_JTAG_BASE + 0x10, 0x00000001);
142 }
143
144 if (!trst)
145 {
146 ZY1000_POKE(ZY1000_JTAG_BASE + 0x14, 0x00000002);
147 }
148 else
149 {
150 /* assert reset */
151 ZY1000_POKE(ZY1000_JTAG_BASE + 0x10, 0x00000002);
152 }
153
154 if (trst||(srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
155 {
156 waitIdle();
157 /* we're now in the RESET state until trst is deasserted */
158 ZY1000_POKE(ZY1000_JTAG_BASE + 0x20, TAP_RESET);
159 } else
160 {
161 /* We'll get RCLK failure when we assert TRST, so clear any false positives here */
162 ZY1000_POKE(ZY1000_JTAG_BASE + 0x14, 0x400);
163 }
164
165 /* wait for srst to float back up */
166 if (!srst)
167 {
168 int i;
169 for (i = 0; i < 1000; i++)
170 {
171 // We don't want to sense our own reset, so we clear here.
172 // There is of course a timing hole where we could loose
173 // a "real" reset.
174 if (!readSRST())
175 break;
176
177 /* wait 1ms */
178 alive_sleep(1);
179 }
180
181 if (i == 1000)
182 {
183 LOG_USER("SRST didn't deassert after %dms", i);
184 } else if (i > 1)
185 {
186 LOG_USER("SRST took %dms to deassert", i);
187 }
188 }
189 }
190
191 int zy1000_speed(int speed)
192 {
193 if (speed == 0)
194 {
195 /*0 means RCLK*/
196 speed = 0;
197 ZY1000_POKE(ZY1000_JTAG_BASE + 0x10, 0x100);
198 LOG_DEBUG("jtag_speed using RCLK");
199 }
200 else
201 {
202 if (speed > 8190 || speed < 2)
203 {
204 LOG_USER("valid ZY1000 jtag_speed=[8190,2]. Divisor is 64MHz / even values between 8190-2, i.e. min 7814Hz, max 32MHz");
205 return ERROR_INVALID_ARGUMENTS;
206 }
207
208 LOG_USER("jtag_speed %d => JTAG clk=%f", speed, 64.0/(float)speed);
209 ZY1000_POKE(ZY1000_JTAG_BASE + 0x14, 0x100);
210 ZY1000_POKE(ZY1000_JTAG_BASE + 0x1c, speed&~1);
211 }
212 return ERROR_OK;
213 }
214
215 static bool savePower;
216
217
218 static void setPower(bool power)
219 {
220 savePower = power;
221 if (power)
222 {
223 HAL_WRITE_UINT32(ZY1000_JTAG_BASE + 0x14, 0x8);
224 } else
225 {
226 HAL_WRITE_UINT32(ZY1000_JTAG_BASE + 0x10, 0x8);
227 }
228 }
229
230 int handle_power_command(struct command_context *cmd_ctx, char *cmd, char **args, int argc)
231 {
232 if (argc > 1)
233 {
234 return ERROR_INVALID_ARGUMENTS;
235 }
236
237 if (argc == 1)
238 {
239 if (strcmp(args[0], "on") == 0)
240 {
241 setPower(1);
242 }
243 else if (strcmp(args[0], "off") == 0)
244 {
245 setPower(0);
246 } else
247 {
248 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
249 return ERROR_INVALID_ARGUMENTS;
250 }
251 }
252
253 command_print(cmd_ctx, "Target power %s", savePower ? "on" : "off");
254
255 return ERROR_OK;
256 }
257
258
259 /* Give TELNET a way to find out what version this is */
260 static int jim_zy1000_version(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
261 {
262 if ((argc < 1) || (argc > 3))
263 return JIM_ERR;
264 const char *version_str = NULL;
265
266 if (argc == 1)
267 {
268 version_str = ZYLIN_OPENOCD_VERSION;
269 } else
270 {
271 const char *str = Jim_GetString(argv[1], NULL);
272 const char *str2 = NULL;
273 if (argc > 2)
274 str2 = Jim_GetString(argv[2], NULL);
275 if (strcmp("openocd", str) == 0)
276 {
277 version_str = ZYLIN_OPENOCD;
278 }
279 else if (strcmp("zy1000", str) == 0)
280 {
281 version_str = ZYLIN_VERSION;
282 }
283 else if (strcmp("date", str) == 0)
284 {
285 version_str = ZYLIN_DATE;
286 }
287 else if (strcmp("time", str) == 0)
288 {
289 version_str = ZYLIN_TIME;
290 }
291 else if (strcmp("pcb", str) == 0)
292 {
293 #ifdef CYGPKG_HAL_NIOS2
294 version_str="c";
295 #else
296 version_str="b";
297 #endif
298 }
299 #ifdef CYGPKG_HAL_NIOS2
300 else if (strcmp("fpga", str) == 0)
301 {
302
303 /* return a list of 32 bit integers to describe the expected
304 * and actual FPGA
305 */
306 static char *fpga_id = "0x12345678 0x12345678 0x12345678 0x12345678";
307 cyg_uint32 id, timestamp;
308 HAL_READ_UINT32(SYSID_BASE, id);
309 HAL_READ_UINT32(SYSID_BASE+4, timestamp);
310 sprintf(fpga_id, "0x%08x 0x%08x 0x%08x 0x%08x", id, timestamp, SYSID_ID, SYSID_TIMESTAMP);
311 version_str = fpga_id;
312 if ((argc>2) && (strcmp("time", str2) == 0))
313 {
314 time_t last_mod = timestamp;
315 char * t = ctime (&last_mod) ;
316 t[strlen(t)-1] = 0;
317 version_str = t;
318 }
319 }
320 #endif
321
322 else
323 {
324 return JIM_ERR;
325 }
326 }
327
328 Jim_SetResult(interp, Jim_NewStringObj(interp, version_str, -1));
329
330 return JIM_OK;
331 }
332
333
334 #ifdef CYGPKG_HAL_NIOS2
335 static int jim_zy1000_writefirmware(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
336 {
337 if (argc != 2)
338 return JIM_ERR;
339
340 int length;
341 int stat;
342 const char *str = Jim_GetString(argv[1], &length);
343
344 /* BUG!!!! skip header! */
345 void *firmware_address=0x4000000;
346 int firmware_length=0x100000;
347
348 if (length>firmware_length)
349 return JIM_ERR;
350
351 void *err_addr;
352
353 if ((stat = flash_erase((void *)firmware_address, firmware_length, (void **)&err_addr)) != 0)
354 {
355 return JIM_ERR;
356 }
357
358 if ((stat = flash_program(firmware_address, str, length, (void **)&err_addr)) != 0)
359 return JIM_ERR;
360
361 return JIM_OK;
362 }
363 #endif
364
365 static int
366 zylinjtag_Jim_Command_powerstatus(Jim_Interp *interp,
367 int argc,
368 Jim_Obj * const *argv)
369 {
370 if (argc != 1)
371 {
372 Jim_WrongNumArgs(interp, 1, argv, "powerstatus");
373 return JIM_ERR;
374 }
375
376 cyg_uint32 status;
377 ZY1000_PEEK(ZY1000_JTAG_BASE + 0x10, status);
378
379 Jim_SetResult(interp, Jim_NewIntObj(interp, (status&0x80) != 0));
380
381 return JIM_OK;
382 }
383
384 int zy1000_register_commands(struct command_context *cmd_ctx)
385 {
386 register_command(cmd_ctx, NULL, "power", handle_power_command, COMMAND_ANY,
387 "power <on/off> - turn power switch to target on/off. No arguments - print status.");
388
389 Jim_CreateCommand(interp, "zy1000_version", jim_zy1000_version, NULL, NULL);
390
391
392 Jim_CreateCommand(interp, "powerstatus", zylinjtag_Jim_Command_powerstatus, NULL, NULL);
393
394 #ifdef CYGPKG_HAL_NIOS2
395 Jim_CreateCommand(interp, "updatezy1000firmware", jim_zy1000_writefirmware, NULL, NULL);
396 #endif
397
398
399 return ERROR_OK;
400 }
401
402
403
404
405 int zy1000_init(void)
406 {
407 LOG_USER("%s", ZYLIN_OPENOCD_VERSION);
408
409 ZY1000_POKE(ZY1000_JTAG_BASE + 0x10, 0x30); // Turn on LED1 & LED2
410
411 setPower(true); // on by default
412
413
414 /* deassert resets. Important to avoid infinite loop waiting for SRST to deassert */
415 zy1000_reset(0, 0);
416 zy1000_speed(jtag_get_speed());
417
418 return ERROR_OK;
419 }
420
421 int zy1000_quit(void)
422 {
423
424 return ERROR_OK;
425 }
426
427
428
429 int interface_jtag_execute_queue(void)
430 {
431 cyg_uint32 empty;
432
433 waitIdle();
434 ZY1000_PEEK(ZY1000_JTAG_BASE + 0x10, empty);
435 /* clear JTAG error register */
436 ZY1000_POKE(ZY1000_JTAG_BASE + 0x14, 0x400);
437
438 if ((empty&0x400) != 0)
439 {
440 LOG_WARNING("RCLK timeout");
441 /* the error is informative only as we don't want to break the firmware if there
442 * is a false positive.
443 */
444 // return ERROR_FAIL;
445 }
446 return ERROR_OK;
447 }
448
449
450
451
452
453 static cyg_uint32 getShiftValue(void)
454 {
455 cyg_uint32 value;
456 waitIdle();
457 ZY1000_PEEK(ZY1000_JTAG_BASE + 0xc, value);
458 VERBOSE(LOG_INFO("getShiftValue %08x", value));
459 return value;
460 }
461 #if 0
462 static cyg_uint32 getShiftValueFlip(void)
463 {
464 cyg_uint32 value;
465 waitIdle();
466 ZY1000_PEEK(ZY1000_JTAG_BASE + 0x18, value);
467 VERBOSE(LOG_INFO("getShiftValue %08x (flipped)", value));
468 return value;
469 }
470 #endif
471
472 #if 0
473 static void shiftValueInnerFlip(const tap_state_t state, const tap_state_t endState, int repeat, cyg_uint32 value)
474 {
475 VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_name(state), tap_state_name(endState), repeat, value));
476 cyg_uint32 a,b;
477 a = state;
478 b = endState;
479 ZY1000_POKE(ZY1000_JTAG_BASE + 0xc, value);
480 ZY1000_POKE(ZY1000_JTAG_BASE + 0x8, (1 << 15) | (repeat << 8) | (a << 4) | b);
481 VERBOSE(getShiftValueFlip());
482 }
483 #endif
484
485 static void gotoEndState(tap_state_t end_state)
486 {
487 setCurrentState(end_state);
488 }
489
490 static __inline void scanFields(int num_fields, const struct scan_field *fields, tap_state_t shiftState, int pause)
491 {
492 int i;
493 int j;
494 int k;
495
496 for (i = 0; i < num_fields; i++)
497 {
498 cyg_uint32 value;
499
500 uint8_t *inBuffer = NULL;
501
502
503 // figure out where to store the input data
504 int num_bits = fields[i].num_bits;
505 if (fields[i].in_value != NULL)
506 {
507 inBuffer = fields[i].in_value;
508 }
509
510 // here we shuffle N bits out/in
511 j = 0;
512 while (j < num_bits)
513 {
514 tap_state_t pause_state;
515 int l;
516 k = num_bits-j;
517 pause_state = (shiftState == TAP_DRSHIFT)?TAP_DRSHIFT:TAP_IRSHIFT;
518 if (k > 32)
519 {
520 k = 32;
521 /* we have more to shift out */
522 } else if (pause&&(i == num_fields-1))
523 {
524 /* this was the last to shift out this time */
525 pause_state = (shiftState==TAP_DRSHIFT)?TAP_DRPAUSE:TAP_IRPAUSE;
526 }
527
528 // we have (num_bits + 7)/8 bytes of bits to toggle out.
529 // bits are pushed out LSB to MSB
530 value = 0;
531 if (fields[i].out_value != NULL)
532 {
533 for (l = 0; l < k; l += 8)
534 {
535 value|=fields[i].out_value[(j + l)/8]<<l;
536 }
537 }
538 /* mask away unused bits for easier debugging */
539 if (k < 32)
540 {
541 value&=~(((uint32_t)0xffffffff) << k);
542 } else
543 {
544 /* Shifting by >= 32 is not defined by the C standard
545 * and will in fact shift by &0x1f bits on nios */
546 }
547
548 shiftValueInner(shiftState, pause_state, k, value);
549
550 if (inBuffer != NULL)
551 {
552 // data in, LSB to MSB
553 value = getShiftValue();
554 // we're shifting in data to MSB, shift data to be aligned for returning the value
555 value >>= 32-k;
556
557 for (l = 0; l < k; l += 8)
558 {
559 inBuffer[(j + l)/8]=(value >> l)&0xff;
560 }
561 }
562 j += k;
563 }
564 }
565 }
566
567 int interface_jtag_add_ir_scan(int num_fields, const struct scan_field *fields, tap_state_t state)
568 {
569
570 int j;
571 int scan_size = 0;
572 struct jtag_tap *tap, *nextTap;
573 for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap = nextTap)
574 {
575 nextTap = jtag_tap_next_enabled(tap);
576 int pause = (nextTap==NULL);
577
578 int found = 0;
579
580 scan_size = tap->ir_length;
581
582 /* search the list */
583 for (j = 0; j < num_fields; j++)
584 {
585 if (tap == fields[j].tap)
586 {
587 found = 1;
588
589 scanFields(1, fields + j, TAP_IRSHIFT, pause);
590 /* update device information */
591 buf_cpy(fields[j].out_value, tap->cur_instr, scan_size);
592
593 tap->bypass = 0;
594 break;
595 }
596 }
597
598 if (!found)
599 {
600 /* if a device isn't listed, set it to BYPASS */
601 uint8_t ones[]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
602
603 struct scan_field tmp;
604 memset(&tmp, 0, sizeof(tmp));
605 tmp.out_value = ones;
606 tmp.num_bits = scan_size;
607 scanFields(1, &tmp, TAP_IRSHIFT, pause);
608 /* update device information */
609 buf_cpy(tmp.out_value, tap->cur_instr, scan_size);
610 tap->bypass = 1;
611 }
612 }
613 gotoEndState(state);
614
615 return ERROR_OK;
616 }
617
618
619
620
621
622 int interface_jtag_add_plain_ir_scan(int num_fields, const struct scan_field *fields, tap_state_t state)
623 {
624 scanFields(num_fields, fields, TAP_IRSHIFT, 1);
625 gotoEndState(state);
626
627 return ERROR_OK;
628 }
629
630 int interface_jtag_add_dr_scan(int num_fields, const struct scan_field *fields, tap_state_t state)
631 {
632
633 int j;
634 struct jtag_tap *tap, *nextTap;
635 for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap = nextTap)
636 {
637 nextTap = jtag_tap_next_enabled(tap);
638 int found = 0;
639 int pause = (nextTap==NULL);
640
641 for (j = 0; j < num_fields; j++)
642 {
643 if (tap == fields[j].tap)
644 {
645 found = 1;
646
647 scanFields(1, fields+j, TAP_DRSHIFT, pause);
648 }
649 }
650 if (!found)
651 {
652 struct scan_field tmp;
653 /* program the scan field to 1 bit length, and ignore it's value */
654 tmp.num_bits = 1;
655 tmp.out_value = NULL;
656 tmp.in_value = NULL;
657
658 scanFields(1, &tmp, TAP_DRSHIFT, pause);
659 }
660 else
661 {
662 }
663 }
664 gotoEndState(state);
665 return ERROR_OK;
666 }
667
668 int interface_jtag_add_plain_dr_scan(int num_fields, const struct scan_field *fields, tap_state_t state)
669 {
670 scanFields(num_fields, fields, TAP_DRSHIFT, 1);
671 gotoEndState(state);
672 return ERROR_OK;
673 }
674
675
676 int interface_jtag_add_tlr()
677 {
678 setCurrentState(TAP_RESET);
679 return ERROR_OK;
680 }
681
682
683
684
685 int interface_jtag_add_reset(int req_trst, int req_srst)
686 {
687 zy1000_reset(req_trst, req_srst);
688 return ERROR_OK;
689 }
690
691 static int zy1000_jtag_add_clocks(int num_cycles, tap_state_t state, tap_state_t clockstate)
692 {
693 /* num_cycles can be 0 */
694 setCurrentState(clockstate);
695
696 /* execute num_cycles, 32 at the time. */
697 int i;
698 for (i = 0; i < num_cycles; i += 32)
699 {
700 int num;
701 num = 32;
702 if (num_cycles-i < num)
703 {
704 num = num_cycles-i;
705 }
706 shiftValueInner(clockstate, clockstate, num, 0);
707 }
708
709 #if !TEST_MANUAL()
710 /* finish in end_state */
711 setCurrentState(state);
712 #else
713 tap_state_t t = TAP_IDLE;
714 /* test manual drive code on any target */
715 int tms;
716 uint8_t tms_scan = tap_get_tms_path(t, state);
717 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
718
719 for (i = 0; i < tms_count; i++)
720 {
721 tms = (tms_scan >> i) & 1;
722 waitIdle();
723 ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, tms);
724 }
725 waitIdle();
726 ZY1000_POKE(ZY1000_JTAG_BASE + 0x20, state);
727 #endif
728
729
730 return ERROR_OK;
731 }
732
733 int interface_jtag_add_runtest(int num_cycles, tap_state_t state)
734 {
735 return zy1000_jtag_add_clocks(num_cycles, state, TAP_IDLE);
736 }
737
738 int interface_jtag_add_clocks(int num_cycles)
739 {
740 return zy1000_jtag_add_clocks(num_cycles, cmd_queue_cur_state, cmd_queue_cur_state);
741 }
742
743 int interface_jtag_add_sleep(uint32_t us)
744 {
745 jtag_sleep(us);
746 return ERROR_OK;
747 }
748
749 int interface_jtag_add_pathmove(int num_states, const tap_state_t *path)
750 {
751 int state_count;
752 int tms = 0;
753
754 /*wait for the fifo to be empty*/
755 waitIdle();
756
757 state_count = 0;
758
759 tap_state_t cur_state = cmd_queue_cur_state;
760
761 while (num_states)
762 {
763 if (tap_state_transition(cur_state, false) == path[state_count])
764 {
765 tms = 0;
766 }
767 else if (tap_state_transition(cur_state, true) == path[state_count])
768 {
769 tms = 1;
770 }
771 else
772 {
773 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[state_count]));
774 exit(-1);
775 }
776
777 waitIdle();
778 ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, tms);
779
780 cur_state = path[state_count];
781 state_count++;
782 num_states--;
783 }
784
785 waitIdle();
786 ZY1000_POKE(ZY1000_JTAG_BASE + 0x20, cur_state);
787 return ERROR_OK;
788 }
789
790
791
792 void embeddedice_write_dcc(struct jtag_tap *tap, int reg_addr, uint8_t *buffer, int little, int count)
793 {
794 // static int const reg_addr = 0x5;
795 tap_state_t end_state = jtag_get_end_state();
796 if (jtag_tap_next_enabled(jtag_tap_next_enabled(NULL)) == NULL)
797 {
798 /* better performance via code duplication */
799 if (little)
800 {
801 int i;
802 for (i = 0; i < count; i++)
803 {
804 shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, 1));
805 shiftValueInner(TAP_DRSHIFT, end_state, 6, reg_addr | (1 << 5));
806 buffer += 4;
807 }
808 } else
809 {
810 int i;
811 for (i = 0; i < count; i++)
812 {
813 shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, 0));
814 shiftValueInner(TAP_DRSHIFT, end_state, 6, reg_addr | (1 << 5));
815 buffer += 4;
816 }
817 }
818 }
819 else
820 {
821 int i;
822 for (i = 0; i < count; i++)
823 {
824 embeddedice_write_reg_inner(tap, reg_addr, fast_target_buffer_get_u32(buffer, little));
825 buffer += 4;
826 }
827 }
828 }
829
830

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)