Code Review / openocd.git / blob
? search:


e9ff8dfa1db41b09ff7a53de19c0979cabb1a753
[openocd.git] / src / jtag / drivers / amt_jtagaccel.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, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
18
19 #ifdef HAVE_CONFIG_H
20 #include "config.h"
21 #endif
22
23 #include <jtag/interface.h>
24
25 #if PARPORT_USE_PPDEV == 1
26 #include <linux/parport.h>
27 #include <linux/ppdev.h>
28 #include <sys/ioctl.h>
29 #else /* not PARPORT_USE_PPDEV */
30 #ifndef _WIN32
31 #include <sys/io.h>
32 #endif
33 #endif
34
35 #if PARPORT_USE_GIVEIO == 1
36 #if IS_CYGWIN == 1
37 #include <windows.h>
38 #endif
39 #endif
40
41 /**
42 * @file
43 * Support the Amontec Chameleon POD with JTAG Accelerator support.
44 * This is a parallel port JTAG adapter with a CPLD between the
45 * parallel port and the JTAG connection. VHDL code running in the
46 * CPLD significantly accelerates JTAG operations compared to the
47 * bitbanging "Wiggler" style of most parallel port adapters.
48 */
49
50 /* configuration */
51 static uint16_t amt_jtagaccel_port;
52
53 /* interface variables
54 */
55 static uint8_t aw_control_rst;
56 static uint8_t aw_control_fsm = 0x10;
57 static uint8_t aw_control_baudrate = 0x20;
58
59 static int rtck_enabled;
60
61 #if PARPORT_USE_PPDEV == 1
62 static int device_handle;
63
64 static const int addr_mode = IEEE1284_MODE_EPP | IEEE1284_ADDR;
65
66 /* FIXME do something sane when these ioctl/read/write calls fail. */
67
68 #define AMT_AW(val) \
69 do { \
70 int __retval; \
71 \
72 __retval = ioctl(device_handle, PPSETMODE, &addr_mode); \
73 assert(__retval >= 0); \
74 __retval = write(device_handle, &val, 1); \
75 assert(__retval >= 0); \
76 } while (0)
77 #define AMT_AR(val) \
78 do { \
79 int __retval; \
80 \
81 __retval = ioctl(device_handle, PPSETMODE, &addr_mode); \
82 assert(__retval >= 0); \
83 __retval = read(device_handle, &val, 1); \
84 assert(__retval >= 0); \
85 } while (0)
86
87 static const int data_mode = IEEE1284_MODE_EPP | IEEE1284_DATA;
88
89 #define AMT_DW(val) \
90 do { \
91 int __retval; \
92 \
93 __retval = ioctl(device_handle, PPSETMODE, &data_mode); \
94 assert(__retval >= 0); \
95 __retval = write(device_handle, &val, 1); \
96 assert(__retval >= 0); \
97 } while (0)
98 #define AMT_DR(val) \
99 do { \
100 int __retval; \
101 \
102 __retval = ioctl(device_handle, PPSETMODE, &data_mode); \
103 assert(__retval >= 0); \
104 __retval = read(device_handle, &val, 1); \
105 assert(__retval >= 0); \
106 } while (0)
107
108 #else
109
110 #define AMT_AW(val) do { outb(val, amt_jtagaccel_port + 3); } while (0)
111 #define AMT_AR(val) do { val = inb(amt_jtagaccel_port + 3); } while (0)
112 #define AMT_DW(val) do { outb(val, amt_jtagaccel_port + 4); } while (0)
113 #define AMT_DR(val) do { val = inb(amt_jtagaccel_port + 4); } while (0)
114
115 #endif /* PARPORT_USE_PPDEV */
116
117 /* tap_move[i][j]: tap movement command to go from state i to state j
118 * 0: Test-Logic-Reset
119 * 1: Run-Test/Idle
120 * 2: Shift-DR
121 * 3: Pause-DR
122 * 4: Shift-IR
123 * 5: Pause-IR
124 */
125 static const uint8_t amt_jtagaccel_tap_move[6][6][2] = {
126 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */
127 { {0x1f, 0x00}, {0x0f, 0x00}, {0x05, 0x00}, {0x0a, 0x00}, {0x06, 0x00}, {0x96, 0x00} }, /* RESET */
128 { {0x1f, 0x00}, {0x00, 0x00}, {0x04, 0x00}, {0x05, 0x00}, {0x06, 0x00}, {0x0b, 0x00} }, /* IDLE */
129 { {0x1f, 0x00}, {0x0d, 0x00}, {0x00, 0x00}, {0x01, 0x00}, {0x8f, 0x09}, {0x8f, 0x01} }, /* DRSHIFT */
130 { {0x1f, 0x00}, {0x0c, 0x00}, {0x08, 0x00}, {0x00, 0x00}, {0x8f, 0x09}, {0x8f, 0x01} }, /* DRPAUSE */
131 { {0x1f, 0x00}, {0x0d, 0x00}, {0x07, 0x00}, {0x97, 0x00}, {0x00, 0x00}, {0x01, 0x00} }, /* IRSHIFT */
132 { {0x1f, 0x00}, {0x0c, 0x00}, {0x07, 0x00}, {0x97, 0x00}, {0x08, 0x00}, {0x00, 0x00} }, /* IRPAUSE */
133 };
134
135 static void amt_jtagaccel_reset(int trst, int srst)
136 {
137 if (trst == 1)
138 aw_control_rst |= 0x4;
139 else if (trst == 0)
140 aw_control_rst &= ~0x4;
141
142 if (srst == 1)
143 aw_control_rst |= 0x1;
144 else if (srst == 0)
145 aw_control_rst &= ~0x1;
146
147 AMT_AW(aw_control_rst);
148 }
149
150 static int amt_jtagaccel_speed(int speed)
151 {
152 aw_control_baudrate &= 0xf0;
153 aw_control_baudrate |= speed & 0x0f;
154 AMT_AW(aw_control_baudrate);
155
156 return ERROR_OK;
157 }
158
159 static void amt_jtagaccel_end_state(tap_state_t state)
160 {
161 if (tap_is_state_stable(state))
162 tap_set_end_state(state);
163 else {
164 LOG_ERROR("BUG: %i is not a valid end state", state);
165 exit(-1);
166 }
167 }
168
169 static void amt_wait_scan_busy(void)
170 {
171 int timeout = 4096;
172 uint8_t ar_status;
173
174 AMT_AR(ar_status);
175 while (((ar_status) & 0x80) && (timeout-- > 0))
176 AMT_AR(ar_status);
177
178 if (ar_status & 0x80) {
179 LOG_ERROR(
180 "amt_jtagaccel timed out while waiting for end of scan, rtck was %s, last AR_STATUS: 0x%2.2x",
181 (rtck_enabled) ? "enabled" : "disabled",
182 ar_status);
183 exit(-1);
184 }
185 }
186
187 static void amt_jtagaccel_state_move(void)
188 {
189 uint8_t aw_scan_tms_5;
190 uint8_t tms_scan[2];
191
192 tap_state_t cur_state = tap_get_state();
193 tap_state_t end_state = tap_get_end_state();
194
195 tms_scan[0] = amt_jtagaccel_tap_move[tap_move_ndx(cur_state)][tap_move_ndx(end_state)][0];
196 tms_scan[1] = amt_jtagaccel_tap_move[tap_move_ndx(cur_state)][tap_move_ndx(end_state)][1];
197
198 aw_scan_tms_5 = 0x40 | (tms_scan[0] & 0x1f);
199 AMT_AW(aw_scan_tms_5);
200 int jtag_speed = 0;
201 int retval = jtag_get_speed(&jtag_speed);
202 assert(retval == ERROR_OK);
203 if (jtag_speed > 3 || rtck_enabled)
204 amt_wait_scan_busy();
205
206 if (tms_scan[0] & 0x80) {
207 aw_scan_tms_5 = 0x40 | (tms_scan[1] & 0x1f);
208 AMT_AW(aw_scan_tms_5);
209 if (jtag_speed > 3 || rtck_enabled)
210 amt_wait_scan_busy();
211 }
212
213 tap_set_state(end_state);
214 }
215
216 static void amt_jtagaccel_runtest(int num_cycles)
217 {
218 int i = 0;
219 uint8_t aw_scan_tms_5;
220 uint8_t aw_scan_tms_1to4;
221
222 tap_state_t saved_end_state = tap_get_end_state();
223
224 /* only do a state_move when we're not already in IDLE */
225 if (tap_get_state() != TAP_IDLE) {
226 amt_jtagaccel_end_state(TAP_IDLE);
227 amt_jtagaccel_state_move();
228 }
229
230 while (num_cycles - i >= 5) {
231 aw_scan_tms_5 = 0x40;
232 AMT_AW(aw_scan_tms_5);
233 i += 5;
234 }
235
236 if (num_cycles - i > 0) {
237 aw_scan_tms_1to4 = 0x80 | ((num_cycles - i - 1) & 0x3) << 4;
238 AMT_AW(aw_scan_tms_1to4);
239 }
240
241 amt_jtagaccel_end_state(saved_end_state);
242 if (tap_get_state() != tap_get_end_state())
243 amt_jtagaccel_state_move();
244 }
245
246 static void amt_jtagaccel_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size)
247 {
248 int bits_left = scan_size;
249 int bit_count = 0;
250 tap_state_t saved_end_state = tap_get_end_state();
251 uint8_t aw_tdi_option;
252 uint8_t dw_tdi_scan;
253 uint8_t dr_tdo;
254 uint8_t aw_tms_scan;
255 uint8_t tms_scan[2];
256 int jtag_speed_var;
257 int retval = jtag_get_speed(&jtag_speed_var);
258 assert(retval == ERROR_OK);
259
260 if (ir_scan)
261 amt_jtagaccel_end_state(TAP_IRSHIFT);
262 else
263 amt_jtagaccel_end_state(TAP_DRSHIFT);
264
265 /* Only move if we're not already there */
266 if (tap_get_state() != tap_get_end_state())
267 amt_jtagaccel_state_move();
268
269 amt_jtagaccel_end_state(saved_end_state);
270
271 /* handle unaligned bits at the beginning */
272 if ((scan_size - 1) % 8) {
273 aw_tdi_option = 0x30 | (((scan_size - 1) % 8) - 1);
274 AMT_AW(aw_tdi_option);
275
276 dw_tdi_scan = buf_get_u32(buffer, bit_count, (scan_size - 1) % 8) & 0xff;
277 AMT_DW(dw_tdi_scan);
278 if (jtag_speed_var > 3 || rtck_enabled)
279 amt_wait_scan_busy();
280
281 if ((type == SCAN_IN) || (type == SCAN_IO)) {
282 AMT_DR(dr_tdo);
283 dr_tdo = dr_tdo >> (8 - ((scan_size - 1) % 8));
284 buf_set_u32(buffer, bit_count, (scan_size - 1) % 8, dr_tdo);
285 }
286
287 bit_count += (scan_size - 1) % 8;
288 bits_left -= (scan_size - 1) % 8;
289 }
290
291 while (bits_left - 1 >= 8) {
292 dw_tdi_scan = buf_get_u32(buffer, bit_count, 8) & 0xff;
293 AMT_DW(dw_tdi_scan);
294 if (jtag_speed_var > 3 || rtck_enabled)
295 amt_wait_scan_busy();
296
297 if ((type == SCAN_IN) || (type == SCAN_IO)) {
298 AMT_DR(dr_tdo);
299 buf_set_u32(buffer, bit_count, 8, dr_tdo);
300 }
301
302 bit_count += 8;
303 bits_left -= 8;
304 }
305
306 tms_scan[0] =
307 amt_jtagaccel_tap_move[tap_move_ndx(tap_get_state())][tap_move_ndx(tap_get_end_state())][0];
308 tms_scan[1] =
309 amt_jtagaccel_tap_move[tap_move_ndx(tap_get_state())][tap_move_ndx(tap_get_end_state())][1];
310 aw_tms_scan = 0x40 | (tms_scan[0] & 0x1f) | (buf_get_u32(buffer, bit_count, 1) << 5);
311 AMT_AW(aw_tms_scan);
312 if (jtag_speed_var > 3 || rtck_enabled)
313 amt_wait_scan_busy();
314
315 if ((type == SCAN_IN) || (type == SCAN_IO)) {
316 AMT_DR(dr_tdo);
317 dr_tdo = dr_tdo >> 7;
318 buf_set_u32(buffer, bit_count, 1, dr_tdo);
319 }
320
321 if (tms_scan[0] & 0x80) {
322 aw_tms_scan = 0x40 | (tms_scan[1] & 0x1f);
323 AMT_AW(aw_tms_scan);
324 if (jtag_speed_var > 3 || rtck_enabled)
325 amt_wait_scan_busy();
326 }
327 tap_set_state(tap_get_end_state());
328 }
329
330 static int amt_jtagaccel_execute_queue(void)
331 {
332 struct jtag_command *cmd = jtag_command_queue; /* currently processed command */
333 int scan_size;
334 enum scan_type type;
335 uint8_t *buffer;
336 int retval;
337
338 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
339 * that wasn't handled by a caller-provided error handler
340 */
341 retval = ERROR_OK;
342
343 while (cmd) {
344 switch (cmd->type) {
345 case JTAG_RESET:
346 LOG_DEBUG_IO("reset trst: %i srst %i",
347 cmd->cmd.reset->trst,
348 cmd->cmd.reset->srst);
349 if (cmd->cmd.reset->trst == 1)
350 tap_set_state(TAP_RESET);
351 amt_jtagaccel_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
352 break;
353 case JTAG_RUNTEST:
354 LOG_DEBUG_IO("runtest %i cycles, end in %i",
355 cmd->cmd.runtest->num_cycles,
356 cmd->cmd.runtest->end_state);
357 amt_jtagaccel_end_state(cmd->cmd.runtest->end_state);
358 amt_jtagaccel_runtest(cmd->cmd.runtest->num_cycles);
359 break;
360 case JTAG_TLR_RESET:
361 LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
362 amt_jtagaccel_end_state(cmd->cmd.statemove->end_state);
363 amt_jtagaccel_state_move();
364 break;
365 case JTAG_SCAN:
366 LOG_DEBUG_IO("scan end in %i", cmd->cmd.scan->end_state);
367 amt_jtagaccel_end_state(cmd->cmd.scan->end_state);
368 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
369 type = jtag_scan_type(cmd->cmd.scan);
370 amt_jtagaccel_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
371 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
372 retval = ERROR_JTAG_QUEUE_FAILED;
373 free(buffer);
374 break;
375 case JTAG_SLEEP:
376 LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
377 jtag_sleep(cmd->cmd.sleep->us);
378 break;
379 default:
380 LOG_ERROR("BUG: unknown JTAG command type encountered");
381 exit(-1);
382 }
383 cmd = cmd->next;
384 }
385
386 return retval;
387 }
388
389 #if PARPORT_USE_GIVEIO == 1
390 int amt_jtagaccel_get_giveio_access(void)
391 {
392 HANDLE h;
393 OSVERSIONINFO version;
394
395 version.dwOSVersionInfoSize = sizeof(version);
396 if (!GetVersionEx(&version)) {
397 errno = EINVAL;
398 return -1;
399 }
400 if (version.dwPlatformId != VER_PLATFORM_WIN32_NT)
401 return 0;
402
403 h = CreateFile("\\\\.\\giveio",
404 GENERIC_READ,
405 0,
406 NULL,
407 OPEN_EXISTING,
408 FILE_ATTRIBUTE_NORMAL,
409 NULL);
410 if (h == INVALID_HANDLE_VALUE) {
411 errno = ENODEV;
412 return -1;
413 }
414
415 CloseHandle(h);
416
417 return 0;
418 }
419 #endif
420
421 static int amt_jtagaccel_init(void)
422 {
423 #if PARPORT_USE_PPDEV == 1
424 char buffer[256];
425 int i = 0;
426 uint8_t control_port;
427 #else
428 uint8_t status_port;
429 #endif
430 uint8_t ar_status;
431
432 #if PARPORT_USE_PPDEV == 1
433 if (device_handle > 0) {
434 LOG_ERROR("device is already opened");
435 return ERROR_JTAG_INIT_FAILED;
436 }
437
438 snprintf(buffer, 256, "/dev/parport%d", amt_jtagaccel_port);
439 device_handle = open(buffer, O_RDWR);
440
441 if (device_handle < 0) {
442 LOG_ERROR(
443 "cannot open device. check it exists and that user read and write rights are set");
444 return ERROR_JTAG_INIT_FAILED;
445 }
446
447 i = ioctl(device_handle, PPCLAIM);
448 if (i < 0) {
449 LOG_ERROR("cannot claim device");
450 return ERROR_JTAG_INIT_FAILED;
451 }
452
453 i = IEEE1284_MODE_EPP;
454 i = ioctl(device_handle, PPSETMODE, &i);
455 if (i < 0) {
456 LOG_ERROR(" cannot set compatible mode to device");
457 return ERROR_JTAG_INIT_FAILED;
458 }
459
460 control_port = 0x00;
461 i = ioctl(device_handle, PPWCONTROL, &control_port);
462
463 control_port = 0x04;
464 i = ioctl(device_handle, PPWCONTROL, &control_port);
465
466 #else
467 if (amt_jtagaccel_port == 0) {
468 amt_jtagaccel_port = 0x378;
469 LOG_WARNING("No parport port specified, using default '0x378' (LPT1)");
470 }
471
472 #if PARPORT_USE_GIVEIO == 1
473 if (amt_jtagaccel_get_giveio_access() != 0) {
474 #else /* PARPORT_USE_GIVEIO */
475 if (ioperm(amt_jtagaccel_port, 5, 1) != 0) {
476 #endif /* PARPORT_USE_GIVEIO */
477 LOG_ERROR("missing privileges for direct i/o");
478 return ERROR_JTAG_INIT_FAILED;
479 }
480
481 /* prepare epp port
482 * clear timeout */
483 status_port = inb(amt_jtagaccel_port + 1);
484 outb(status_port | 0x1, amt_jtagaccel_port + 1);
485
486 /* reset epp port */
487 outb(0x00, amt_jtagaccel_port + 2);
488 outb(0x04, amt_jtagaccel_port + 2);
489 #endif
490
491 if (rtck_enabled) {
492 /* set RTCK enable bit */
493 aw_control_fsm |= 0x02;
494 }
495
496 /* enable JTAG port */
497 aw_control_fsm |= 0x04;
498 AMT_AW(aw_control_fsm);
499
500 enum reset_types jtag_reset_config = jtag_get_reset_config();
501 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
502 aw_control_rst &= ~0x8;
503 else
504 aw_control_rst |= 0x8;
505
506 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
507 aw_control_rst &= ~0x2;
508 else
509 aw_control_rst |= 0x2;
510
511 amt_jtagaccel_reset(0, 0);
512
513 /* read status register */
514 AMT_AR(ar_status);
515 LOG_DEBUG("AR_STATUS: 0x%2.2x", ar_status);
516
517 return ERROR_OK;
518 }
519
520 static int amt_jtagaccel_quit(void)
521 {
522
523 return ERROR_OK;
524 }
525
526 COMMAND_HANDLER(amt_jtagaccel_handle_parport_port_command)
527 {
528 if (CMD_ARGC == 1) {
529 /* only if the port wasn't overwritten by cmdline */
530 if (amt_jtagaccel_port == 0) {
531 uint16_t port;
532 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], port);
533 amt_jtagaccel_port = port;
534 } else {
535 LOG_ERROR("The parport port was already configured!");
536 return ERROR_FAIL;
537 }
538 }
539
540 command_print(CMD, "parport port = %u", amt_jtagaccel_port);
541
542 return ERROR_OK;
543 }
544
545 COMMAND_HANDLER(amt_jtagaccel_handle_rtck_command)
546 {
547 if (CMD_ARGC == 0) {
548 command_print(CMD,
549 "amt_jtagaccel RTCK feature %s",
550 (rtck_enabled) ? "enabled" : "disabled");
551 return ERROR_OK;
552 } else {
553 if (strcmp(CMD_ARGV[0], "enabled") == 0)
554 rtck_enabled = 1;
555 else
556 rtck_enabled = 0;
557 }
558
559 return ERROR_OK;
560 }
561
562 static const struct command_registration amtjtagaccel_command_handlers[] = {
563 {
564 .name = "parport_port",
565 .handler = &amt_jtagaccel_handle_parport_port_command,
566 .mode = COMMAND_CONFIG,
567 .help = "configure or display the parallel port to use",
568 .usage = "[port_num]",
569 },
570 {
571 /**
572 * @todo Remove this "rtck" command; just use the standard
573 * mechanism to enable/disable adaptive clocking. First
574 * implement the standard mechanism and deprecate "rtck";
575 * after a year or so, it'll be safe to remove this.
576 */
577 .name = "rtck",
578 .handler = &amt_jtagaccel_handle_rtck_command,
579 .mode = COMMAND_CONFIG,
580 .help = "configure or display RTCK support",
581 .usage = "[enable|disable]",
582 },
583 COMMAND_REGISTRATION_DONE
584 };
585
586 static struct jtag_interface amt_jtagaccel_interface = {
587 .execute_queue = amt_jtagaccel_execute_queue,
588 };
589
590 struct adapter_driver amt_jtagaccel_adapter_driver = {
591 .name = "amt_jtagaccel",
592 .transports = jtag_only,
593 .commands = amtjtagaccel_command_handlers,
594
595 .init = amt_jtagaccel_init,
596 .quit = amt_jtagaccel_quit,
597 .speed = amt_jtagaccel_speed,
598
599 .jtag_ops = &amt_jtagaccel_interface,
600 };
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)