zy1000.c 16.1 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/***************************************************************************
 *   Copyright (C) 2007-2008 by yvind Harboe                              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

23
#include "embeddedice.h"
zwelch's avatar
zwelch committed
24
#include "minidriver.h"
25
#include "interface.h"
26
27
28
29
30

#include <cyg/hal/hal_io.h>             // low level i/o
#include <cyg/hal/hal_diag.h>


oharboe's avatar
oharboe committed
31
#define ZYLIN_VERSION "1.52"
32
33
#define ZYLIN_DATE __DATE__
#define ZYLIN_TIME __TIME__
oharboe's avatar
oharboe committed
34
#define ZYLIN_OPENOCD "$Revision$"
35
#define ZYLIN_OPENOCD_VERSION "Zylin JTAG ZY1000 " ZYLIN_VERSION " " ZYLIN_DATE " " ZYLIN_TIME
36
37
38

/* low level command set
 */
39
void zy1000_reset(int trst, int srst);
40
41


42
43
44
45
int zy1000_speed(int speed);
int zy1000_register_commands(struct command_context_s *cmd_ctx);
int zy1000_init(void);
int zy1000_quit(void);
46
47

/* interface commands */
48
int zy1000_handle_zy1000_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
49

50
static int zy1000_khz(int khz, int *jtag_speed)
51
52
53
54
55
56
57
58
59
60
61
62
{
	if (khz==0)
	{
		*jtag_speed=0;
	}
	else
	{
		*jtag_speed=64000/khz;
	}
	return ERROR_OK;
}

63
static int zy1000_speed_div(int speed, int *khz)
64
65
66
67
68
69
70
71
72
73
74
75
76
{
	if (speed==0)
	{
		*khz = 0;
	}
	else
	{
		*khz=64000/speed;
	}

	return ERROR_OK;
}

77
static bool readPowerDropout(void)
78
79
80
{
	cyg_uint32 state;
	// sample and clear power dropout
oharboe's avatar
wip    
oharboe committed
81
82
	HAL_WRITE_UINT32(ZY1000_JTAG_BASE+0x10, 0x80);
	HAL_READ_UINT32(ZY1000_JTAG_BASE+0x10, state);
83
84
85
86
	bool powerDropout;
	powerDropout = (state & 0x80) != 0;
	return powerDropout;
}
87

88

89
static bool readSRST(void)
90
91
92
{
	cyg_uint32 state;
	// sample and clear SRST sensing
oharboe's avatar
wip    
oharboe committed
93
94
	HAL_WRITE_UINT32(ZY1000_JTAG_BASE+0x10, 0x00000040);
	HAL_READ_UINT32(ZY1000_JTAG_BASE+0x10, state);
95
96
97
98
99
	bool srstAsserted;
	srstAsserted = (state & 0x40) != 0;
	return srstAsserted;
}

oharboe's avatar
oharboe committed
100
101
102
103
104
105
static int zy1000_srst_asserted(int *srst_asserted)
{
	*srst_asserted=readSRST();
	return ERROR_OK;
}

106
107
static int zy1000_power_dropout(int *dropout)
{
oharboe's avatar
oharboe committed
108
	*dropout=readPowerDropout();
109
110
111
112
113
	return ERROR_OK;
}


jtag_interface_t zy1000_interface =
114
115
{
	.name = "ZY1000",
oharboe's avatar
oharboe committed
116
	.execute_queue = NULL,
117
118
119
120
121
122
123
	.speed = zy1000_speed,
	.register_commands = zy1000_register_commands,
	.init = zy1000_init,
	.quit = zy1000_quit,
	.khz = zy1000_khz,
	.speed_div = zy1000_speed_div,
	.power_dropout = zy1000_power_dropout,
oharboe's avatar
oharboe committed
124
	.srst_asserted = zy1000_srst_asserted,
125
126
};

127
void zy1000_reset(int trst, int srst)
128
129
{
	LOG_DEBUG("zy1000 trst=%d, srst=%d", trst, srst);
zwelch's avatar
zwelch committed
130
	if (!srst)
131
	{
oharboe's avatar
wip    
oharboe committed
132
		ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x00000001);
133
134
135
	}
	else
	{
zwelch's avatar
zwelch committed
136
		/* Danger!!! if clk != 0 when in
137
		 * idle in TAP_IDLE, reset halt on str912 will fail.
138
		 */
oharboe's avatar
wip    
oharboe committed
139
		ZY1000_POKE(ZY1000_JTAG_BASE+0x10, 0x00000001);
140
141
	}

zwelch's avatar
zwelch committed
142
	if (!trst)
143
	{
oharboe's avatar
wip    
oharboe committed
144
		ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x00000002);
145
146
147
148
	}
	else
	{
		/* assert reset */
oharboe's avatar
wip    
oharboe committed
149
		ZY1000_POKE(ZY1000_JTAG_BASE+0x10, 0x00000002);
150
	}
151

152
	if (trst||(srst&&(jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
153
154
	{
		waitIdle();
155
		/* we're now in the RESET state until trst is deasserted */
156
		ZY1000_POKE(ZY1000_JTAG_BASE+0x20, TAP_RESET);
157
158
159
	} else
	{
		/* We'll get RCLK failure when we assert TRST, so clear any false positives here */
oharboe's avatar
wip    
oharboe committed
160
		ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x400);
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
	}

	/* wait for srst to float back up */
	if (!srst)
	{
		int i;
		for (i=0; i<1000; i++)
		{
			// We don't want to sense our own reset, so we clear here.
			// There is of course a timing hole where we could loose
			// a "real" reset.
			if (!readSRST())
				break;

			/* wait 1ms */
			alive_sleep(1);
		}

		if (i==1000)
		{
			LOG_USER("SRST didn't deassert after %dms", i);
		} else if (i>1)
		{
			LOG_USER("SRST took %dms to deassert", i);
		}
	}
}

189
int zy1000_speed(int speed)
190
{
zwelch's avatar
zwelch committed
191
	if (speed == 0)
192
193
194
	{
		/*0 means RCLK*/
		speed = 0;
oharboe's avatar
wip    
oharboe committed
195
		ZY1000_POKE(ZY1000_JTAG_BASE+0x10, 0x100);
196
197
198
199
		LOG_DEBUG("jtag_speed using RCLK");
	}
	else
	{
zwelch's avatar
zwelch committed
200
		if (speed > 8190 || speed < 2)
201
		{
202
			LOG_USER("valid ZY1000 jtag_speed=[8190,2]. Divisor is 64MHz / even values between 8190-2, i.e. min 7814Hz, max 32MHz");
203
204
205
206
			return ERROR_INVALID_ARGUMENTS;
		}

		LOG_USER("jtag_speed %d => JTAG clk=%f", speed, 64.0/(float)speed);
oharboe's avatar
wip    
oharboe committed
207
208
		ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x100);
		ZY1000_POKE(ZY1000_JTAG_BASE+0x1c, speed&~1);
209
210
211
212
	}
	return ERROR_OK;
}

213
static bool savePower;
214
215


216
static void setPower(bool power)
217
{
218
219
220
221
222
223
224
225
	savePower = power;
	if (power)
	{
		HAL_WRITE_UINT32(ZY1000_JTAG_BASE+0x14, 0x8);
	} else
	{
		HAL_WRITE_UINT32(ZY1000_JTAG_BASE+0x10, 0x8);
	}
226
227
}

228
int handle_power_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
229
{
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
	if (argc > 1)
	{
		return ERROR_INVALID_ARGUMENTS;
	}

	if (argc == 1)
	{
		if (strcmp(args[0], "on") == 0)
		{
			setPower(1);
		}
		else if (strcmp(args[0], "off") == 0)
		{
			setPower(0);
		} else
		{
			command_print(cmd_ctx, "arg is \"on\" or \"off\"");
			return ERROR_INVALID_ARGUMENTS;
		}
	}

	command_print(cmd_ctx, "Target power %s", savePower ? "on" : "off");
252
253
254
255
256

	return ERROR_OK;
}


257
/* Give TELNET a way to find out what version this is */
oharboe's avatar
oharboe committed
258
static int jim_zy1000_version(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
259
{
oharboe's avatar
oharboe committed
260
261
262
263
264
265
	if ((argc < 1) || (argc > 2))
		return JIM_ERR;
	char buff[128];
	const char *version_str=NULL;

	if (argc == 1)
266
	{
oharboe's avatar
oharboe committed
267
268
		version_str=ZYLIN_OPENOCD_VERSION;
	} else
269
	{
oharboe's avatar
oharboe committed
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
		const char *str = Jim_GetString(argv[1], NULL);
		if (strcmp("openocd", str) == 0)
		{
			int revision;
			revision = atol(ZYLIN_OPENOCD+strlen("XRevision: "));
			sprintf(buff, "%d", revision);
			version_str=buff;
		}
		else if (strcmp("zy1000", str) == 0)
		{
			version_str=ZYLIN_VERSION;
		}
		else if (strcmp("date", str) == 0)
		{
			version_str=ZYLIN_DATE;
		}
		else
		{
			return JIM_ERR;
		}
290
	}
291

oharboe's avatar
oharboe committed
292
293
294
	Jim_SetResult(interp, Jim_NewStringObj(interp, version_str, -1));

	return JIM_OK;
295
296
}

297

oharboe's avatar
oharboe committed
298
299
static int
zylinjtag_Jim_Command_powerstatus(Jim_Interp *interp,
300
								   int argc,
oharboe's avatar
oharboe committed
301
302
303
304
305
306
307
308
309
310
311
		Jim_Obj * const *argv)
{
	if (argc != 1)
	{
		Jim_WrongNumArgs(interp, 1, argv, "powerstatus");
		return JIM_ERR;
	}

	cyg_uint32 status;
	ZY1000_PEEK(ZY1000_JTAG_BASE+0x10, status);

zwelch's avatar
zwelch committed
312
	Jim_SetResult(interp, Jim_NewIntObj(interp, (status&0x80) != 0));
oharboe's avatar
oharboe committed
313
314
315
316

	return JIM_OK;
}

317
318
319
320
int zy1000_register_commands(struct command_context_s *cmd_ctx)
{
	register_command(cmd_ctx, NULL, "power", handle_power_command, COMMAND_ANY,
			"power <on/off> - turn power switch to target on/off. No arguments - print status.");
oharboe's avatar
oharboe committed
321
322
323

	Jim_CreateCommand(interp, "zy1000_version", jim_zy1000_version, NULL, NULL);

324

oharboe's avatar
oharboe committed
325
	Jim_CreateCommand(interp, "powerstatus", zylinjtag_Jim_Command_powerstatus, NULL, NULL);
326

327
328
329
330
	return ERROR_OK;
}


oharboe's avatar
oharboe committed
331
332


333
334
int zy1000_init(void)
{
oharboe's avatar
oharboe committed
335
	LOG_USER("%s", ZYLIN_OPENOCD_VERSION);
336
337
338
339
340
341
342
343

	ZY1000_POKE(ZY1000_JTAG_BASE+0x10, 0x30); // Turn on LED1 & LED2

	setPower(true); // on by default


	 /* deassert resets. Important to avoid infinite loop waiting for SRST to deassert */
	zy1000_reset(0, 0);
344
	zy1000_speed(jtag_get_speed());
345
346
347
348
349
350
351
352

	return ERROR_OK;
}

int zy1000_quit(void)
{

	return ERROR_OK;
353
354
355
356
357
358
359
360
361
}



int interface_jtag_execute_queue(void)
{
	cyg_uint32 empty;

	waitIdle();
oharboe's avatar
wip    
oharboe committed
362
	ZY1000_PEEK(ZY1000_JTAG_BASE+0x10, empty);
363
	/* clear JTAG error register */
oharboe's avatar
wip    
oharboe committed
364
	ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x400);
365

zwelch's avatar
zwelch committed
366
	if ((empty&0x400) != 0)
367
368
369
370
371
372
373
374
375
376
377
378
379
380
	{
		LOG_WARNING("RCLK timeout");
		/* the error is informative only as we don't want to break the firmware if there
		 * is a false positive.
		 */
//		return ERROR_FAIL;
	}
	return ERROR_OK;
}





381
static cyg_uint32 getShiftValue(void)
382
383
384
{
	cyg_uint32 value;
	waitIdle();
oharboe's avatar
wip    
oharboe committed
385
	ZY1000_PEEK(ZY1000_JTAG_BASE+0xc, value);
386
387
388
389
	VERBOSE(LOG_INFO("getShiftValue %08x", value));
	return value;
}
#if 0
390
static cyg_uint32 getShiftValueFlip(void)
391
392
393
{
	cyg_uint32 value;
	waitIdle();
oharboe's avatar
wip    
oharboe committed
394
	ZY1000_PEEK(ZY1000_JTAG_BASE+0x18, value);
395
396
397
398
399
400
	VERBOSE(LOG_INFO("getShiftValue %08x (flipped)", value));
	return value;
}
#endif

#if 0
401
static void shiftValueInnerFlip(const tap_state_t state, const tap_state_t endState, int repeat, cyg_uint32 value)
402
{
403
	VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_name(state), tap_state_name(endState), repeat, value));
404
405
406
	cyg_uint32 a,b;
	a=state;
	b=endState;
oharboe's avatar
wip    
oharboe committed
407
408
	ZY1000_POKE(ZY1000_JTAG_BASE+0xc, value);
	ZY1000_POKE(ZY1000_JTAG_BASE+0x8, (1<<15)|(repeat<<8)|(a<<4)|b);
409
410
411
412
	VERBOSE(getShiftValueFlip());
}
#endif

zwelch's avatar
zwelch committed
413
extern int jtag_check_value(uint8_t *captured, void *priv);
414

oharboe's avatar
oharboe committed
415
static __inline void scanFields(int num_fields, const scan_field_t *fields, tap_state_t shiftState, tap_state_t end_state)
416
417
418
419
420
421
422
423
424
{
	int i;
	int j;
	int k;

	for (i = 0; i < num_fields; i++)
	{
		cyg_uint32 value;

zwelch's avatar
zwelch committed
425
		uint8_t *inBuffer=NULL;
426
427
428
429


		// figure out where to store the input data
		int num_bits=fields[i].num_bits;
zwelch's avatar
zwelch committed
430
		if (fields[i].in_value != NULL)
431
432
433
434
435
436
437
438
		{
			inBuffer=fields[i].in_value;
		}

		// here we shuffle N bits out/in
		j=0;
		while (j<num_bits)
		{
439
			tap_state_t pause_state;
440
441
			int l;
			k=num_bits-j;
442
			pause_state=(shiftState==TAP_DRSHIFT)?TAP_DRSHIFT:TAP_IRSHIFT;
443
444
445
446
			if (k>32)
			{
				k=32;
				/* we have more to shift out */
447
			} else if (i == num_fields-1)
448
449
			{
				/* this was the last to shift out this time */
450
				pause_state=end_state;
451
452
453
454
455
			}

			// we have (num_bits+7)/8 bytes of bits to toggle out.
			// bits are pushed out LSB to MSB
			value=0;
zwelch's avatar
zwelch committed
456
			if (fields[i].out_value != NULL)
457
			{
zwelch's avatar
zwelch committed
458
				for (l=0; l<k; l += 8)
459
460
461
462
463
				{
					value|=fields[i].out_value[(j+l)/8]<<l;
				}
			}
			/* mask away unused bits for easier debugging */
464
			value&=~(((uint32_t)0xffffffff)<<k);
465
466
467

			shiftValueInner(shiftState, pause_state, k, value);

zwelch's avatar
zwelch committed
468
			if (inBuffer != NULL)
469
470
471
472
473
474
			{
				// data in, LSB to MSB
				value=getShiftValue();
				// we're shifting in data to MSB, shift data to be aligned for returning the value
				value >>= 32-k;

zwelch's avatar
zwelch committed
475
				for (l=0; l<k; l += 8)
476
477
478
479
				{
					inBuffer[(j+l)/8]=(value>>l)&0xff;
				}
			}
zwelch's avatar
zwelch committed
480
			j += k;
481
482
483
484
		}
	}
}

485
int interface_jtag_set_end_state(tap_state_t state)
486
487
488
489
490
{
	return ERROR_OK;
}


oharboe's avatar
oharboe committed
491
int interface_jtag_add_ir_scan(int num_fields, const scan_field_t *fields, tap_state_t state)
492
493
{

oharboe's avatar
oharboe committed
494
	int j;
495
	int scan_size = 0;
oharboe's avatar
oharboe committed
496
	jtag_tap_t *tap, *nextTap;
zwelch's avatar
zwelch committed
497
	for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap=nextTap)
498
	{
499
		nextTap=jtag_tap_next_enabled(tap);
500
501
502
		tap_state_t end_state;
		if (nextTap==NULL)
		{
503
			end_state = state;
504
505
506
507
		} else
		{
			end_state = TAP_IRSHIFT;
		}
oharboe's avatar
oharboe committed
508

509
		int found = 0;
510

oharboe's avatar
oharboe committed
511
		scan_size = tap->ir_length;
512
513
514
515

		/* search the list */
		for (j=0; j < num_fields; j++)
		{
oharboe's avatar
oharboe committed
516
			if (tap == fields[j].tap)
517
518
519
			{
				found = 1;

520
				scanFields(1, fields+j, TAP_IRSHIFT, end_state);
521
				/* update device information */
oharboe's avatar
oharboe committed
522
				buf_cpy(fields[j].out_value, tap->cur_instr, scan_size);
523

oharboe's avatar
oharboe committed
524
				tap->bypass = 0;
525
526
527
528
529
530
531
				break;
			}
		}

		if (!found)
		{
			/* if a device isn't listed, set it to BYPASS */
zwelch's avatar
zwelch committed
532
			uint8_t ones[]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
533
534
535
536
537

			scan_field_t tmp;
			memset(&tmp, 0, sizeof(tmp));
			tmp.out_value = ones;
			tmp.num_bits = scan_size;
538
			scanFields(1, &tmp, TAP_IRSHIFT, end_state);
539
			/* update device information */
oharboe's avatar
oharboe committed
540
541
			buf_cpy(tmp.out_value, tap->cur_instr, scan_size);
			tap->bypass = 1;
542
543
544
545
546
547
548
549
550
551
		}
	}

	return ERROR_OK;
}





oharboe's avatar
oharboe committed
552
int interface_jtag_add_plain_ir_scan(int num_fields, const scan_field_t *fields, tap_state_t state)
553
{
554
	scanFields(num_fields, fields, TAP_IRSHIFT, state);
555
556
557
558
559
560

	return ERROR_OK;
}

/*extern jtag_command_t **jtag_get_last_command_p(void);*/

oharboe's avatar
oharboe committed
561
int interface_jtag_add_dr_scan(int num_fields, const scan_field_t *fields, tap_state_t state)
562
{
oharboe's avatar
oharboe committed
563
564
565

	int j;
	jtag_tap_t *tap, *nextTap;
zwelch's avatar
zwelch committed
566
	for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap=nextTap)
567
	{
568
		nextTap=jtag_tap_next_enabled(tap);
oharboe's avatar
oharboe committed
569
		int found=0;
570
571
572
		tap_state_t end_state;
		if (nextTap==NULL)
		{
573
			end_state = state;
574
575
576
577
		} else
		{
			end_state = TAP_DRSHIFT;
		}
578
579
580

		for (j=0; j < num_fields; j++)
		{
oharboe's avatar
oharboe committed
581
			if (tap == fields[j].tap)
582
583
584
			{
				found = 1;

585
				scanFields(1, fields+j, TAP_DRSHIFT, end_state);
586
587
588
589
590
591
592
593
594
595
			}
		}
		if (!found)
		{
			scan_field_t tmp;
			/* program the scan field to 1 bit length, and ignore it's value */
			tmp.num_bits = 1;
			tmp.out_value = NULL;
			tmp.in_value = NULL;

596
			scanFields(1, &tmp, TAP_DRSHIFT, end_state);
597
598
599
600
601
602
603
604
		}
		else
		{
		}
	}
	return ERROR_OK;
}

oharboe's avatar
oharboe committed
605
int interface_jtag_add_plain_dr_scan(int num_fields, const scan_field_t *fields, tap_state_t state)
606
{
607
	scanFields(num_fields, fields, TAP_DRSHIFT, state);
608
609
610
611
612
613
	return ERROR_OK;
}


int interface_jtag_add_tlr()
{
614
	setCurrentState(TAP_RESET);
615
616
617
618
619
620
621
622
623
624
625
	return ERROR_OK;
}




extern int jtag_nsrst_delay;
extern int jtag_ntrst_delay;

int interface_jtag_add_reset(int req_trst, int req_srst)
{
626
	zy1000_reset(req_trst, req_srst);
627
628
629
	return ERROR_OK;
}

630
static int zy1000_jtag_add_clocks(int num_cycles, tap_state_t state, tap_state_t clockstate)
631
632
{
	/* num_cycles can be 0 */
633
	setCurrentState(clockstate);
634
635
636

	/* execute num_cycles, 32 at the time. */
	int i;
zwelch's avatar
zwelch committed
637
	for (i=0; i<num_cycles; i += 32)
638
639
640
641
642
643
644
	{
		int num;
		num=32;
		if (num_cycles-i<num)
		{
			num=num_cycles-i;
		}
645
		shiftValueInner(clockstate, clockstate, num, 0);
646
647
648
649
650
651
	}

#if !TEST_MANUAL()
	/* finish in end_state */
	setCurrentState(state);
#else
652
	tap_state_t t=TAP_IDLE;
653
654
	/* test manual drive code on any target */
	int tms;
zwelch's avatar
zwelch committed
655
	uint8_t tms_scan = tap_get_tms_path(t, state);
656
	int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
657

658
	for (i = 0; i < tms_count; i++)
659
660
661
	{
		tms = (tms_scan >> i) & 1;
		waitIdle();
oharboe's avatar
wip    
oharboe committed
662
		ZY1000_POKE(ZY1000_JTAG_BASE+0x28,  tms);
663
664
	}
	waitIdle();
oharboe's avatar
wip    
oharboe committed
665
	ZY1000_POKE(ZY1000_JTAG_BASE+0x20, state);
666
667
668
669
670
671
#endif


	return ERROR_OK;
}

672
int interface_jtag_add_runtest(int num_cycles, tap_state_t state)
673
674
675
676
677
678
{
	return zy1000_jtag_add_clocks(num_cycles, state, TAP_IDLE);
}

int interface_jtag_add_clocks(int num_cycles)
{
679
	return zy1000_jtag_add_clocks(num_cycles, cmd_queue_cur_state, cmd_queue_cur_state);
680
681
}

682
int interface_jtag_add_sleep(uint32_t us)
683
684
685
686
687
{
	jtag_sleep(us);
	return ERROR_OK;
}

oharboe's avatar
oharboe committed
688
int interface_jtag_add_pathmove(int num_states, const tap_state_t *path)
689
690
691
692
693
694
695
696
697
{
	int state_count;
	int tms = 0;

	/*wait for the fifo to be empty*/
	waitIdle();

	state_count = 0;

698
	tap_state_t cur_state=cmd_queue_cur_state;
699
700
701

	while (num_states)
	{
702
		if (tap_state_transition(cur_state, false) == path[state_count])
703
704
705
		{
			tms = 0;
		}
706
		else if (tap_state_transition(cur_state, true) == path[state_count])
707
708
709
710
711
		{
			tms = 1;
		}
		else
		{
712
			LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[state_count]));
713
714
715
716
			exit(-1);
		}

		waitIdle();
oharboe's avatar
wip    
oharboe committed
717
		ZY1000_POKE(ZY1000_JTAG_BASE+0x28,  tms);
718
719
720
721
722
723
724

		cur_state = path[state_count];
		state_count++;
		num_states--;
	}

	waitIdle();
oharboe's avatar
wip    
oharboe committed
725
	ZY1000_POKE(ZY1000_JTAG_BASE+0x20,  cur_state);
726
727
728
729
730
	return ERROR_OK;
}



zwelch's avatar
zwelch committed
731
void embeddedice_write_dcc(jtag_tap_t *tap, int reg_addr, uint8_t *buffer, int little, int count)
732
733
{
//	static int const reg_addr=0x5;
734
	tap_state_t end_state=jtag_get_end_state();
735
	if (jtag_tap_next_enabled(jtag_tap_next_enabled(NULL))==NULL)
736
737
738
739
740
741
742
	{
		/* better performance via code duplication */
		if (little)
		{
			int i;
			for (i = 0; i < count; i++)
			{
743
744
				shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, 1));
				shiftValueInner(TAP_DRSHIFT, end_state, 6, reg_addr|(1<<5));
zwelch's avatar
zwelch committed
745
				buffer += 4;
746
747
748
749
750
751
			}
		} else
		{
			int i;
			for (i = 0; i < count; i++)
			{
752
753
				shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, 0));
				shiftValueInner(TAP_DRSHIFT, end_state, 6, reg_addr|(1<<5));
zwelch's avatar
zwelch committed
754
				buffer += 4;
755
756
757
758
759
760
761
762
			}
		}
	}
	else
	{
		int i;
		for (i = 0; i < count; i++)
		{
oharboe's avatar
oharboe committed
763
			embeddedice_write_reg_inner(tap, reg_addr, fast_target_buffer_get_u32(buffer, little));
764
765
766
767
768
			buffer += 4;
		}
	}
}

769