arm-jtag-ew.c 20.6 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
23
24
/***************************************************************************
 *   Copyright (C) 2009 by Dimitar Dimitrov <dinuxbg@gmail.com>            *
 *   based on Dominic Rath's and Benedikt Sauter's usbprog.c               *
 *                                                                         *
 *   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

25
#include <jtag/interface.h>
26
#include <jtag/commands.h>
27
#include <usb.h>
28
#include "usb_common.h"
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


#define USB_VID						0x15ba
#define USB_PID						0x001e

#define ARMJTAGEW_EPT_BULK_OUT		0x01u
#define ARMJTAGEW_EPT_BULK_IN		0x82u

#define ARMJTAGEW_USB_TIMEOUT		2000

#define ARMJTAGEW_IN_BUFFER_SIZE	(4*1024)
#define ARMJTAGEW_OUT_BUFFER_SIZE	(4*1024)


/* USB command request codes. */
#define CMD_GET_VERSION				0x00
#define CMD_SELECT_DPIMPL			0x10
#define CMD_SET_TCK_FREQUENCY		0x11
#define CMD_GET_TCK_FREQUENCY		0x12
#define CMD_MEASURE_MAX_TCK_FREQ	0x15
#define CMD_MEASURE_RTCK_RESPONSE	0x16
#define CMD_TAP_SHIFT				0x17
#define CMD_SET_TAPHW_STATE			0x20
#define CMD_GET_TAPHW_STATE			0x21
#define CMD_TGPWR_SETUP				0x22

/* Global USB buffers */
zwelch's avatar
zwelch committed
56
57
static uint8_t usb_in_buffer[ARMJTAGEW_IN_BUFFER_SIZE];
static uint8_t usb_out_buffer[ARMJTAGEW_OUT_BUFFER_SIZE];
58
59

/* Queue command functions */
60
61
62
63
static void armjtagew_end_state(tap_state_t state);
static void armjtagew_state_move(void);
static void armjtagew_path_move(int num_states, tap_state_t *path);
static void armjtagew_runtest(int num_cycles);
64
static void armjtagew_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command);
65
static void armjtagew_reset(int trst, int srst);
zwelch's avatar
zwelch committed
66
//static void armjtagew_simple_command(uint8_t command);
67
static int armjtagew_get_status(void);
68
69

/* tap buffer functions */
70
71
72
73
static void armjtagew_tap_init(void);
static int armjtagew_tap_execute(void);
static void armjtagew_tap_ensure_space(int scans, int bits);
static void armjtagew_tap_append_step(int tms, int tdi);
74
static void armjtagew_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command);
75
76

/* ARM-JTAG-EW lowlevel functions */
77
struct armjtagew {
78
	struct usb_dev_handle* usb_handle;
79
};
80

81
82
83
84
85
static struct armjtagew *armjtagew_usb_open(void);
static void armjtagew_usb_close(struct armjtagew *armjtagew);
static int armjtagew_usb_message(struct armjtagew *armjtagew, int out_length, int in_length);
static int armjtagew_usb_write(struct armjtagew *armjtagew, int out_length);
static int armjtagew_usb_read(struct armjtagew *armjtagew, int exp_in_length);
86
87

/* helper functions */
88
static int armjtagew_get_version_info(void);
89
90

#ifdef _DEBUG_USB_COMMS_
zwelch's avatar
zwelch committed
91
static void armjtagew_debug_buffer(uint8_t *buffer, int length);
92
93
#endif

94
static struct armjtagew* armjtagew_handle;
95
96
97
98
99
100



/***************************************************************************/
/* External interface implementation */

101
static int armjtagew_execute_queue(void)
102
{
103
	struct jtag_command *cmd = jtag_command_queue;
104
105
	int scan_size;
	enum scan_type type;
zwelch's avatar
zwelch committed
106
	uint8_t *buffer;
107
108
109
110
111
112

	while (cmd != NULL)
	{
		switch (cmd->type)
		{
			case JTAG_RUNTEST:
113
				DEBUG_JTAG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, \
114
115
					cmd->cmd.runtest->end_state);

116
				armjtagew_end_state(cmd->cmd.runtest->end_state);
117
118
119
				armjtagew_runtest(cmd->cmd.runtest->num_cycles);
				break;

120
			case JTAG_TLR_RESET:
121
122
				DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);

123
				armjtagew_end_state(cmd->cmd.statemove->end_state);
124
125
126
127
128
129
130
131
132
133
134
135
136
137
				armjtagew_state_move();
				break;

			case JTAG_PATHMOVE:
				DEBUG_JTAG_IO("pathmove: %i states, end in %i", \
					cmd->cmd.pathmove->num_states, \
					cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);

				armjtagew_path_move(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path);
				break;

			case JTAG_SCAN:
				DEBUG_JTAG_IO("scan end in %i", cmd->cmd.scan->end_state);

138
				armjtagew_end_state(cmd->cmd.scan->end_state);
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

				scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
				DEBUG_JTAG_IO("scan input, length = %d", scan_size);

#ifdef _DEBUG_USB_COMMS_
				armjtagew_debug_buffer(buffer, (scan_size + 7) / 8);
#endif
				type = jtag_scan_type(cmd->cmd.scan);
				armjtagew_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size, cmd->cmd.scan);
				break;

			case JTAG_RESET:
				DEBUG_JTAG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);

				armjtagew_tap_execute();

				if (cmd->cmd.reset->trst == 1)
				{
					tap_set_state(TAP_RESET);
				}
				armjtagew_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
				break;

			case JTAG_SLEEP:
				DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
				armjtagew_tap_execute();
				jtag_sleep(cmd->cmd.sleep->us);
				break;

			default:
				LOG_ERROR("BUG: unknown JTAG command type encountered");
				exit(-1);
		}
		cmd = cmd->next;
	}

	return armjtagew_tap_execute();
}


/* Sets speed in kHz. */
180
static int armjtagew_speed(int speed)
181
182
183
184
185
186
{
    int result;
    int speed_real;


    usb_out_buffer[0] = CMD_SET_TCK_FREQUENCY;
zwelch's avatar
zwelch committed
187
	buf_set_u32(usb_out_buffer + 1, 0, 32, speed);
188

189
    result = armjtagew_usb_message(armjtagew_handle, 4, 4);
190
191
192
193
194
195
196
197

    if (result < 0)
    {
        LOG_ERROR("ARM-JTAG-EW setting speed failed (%d)", result);
        return ERROR_JTAG_DEVICE_ERROR;
    }

	usb_out_buffer[0] = CMD_GET_TCK_FREQUENCY;
198
    result = armjtagew_usb_message(armjtagew_handle, 1, 4);
199
	speed_real = (int)buf_get_u32(usb_in_buffer,0,32);
zwelch's avatar
zwelch committed
200
	if (result < 0)
201
202
203
	{
        LOG_ERROR("ARM-JTAG-EW getting speed failed (%d)", result);
        return ERROR_JTAG_DEVICE_ERROR;
zwelch's avatar
zwelch committed
204
	}
205
206
	else
	{
zwelch's avatar
zwelch committed
207
	LOG_INFO("Requested speed %dkHz, emulator reported %dkHz.", speed, speed_real);
208
209
210
211
212
213
	}

    return ERROR_OK;
}


214
static int armjtagew_khz(int khz, int *jtag_speed)
215
216
217
218
219
220
{
	*jtag_speed = khz;

	return ERROR_OK;
}

221
static int armjtagew_init(void)
222
223
224
{
	int check_cnt;

225
	armjtagew_handle = armjtagew_usb_open();
226

227
	if (armjtagew_handle == 0)
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
	{
		LOG_ERROR("Cannot find ARM-JTAG-EW Interface! Please check connection and permissions.");
		return ERROR_JTAG_INIT_FAILED;
	}

	check_cnt = 0;
	while (check_cnt < 3)
	{
		if (armjtagew_get_version_info() == ERROR_OK)
		{
			/* attempt to get status */
			armjtagew_get_status();
			break;
		}

		check_cnt++;
	}

	if (check_cnt == 3)
	{
		LOG_INFO("ARM-JTAG-EW initial read failed, don't worry");
	}

	LOG_INFO("ARM-JTAG-EW JTAG Interface ready");

	armjtagew_reset(0, 0);
	armjtagew_tap_init();

	return ERROR_OK;
}

259
static int armjtagew_quit(void)
260
{
261
	armjtagew_usb_close(armjtagew_handle);
262
263
264
265
266
267
	return ERROR_OK;
}

/***************************************************************************/
/* Queue command implementations */

268
static void armjtagew_end_state(tap_state_t state)
269
270
271
272
273
274
275
276
277
278
279
280
281
{
	if (tap_is_state_stable(state))
	{
		tap_set_end_state(state);
	}
	else
	{
		LOG_ERROR("BUG: %i is not a valid end state", state);
		exit(-1);
	}
}

/* Goes to the end state. */
282
static void armjtagew_state_move(void)
283
284
285
{
	int i;
	int tms = 0;
zwelch's avatar
zwelch committed
286
	uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
287
	int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
288

289
	for (i = 0; i < tms_count; i++)
290
291
292
293
294
295
296
297
	{
		tms = (tms_scan >> i) & 1;
		armjtagew_tap_append_step(tms, 0);
	}

	tap_set_state(tap_get_end_state());
}

298
static void armjtagew_path_move(int num_states, tap_state_t *path)
299
300
301
302
303
304
{
	int i;

	for (i = 0; i < num_states; i++)
	{
		/*
zwelch's avatar
zwelch committed
305
		 * TODO: The ARM-JTAG-EW hardware delays TDI with 3 TCK cycles when in RTCK mode.
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
		 * Either handle that here, or update the documentation with examples
		 * how to fix that in the configuration files.
		 */
		if (path[i] == tap_state_transition(tap_get_state(), false))
		{
			armjtagew_tap_append_step(0, 0);
		}
		else if (path[i] == tap_state_transition(tap_get_state(), true))
		{
			armjtagew_tap_append_step(1, 0);
		}
		else
		{
			LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path[i]));
			exit(-1);
		}

		tap_set_state(path[i]);
	}

	tap_set_end_state(tap_get_state());
}

329
static void armjtagew_runtest(int num_cycles)
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
{
	int i;

	tap_state_t saved_end_state = tap_get_end_state();

	/* only do a state_move when we're not already in IDLE */
	if (tap_get_state() != TAP_IDLE)
	{
		armjtagew_end_state(TAP_IDLE);
		armjtagew_state_move();
	}

	/* execute num_cycles */
	for (i = 0; i < num_cycles; i++)
	{
		armjtagew_tap_append_step(0, 0);
	}

	/* finish in end_state */
	armjtagew_end_state(saved_end_state);
	if (tap_get_state() != tap_get_end_state())
	{
		armjtagew_state_move();
	}
}

356
static void armjtagew_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command)
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
{
	tap_state_t saved_end_state;

	armjtagew_tap_ensure_space(1, scan_size + 8);

	saved_end_state = tap_get_end_state();

	/* Move to appropriate scan state */
	armjtagew_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);

	armjtagew_state_move();
	armjtagew_end_state(saved_end_state);

	/* Scan */
	armjtagew_tap_append_scan(scan_size, buffer, command);

	/* We are in Exit1, go to Pause */
	armjtagew_tap_append_step(0, 0);

	tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);

	if (tap_get_state() != tap_get_end_state())
	{
		armjtagew_state_move();
	}
}

384
static void armjtagew_reset(int trst, int srst)
385
{
zwelch's avatar
zwelch committed
386
387
	const uint8_t trst_mask = (1u << 5);
	const uint8_t srst_mask = (1u << 6);
zwelch's avatar
zwelch committed
388
389
390
	uint8_t val = 0;
	uint8_t outp_en = 0;
	uint8_t change_mask = 0;
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
	int result;

	LOG_DEBUG("trst: %i, srst: %i", trst, srst);

	if (srst == 0)
	{
		val |= srst_mask;
		outp_en &= ~srst_mask;		/* tristate */
		change_mask |= srst_mask;
	}
	else if (srst == 1)
	{
		val &= ~srst_mask;
		outp_en |= srst_mask;
		change_mask |= srst_mask;
	}

	if (trst == 0)
	{
		val |= trst_mask;
		outp_en &= ~trst_mask;		/* tristate */
		change_mask |= trst_mask;
	}
	else if (trst == 1)
	{
		val &= ~trst_mask;
		outp_en |= trst_mask;
		change_mask |= trst_mask;
	}

	usb_out_buffer[0] = CMD_SET_TAPHW_STATE;
	usb_out_buffer[1] = val;
	usb_out_buffer[2] = outp_en;
	usb_out_buffer[3] = change_mask;
425
	result = armjtagew_usb_write(armjtagew_handle, 4);
426
427
428
429
430
431
432
	if (result != 4)
	{
		LOG_ERROR("ARM-JTAG-EW TRST/SRST pin set failed failed (%d)", result);
	}
}


433
static int armjtagew_get_status(void)
434
435
436
437
{
	int result;

	usb_out_buffer[0] = CMD_GET_TAPHW_STATE;
438
	result = armjtagew_usb_message(armjtagew_handle, 1, 12);
439
440
441
442

	if (result == 0)
	{
		unsigned int u_tg = buf_get_u32(usb_in_buffer, 0, 16);
Eric Wetzel's avatar
Eric Wetzel committed
443
		LOG_INFO("U_tg = %d mV, U_aux = %d mV, U_tgpwr = %d mV, I_tgpwr = %d mA, D1 = %d, Target power %s %s",
444
445
446
447
			 (int)(buf_get_u32(usb_in_buffer + 0, 0, 16)),
			 (int)(buf_get_u32(usb_in_buffer + 2, 0, 16)),
			 (int)(buf_get_u32(usb_in_buffer + 4, 0, 16)),
			 (int)(buf_get_u32(usb_in_buffer + 6, 0, 16)),
448
449
			 usb_in_buffer[9],
			 usb_in_buffer[11] ? "OVERCURRENT" : "OK",
450
			 usb_in_buffer[10] ? "enabled" : "disabled");
451
452
453

		if (u_tg < 1500)
		{
454
			LOG_ERROR("Vref too low. Check Target Power");
455
456
457
458
		}
	}
	else
	{
459
		LOG_ERROR("ARM-JTAG-EW command CMD_GET_TAPHW_STATE failed (%d)", result);
460
461
462
463
464
	}

	return ERROR_OK;
}

465
static int armjtagew_get_version_info(void)
466
467
468
469
470
471
472
{
	int result;
	char sn[16];
	char auxinfo[257];

	/* query hardware version */
	usb_out_buffer[0] = CMD_GET_VERSION;
473
	result = armjtagew_usb_message(armjtagew_handle, 1, 4 + 15 + 256);
474

zwelch's avatar
zwelch committed
475
	if (result != 0)
476
	{
477
		LOG_ERROR("ARM-JTAG-EW command CMD_GET_VERSION failed (%d)", result);
478
479
480
481
		return ERROR_JTAG_DEVICE_ERROR;
	}


zwelch's avatar
zwelch committed
482
	memcpy(sn, usb_in_buffer + 4, 15);
483
	sn[15] = '\0';
zwelch's avatar
zwelch committed
484
	memcpy(auxinfo, usb_in_buffer + 4+15, 256);
485
486
487
488
489
490
491
492
493
	auxinfo[256] = '\0';

	LOG_INFO("ARM-JTAG-EW firmware version %d.%d, hardware revision %c, SN=%s, Additional info: %s", \
			usb_in_buffer[1], usb_in_buffer[0], \
			isgraph(usb_in_buffer[2]) ? usb_in_buffer[2] : 'X', \
			sn, auxinfo);
	return ERROR_OK;
}

494
COMMAND_HANDLER(armjtagew_handle_armjtagew_info_command)
495
496
497
498
499
500
501
502
503
504
{
	if (armjtagew_get_version_info() == ERROR_OK)
	{
		/* attempt to get status */
		armjtagew_get_status();
	}

	return ERROR_OK;
}

505
506
507
508
509
510
511
512
513
514
static const struct command_registration armjtagew_command_handlers[] = {
	{
		.name = "armjtagew_info",
		.handler = &armjtagew_handle_armjtagew_info_command,
		.mode = COMMAND_EXEC,
		.help = "query armjtagew info",
	},
	COMMAND_REGISTRATION_DONE
};

515
struct jtag_interface armjtagew_interface = {
516
517
518
519
520
521
522
523
524
	.name = "arm-jtag-ew",
	.commands = armjtagew_command_handlers,

	.execute_queue = armjtagew_execute_queue,
	.speed = armjtagew_speed,
	.khz = armjtagew_khz,
	.init = armjtagew_init,
	.quit = armjtagew_quit,
};
525

526
527
528
529
530
531
532
/***************************************************************************/
/* ARM-JTAG-EW tap functions */

/* 2048 is the max value we can use here */
#define ARMJTAGEW_TAP_BUFFER_SIZE 2048

static int tap_length;
zwelch's avatar
zwelch committed
533
534
535
static uint8_t tms_buffer[ARMJTAGEW_TAP_BUFFER_SIZE];
static uint8_t tdi_buffer[ARMJTAGEW_TAP_BUFFER_SIZE];
static uint8_t tdo_buffer[ARMJTAGEW_TAP_BUFFER_SIZE];
536

537
struct pending_scan_result {
538
539
	int first;	/* First bit position in tdo_buffer to read */
	int length; /* Number of bits to read */
540
	struct scan_command *command; /* Corresponding scan command */
zwelch's avatar
zwelch committed
541
	uint8_t *buffer;
542
};
543
544
545
546

#define MAX_PENDING_SCAN_RESULTS 256

static int pending_scan_results_length;
547
static struct pending_scan_result pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS];
548
549
550

static int last_tms;

551
static void armjtagew_tap_init(void)
552
553
554
555
556
{
	tap_length = 0;
	pending_scan_results_length = 0;
}

557
static void armjtagew_tap_ensure_space(int scans, int bits)
558
559
560
561
562
563
564
565
566
567
{
	int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length;
	int available_bits = ARMJTAGEW_TAP_BUFFER_SIZE * 8 - tap_length;

	if (scans > available_scans || bits > available_bits)
	{
		armjtagew_tap_execute();
	}
}

568
static void armjtagew_tap_append_step(int tms, int tdi)
569
570
{
	last_tms = tms;
Andreas Fritiofson's avatar
Andreas Fritiofson committed
571
	int index_local = tap_length / 8;
572

Andreas Fritiofson's avatar
Andreas Fritiofson committed
573
	if (index_local < ARMJTAGEW_TAP_BUFFER_SIZE)
574
575
	{
		int bit_index = tap_length % 8;
zwelch's avatar
zwelch committed
576
		uint8_t bit = 1 << bit_index;
577
578
579

		if (tms)
		{
Andreas Fritiofson's avatar
Andreas Fritiofson committed
580
			tms_buffer[index_local] |= bit;
581
582
583
		}
		else
		{
Andreas Fritiofson's avatar
Andreas Fritiofson committed
584
			tms_buffer[index_local] &= ~bit;
585
586
587
588
		}

		if (tdi)
		{
Andreas Fritiofson's avatar
Andreas Fritiofson committed
589
			tdi_buffer[index_local] |= bit;
590
591
592
		}
		else
		{
Andreas Fritiofson's avatar
Andreas Fritiofson committed
593
			tdi_buffer[index_local] &= ~bit;
594
595
596
597
598
599
600
601
602
603
		}

		tap_length++;
	}
	else
	{
		LOG_ERROR("armjtagew_tap_append_step, overflow");
	}
}

604
void armjtagew_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command)
605
{
606
	struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
	int i;

	pending_scan_result->first = tap_length;
	pending_scan_result->length = length;
	pending_scan_result->command = command;
	pending_scan_result->buffer = buffer;

	for (i = 0; i < length; i++)
	{
		armjtagew_tap_append_step((i < length-1 ? 0 : 1), (buffer[i/8] >> (i%8)) & 1);
	}
	pending_scan_results_length++;
}

/* Pad and send a tap sequence to the device, and receive the answer.
 * For the purpose of padding we assume that we are in idle or pause state. */
623
static int armjtagew_tap_execute(void)
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
{
	int byte_length;
	int tms_offset;
	int tdi_offset;
	int i;
	int result;

	if (tap_length > 0)
	{
		/* Pad last byte so that tap_length is divisible by 8 */
		while (tap_length % 8 != 0)
		{
			/* More of the last TMS value keeps us in the same state,
			 * analogous to free-running JTAG interfaces. */
			armjtagew_tap_append_step(last_tms, 0);
		}

		byte_length = tap_length / 8;

		usb_out_buffer[0] = CMD_TAP_SHIFT;
zwelch's avatar
zwelch committed
644
		buf_set_u32(usb_out_buffer + 1, 0, 16, byte_length);
645
646
647
648
649
650
651
652
653
654
655
656
657

		tms_offset = 3;
		for (i = 0; i < byte_length; i++)
		{
			usb_out_buffer[tms_offset + i] = flip_u32(tms_buffer[i],8);
		}

		tdi_offset = tms_offset + byte_length;
		for (i = 0; i < byte_length; i++)
		{
			usb_out_buffer[tdi_offset + i] = flip_u32(tdi_buffer[i],8);
		}

658
		result = armjtagew_usb_message(armjtagew_handle, 3 + 2 * byte_length, byte_length + 4);
659
660
661

		if (result == 0)
		{
662
			int stat_local;
663

664
665
666
			stat_local = (int)buf_get_u32(usb_in_buffer + byte_length, 0, 32);
			if (stat_local) {
				LOG_ERROR("armjtagew_tap_execute, emulator returned error code %d for a CMD_TAP_SHIFT command", stat_local);
667
668
669
670
671
672
673
674
675
676
				return ERROR_JTAG_QUEUE_FAILED;
			}

			for (i = 0; i < byte_length; i++)
			{
				tdo_buffer[i] = flip_u32(usb_in_buffer[i],8);
			}

			for (i = 0; i < pending_scan_results_length; i++)
			{
677
				struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[i];
zwelch's avatar
zwelch committed
678
				uint8_t *buffer = pending_scan_result->buffer;
679
680
				int length = pending_scan_result->length;
				int first = pending_scan_result->first;
681
				struct scan_command *command = pending_scan_result->command;
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718

				/* Copy to buffer */
				buf_set_buf(tdo_buffer, first, buffer, 0, length);

				DEBUG_JTAG_IO("pending scan result, length = %d", length);

#ifdef _DEBUG_USB_COMMS_
				armjtagew_debug_buffer(buffer, byte_length);
#endif

				if (jtag_read_buffer(buffer, command) != ERROR_OK)
				{
					armjtagew_tap_init();
					return ERROR_JTAG_QUEUE_FAILED;
				}

				if (pending_scan_result->buffer != NULL)
				{
					free(pending_scan_result->buffer);
				}
			}
		}
		else
		{
			LOG_ERROR("armjtagew_tap_execute, wrong result %d, expected %d", result, byte_length);
			return ERROR_JTAG_QUEUE_FAILED;
		}

		armjtagew_tap_init();
	}

	return ERROR_OK;
}

/*****************************************************************************/
/* JLink USB low-level functions */

719
static struct armjtagew* armjtagew_usb_open()
720
721
722
{
	usb_init();

723
724
725
726
727
	const uint16_t vids[] = { USB_VID, 0 };
	const uint16_t pids[] = { USB_PID, 0 };
	struct usb_dev_handle *dev;
	if (jtag_usb_open(vids, pids, &dev) != ERROR_OK)
		return NULL;
728

729
730
	struct armjtagew *result = malloc(sizeof(struct armjtagew));
	result->usb_handle = dev;
731
732

#if 0
733
734
	/* usb_set_configuration required under win32 */
	usb_set_configuration(dev, dev->config[0].bConfigurationValue);
735
#endif
736
	usb_claim_interface(dev, 0);
737
#if 0
738
739
740
741
742
	/*
	 * This makes problems under Mac OS X. And is not needed
	 * under Windows. Hopefully this will not break a linux build
	 */
	usb_set_altinterface(dev, 0);
743
#endif
744
	return result;
745
746
}

747
static void armjtagew_usb_close(struct armjtagew *armjtagew)
748
{
749
750
	usb_close(armjtagew->usb_handle);
	free(armjtagew);
751
752
753
}

/* Send a message and receive the reply. */
754
static int armjtagew_usb_message(struct armjtagew *armjtagew, int out_length, int in_length)
755
756
757
{
	int result;

758
	result = armjtagew_usb_write(armjtagew, out_length);
759
760
	if (result == out_length)
	{
761
		result = armjtagew_usb_read(armjtagew, in_length);
zwelch's avatar
zwelch committed
762
		if (result != in_length)
763
764
765
766
767
768
769
770
771
772
773
774
775
776
		{
			LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", in_length, result);
			return -1;
		}
	}
	else
	{
		LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)", out_length, result);
		return -1;
	}
	return 0;
}

/* Write data from out_buffer to USB. */
777
static int armjtagew_usb_write(struct armjtagew *armjtagew, int out_length)
778
779
780
781
782
{
	int result;

	if (out_length > ARMJTAGEW_OUT_BUFFER_SIZE)
	{
783
		LOG_ERROR("armjtagew_write illegal out_length=%d (max=%d)", out_length, ARMJTAGEW_OUT_BUFFER_SIZE);
784
785
786
		return -1;
	}

787
	result = usb_bulk_write(armjtagew->usb_handle, ARMJTAGEW_EPT_BULK_OUT, \
788
789
790
791
792
793
794
795
796
797
798
		(char*)usb_out_buffer, out_length, ARMJTAGEW_USB_TIMEOUT);

	DEBUG_JTAG_IO("armjtagew_usb_write, out_length = %d, result = %d", out_length, result);

#ifdef _DEBUG_USB_COMMS_
	armjtagew_debug_buffer(usb_out_buffer, out_length);
#endif
	return result;
}

/* Read data from USB into in_buffer. */
799
static int armjtagew_usb_read(struct armjtagew *armjtagew, int exp_in_length)
800
{
801
	int result = usb_bulk_read(armjtagew->usb_handle, ARMJTAGEW_EPT_BULK_IN, \
802
803
804
805
806
807
808
809
810
811
812
813
814
815
		(char*)usb_in_buffer, exp_in_length, ARMJTAGEW_USB_TIMEOUT);

	DEBUG_JTAG_IO("armjtagew_usb_read, result = %d", result);

#ifdef _DEBUG_USB_COMMS_
	armjtagew_debug_buffer(usb_in_buffer, result);
#endif
	return result;
}


#ifdef _DEBUG_USB_COMMS_
#define BYTES_PER_LINE  16

zwelch's avatar
zwelch committed
816
static void armjtagew_debug_buffer(uint8_t *buffer, int length)
817
818
819
820
821
822
823
824
825
826
827
828
829
830
{
	char line[81];
	char s[4];
	int i;
	int j;

	for (i = 0; i < length; i += BYTES_PER_LINE)
	{
		snprintf(line, 5, "%04x", i);
		for (j = i; j < i + BYTES_PER_LINE && j < length; j++)
		{
			snprintf(s, 4, " %02x", buffer[j]);
			strcat(line, s);
		}
831
		LOG_DEBUG("%s", line);
832
833
834
835
	}
}
#endif