Code Review / openocd.git / blob
? search:


3a589a3a50b82d79c6230ae8a2eb746803756573
[openocd.git] / src / jtag / drivers / parport.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
20 ***************************************************************************/
21
22 #ifdef HAVE_CONFIG_H
23 #include "config.h"
24 #endif
25
26 #include <jtag/interface.h>
27 #include "bitbang.h"
28
29 /* -ino: 060521-1036 */
30 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
31 #include <machine/sysarch.h>
32 #include <machine/cpufunc.h>
33 #define ioperm(startport, length, enable)\
34 i386_set_ioperm((startport), (length), (enable))
35 #endif /* __FreeBSD__ */
36
37 #if PARPORT_USE_PPDEV == 1
38 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
39 #include <dev/ppbus/ppi.h>
40 #include <dev/ppbus/ppbconf.h>
41 #define PPRSTATUS PPIGSTATUS
42 #define PPWDATA PPISDATA
43 #else
44 #include <linux/parport.h>
45 #include <linux/ppdev.h>
46 #endif
47 #include <sys/ioctl.h>
48 #else /* not PARPORT_USE_PPDEV */
49 #ifndef _WIN32
50 #include <sys/io.h>
51 #endif
52 #endif
53
54 #if PARPORT_USE_GIVEIO == 1 && IS_CYGWIN == 1
55 #include <windows.h>
56 #endif
57
58 /* parallel port cable description
59 */
60 struct cable {
61 const char *name;
62 uint8_t TDO_MASK; /* status port bit containing current TDO value */
63 uint8_t TRST_MASK; /* data port bit for TRST */
64 uint8_t TMS_MASK; /* data port bit for TMS */
65 uint8_t TCK_MASK; /* data port bit for TCK */
66 uint8_t TDI_MASK; /* data port bit for TDI */
67 uint8_t SRST_MASK; /* data port bit for SRST */
68 uint8_t OUTPUT_INVERT; /* data port bits that should be inverted */
69 uint8_t INPUT_INVERT; /* status port that should be inverted */
70 uint8_t PORT_INIT; /* initialize data port with this value */
71 uint8_t PORT_EXIT; /* de-initialize data port with this value */
72 uint8_t LED_MASK; /* data port bit for LED */
73 };
74
75 static const struct cable cables[] = {
76 /* name tdo trst tms tck tdi srst o_inv i_inv init exit led */
77 { "wiggler", 0x80, 0x10, 0x02, 0x04, 0x08, 0x01, 0x01, 0x80, 0x80, 0x80, 0x00 },
78 { "wiggler2", 0x80, 0x10, 0x02, 0x04, 0x08, 0x01, 0x01, 0x80, 0x80, 0x00, 0x20 },
79 { "wiggler_ntrst_inverted", 0x80, 0x10, 0x02, 0x04, 0x08, 0x01, 0x11, 0x80, 0x80, 0x80, 0x00 },
80 { "old_amt_wiggler", 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x11, 0x80, 0x80, 0x80, 0x00 },
81 { "arm-jtag", 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x01, 0x80, 0x80, 0x80, 0x00 },
82 { "chameleon", 0x80, 0x00, 0x04, 0x01, 0x02, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00 },
83 { "dlc5", 0x10, 0x00, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00 },
84 { "triton", 0x80, 0x08, 0x04, 0x01, 0x02, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00 },
85 { "lattice", 0x40, 0x10, 0x04, 0x02, 0x01, 0x08, 0x00, 0x00, 0x18, 0x18, 0x00 },
86 { "flashlink", 0x20, 0x10, 0x02, 0x01, 0x04, 0x20, 0x30, 0x20, 0x00, 0x00, 0x00 },
87 /* Altium Universal JTAG cable. Set the cable to Xilinx Mode and wire to target as follows:
88 HARD TCK - Target TCK
89 HARD TMS - Target TMS
90 HARD TDI - Target TDI
91 HARD TDO - Target TDO
92 SOFT TCK - Target TRST
93 SOFT TDI - Target SRST
94 */
95 { "altium", 0x10, 0x20, 0x04, 0x02, 0x01, 0x80, 0x00, 0x00, 0x10, 0x00, 0x08 },
96 { "aspo", 0x10, 0x01, 0x04, 0x08, 0x02, 0x10, 0x17, 0x00, 0x17, 0x17, 0x00 },
97 { NULL, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
98 };
99
100 /* configuration */
101 static char *parport_cable;
102 static uint16_t parport_port;
103 static bool parport_exit;
104 static uint32_t parport_toggling_time_ns = 1000;
105 static int wait_states;
106
107 /* interface variables
108 */
109 static const struct cable *cable;
110 static uint8_t dataport_value;
111
112 #if PARPORT_USE_PPDEV == 1
113 static int device_handle;
114 #else
115 static unsigned long dataport;
116 static unsigned long statusport;
117 #endif
118
119 static bb_value_t parport_read(void)
120 {
121 int data = 0;
122
123 #if PARPORT_USE_PPDEV == 1
124 ioctl(device_handle, PPRSTATUS, &data);
125 #else
126 data = inb(statusport);
127 #endif
128
129 if ((data ^ cable->INPUT_INVERT) & cable->TDO_MASK)
130 return BB_HIGH;
131 else
132 return BB_LOW;
133 }
134
135 static inline void parport_write_data(void)
136 {
137 uint8_t output;
138 output = dataport_value ^ cable->OUTPUT_INVERT;
139
140 #if PARPORT_USE_PPDEV == 1
141 ioctl(device_handle, PPWDATA, &output);
142 #else
143 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
144 outb(dataport, output);
145 #else
146 outb(output, dataport);
147 #endif
148 #endif
149 }
150
151 static int parport_write(int tck, int tms, int tdi)
152 {
153 int i = wait_states + 1;
154
155 if (tck)
156 dataport_value |= cable->TCK_MASK;
157 else
158 dataport_value &= ~cable->TCK_MASK;
159
160 if (tms)
161 dataport_value |= cable->TMS_MASK;
162 else
163 dataport_value &= ~cable->TMS_MASK;
164
165 if (tdi)
166 dataport_value |= cable->TDI_MASK;
167 else
168 dataport_value &= ~cable->TDI_MASK;
169
170 while (i-- > 0)
171 parport_write_data();
172
173 return ERROR_OK;
174 }
175
176 /* (1) assert or (0) deassert reset lines */
177 static int parport_reset(int trst, int srst)
178 {
179 LOG_DEBUG("trst: %i, srst: %i", trst, srst);
180
181 if (trst == 0)
182 dataport_value |= cable->TRST_MASK;
183 else if (trst == 1)
184 dataport_value &= ~cable->TRST_MASK;
185
186 if (srst == 0)
187 dataport_value |= cable->SRST_MASK;
188 else if (srst == 1)
189 dataport_value &= ~cable->SRST_MASK;
190
191 parport_write_data();
192
193 return ERROR_OK;
194 }
195
196 /* turn LED on parport adapter on (1) or off (0) */
197 static int parport_led(int on)
198 {
199 if (on)
200 dataport_value |= cable->LED_MASK;
201 else
202 dataport_value &= ~cable->LED_MASK;
203
204 parport_write_data();
205
206 return ERROR_OK;
207 }
208
209 static int parport_speed(int speed)
210 {
211 wait_states = speed;
212 return ERROR_OK;
213 }
214
215 static int parport_khz(int khz, int *jtag_speed)
216 {
217 if (khz == 0) {
218 LOG_DEBUG("RCLK not supported");
219 return ERROR_FAIL;
220 }
221
222 *jtag_speed = 499999 / (khz * parport_toggling_time_ns);
223 return ERROR_OK;
224 }
225
226 static int parport_speed_div(int speed, int *khz)
227 {
228 uint32_t denominator = (speed + 1) * parport_toggling_time_ns;
229
230 *khz = (499999 + denominator) / denominator;
231 return ERROR_OK;
232 }
233
234 #if PARPORT_USE_GIVEIO == 1
235 static int parport_get_giveio_access(void)
236 {
237 HANDLE h;
238 OSVERSIONINFO version;
239
240 version.dwOSVersionInfoSize = sizeof version;
241 if (!GetVersionEx(&version)) {
242 errno = EINVAL;
243 return -1;
244 }
245 if (version.dwPlatformId != VER_PLATFORM_WIN32_NT)
246 return 0;
247
248 h = CreateFile("\\\\.\\giveio", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
249 if (h == INVALID_HANDLE_VALUE) {
250 errno = ENODEV;
251 return -1;
252 }
253
254 CloseHandle(h);
255
256 return 0;
257 }
258 #endif
259
260 static struct bitbang_interface parport_bitbang = {
261 .read = &parport_read,
262 .write = &parport_write,
263 .blink = &parport_led,
264 };
265
266 static int parport_init(void)
267 {
268 const struct cable *cur_cable;
269 #if PARPORT_USE_PPDEV == 1
270 char buffer[256];
271 #endif
272
273 cur_cable = cables;
274
275 if (parport_cable == NULL) {
276 parport_cable = strdup("wiggler");
277 LOG_WARNING("No parport cable specified, using default 'wiggler'");
278 }
279
280 while (cur_cable->name) {
281 if (strcmp(cur_cable->name, parport_cable) == 0) {
282 cable = cur_cable;
283 break;
284 }
285 cur_cable++;
286 }
287
288 if (!cable) {
289 LOG_ERROR("No matching cable found for %s", parport_cable);
290 return ERROR_JTAG_INIT_FAILED;
291 }
292
293 dataport_value = cable->PORT_INIT;
294
295 #if PARPORT_USE_PPDEV == 1
296 if (device_handle > 0) {
297 LOG_ERROR("device is already opened");
298 return ERROR_JTAG_INIT_FAILED;
299 }
300
301 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
302 LOG_DEBUG("opening /dev/ppi%d...", parport_port);
303
304 snprintf(buffer, 256, "/dev/ppi%d", parport_port);
305 device_handle = open(buffer, O_WRONLY);
306 #else /* not __FreeBSD__, __FreeBSD_kernel__ */
307 LOG_DEBUG("opening /dev/parport%d...", parport_port);
308
309 snprintf(buffer, 256, "/dev/parport%d", parport_port);
310 device_handle = open(buffer, O_WRONLY);
311 #endif /* __FreeBSD__, __FreeBSD_kernel__ */
312
313 if (device_handle < 0) {
314 int err = errno;
315 LOG_ERROR("cannot open device. check it exists and that user read and write rights are set. errno=%d", err);
316 return ERROR_JTAG_INIT_FAILED;
317 }
318
319 LOG_DEBUG("...open");
320
321 #if !defined(__FreeBSD__) && !defined(__FreeBSD_kernel__)
322 int i = ioctl(device_handle, PPCLAIM);
323
324 if (i < 0) {
325 LOG_ERROR("cannot claim device");
326 return ERROR_JTAG_INIT_FAILED;
327 }
328
329 i = PARPORT_MODE_COMPAT;
330 i = ioctl(device_handle, PPSETMODE, &i);
331 if (i < 0) {
332 LOG_ERROR(" cannot set compatible mode to device");
333 return ERROR_JTAG_INIT_FAILED;
334 }
335
336 i = IEEE1284_MODE_COMPAT;
337 i = ioctl(device_handle, PPNEGOT, &i);
338 if (i < 0) {
339 LOG_ERROR("cannot set compatible 1284 mode to device");
340 return ERROR_JTAG_INIT_FAILED;
341 }
342 #endif /* not __FreeBSD__, __FreeBSD_kernel__ */
343
344 #else /* not PARPORT_USE_PPDEV */
345 if (parport_port == 0) {
346 parport_port = 0x378;
347 LOG_WARNING("No parport port specified, using default '0x378' (LPT1)");
348 }
349
350 dataport = parport_port;
351 statusport = parport_port + 1;
352
353 LOG_DEBUG("requesting privileges for parallel port 0x%lx...", dataport);
354 #if PARPORT_USE_GIVEIO == 1
355 if (parport_get_giveio_access() != 0) {
356 #else /* PARPORT_USE_GIVEIO */
357 if (ioperm(dataport, 3, 1) != 0) {
358 #endif /* PARPORT_USE_GIVEIO */
359 LOG_ERROR("missing privileges for direct i/o");
360 return ERROR_JTAG_INIT_FAILED;
361 }
362 LOG_DEBUG("...privileges granted");
363
364 /* make sure parallel port is in right mode (clear tristate and interrupt */
365 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
366 outb(parport_port + 2, 0x0);
367 #else
368 outb(0x0, parport_port + 2);
369 #endif
370
371 #endif /* PARPORT_USE_PPDEV */
372
373 if (parport_reset(0, 0) != ERROR_OK)
374 return ERROR_FAIL;
375 if (parport_write(0, 0, 0) != ERROR_OK)
376 return ERROR_FAIL;
377 if (parport_led(1) != ERROR_OK)
378 return ERROR_FAIL;
379
380 bitbang_interface = &parport_bitbang;
381
382 return ERROR_OK;
383 }
384
385 static int parport_quit(void)
386 {
387 if (parport_led(0) != ERROR_OK)
388 return ERROR_FAIL;
389
390 if (parport_exit) {
391 dataport_value = cable->PORT_EXIT;
392 parport_write_data();
393 }
394
395 if (parport_cable) {
396 free(parport_cable);
397 parport_cable = NULL;
398 }
399
400 return ERROR_OK;
401 }
402
403 COMMAND_HANDLER(parport_handle_parport_port_command)
404 {
405 if (CMD_ARGC == 1) {
406 /* only if the port wasn't overwritten by cmdline */
407 if (parport_port == 0)
408 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], parport_port);
409 else {
410 LOG_ERROR("The parport port was already configured!");
411 return ERROR_FAIL;
412 }
413 }
414
415 command_print(CMD, "parport port = 0x%" PRIx16 "", parport_port);
416
417 return ERROR_OK;
418 }
419
420 COMMAND_HANDLER(parport_handle_parport_cable_command)
421 {
422 if (CMD_ARGC == 0)
423 return ERROR_OK;
424
425 /* only if the cable name wasn't overwritten by cmdline */
426 if (parport_cable == 0) {
427 /* REVISIT first verify that it's listed in cables[] ... */
428 parport_cable = malloc(strlen(CMD_ARGV[0]) + sizeof(char));
429 strcpy(parport_cable, CMD_ARGV[0]);
430 }
431
432 /* REVISIT it's probably worth returning the current value ... */
433
434 return ERROR_OK;
435 }
436
437 COMMAND_HANDLER(parport_handle_write_on_exit_command)
438 {
439 if (CMD_ARGC != 1)
440 return ERROR_COMMAND_SYNTAX_ERROR;
441
442 COMMAND_PARSE_ON_OFF(CMD_ARGV[0], parport_exit);
443
444 return ERROR_OK;
445 }
446
447 COMMAND_HANDLER(parport_handle_parport_toggling_time_command)
448 {
449 if (CMD_ARGC == 1) {
450 uint32_t ns;
451 int retval = parse_u32(CMD_ARGV[0], &ns);
452
453 if (ERROR_OK != retval)
454 return retval;
455
456 if (ns == 0) {
457 LOG_ERROR("0 ns is not a valid parport toggling time");
458 return ERROR_FAIL;
459 }
460
461 parport_toggling_time_ns = ns;
462 retval = jtag_get_speed(&wait_states);
463 if (retval != ERROR_OK) {
464 /* if jtag_get_speed fails then the clock_mode
465 * has not been configured, this happens if parport_toggling_time is
466 * called before the adapter speed is set */
467 LOG_INFO("no parport speed set - defaulting to zero wait states");
468 wait_states = 0;
469 }
470 }
471
472 command_print(CMD, "parport toggling time = %" PRIu32 " ns",
473 parport_toggling_time_ns);
474
475 return ERROR_OK;
476 }
477
478 static const struct command_registration parport_command_handlers[] = {
479 {
480 .name = "parport_port",
481 .handler = parport_handle_parport_port_command,
482 .mode = COMMAND_CONFIG,
483 .help = "Display the address of the I/O port (e.g. 0x378) "
484 "or the number of the '/dev/parport' device used. "
485 "If a parameter is provided, first change that port.",
486 .usage = "[port_number]",
487 },
488 {
489 .name = "parport_cable",
490 .handler = parport_handle_parport_cable_command,
491 .mode = COMMAND_CONFIG,
492 .help = "Set the layout of the parallel port cable "
493 "used to connect to the target.",
494 /* REVISIT there's no way to list layouts we know ... */
495 .usage = "[layout]",
496 },
497 {
498 .name = "parport_write_on_exit",
499 .handler = parport_handle_write_on_exit_command,
500 .mode = COMMAND_CONFIG,
501 .help = "Configure the parallel driver to write "
502 "a known value to the parallel interface on exit.",
503 .usage = "('on'|'off')",
504 },
505 {
506 .name = "parport_toggling_time",
507 .handler = parport_handle_parport_toggling_time_command,
508 .mode = COMMAND_CONFIG,
509 .help = "Displays or assigns how many nanoseconds it "
510 "takes for the hardware to toggle TCK.",
511 .usage = "[nanoseconds]",
512 },
513 COMMAND_REGISTRATION_DONE
514 };
515
516 struct jtag_interface parport_interface = {
517 .name = "parport",
518 .supported = DEBUG_CAP_TMS_SEQ,
519 .transports = jtag_only,
520 .commands = parport_command_handlers,
521
522 .init = parport_init,
523 .quit = parport_quit,
524 .reset = parport_reset,
525 .khz = parport_khz,
526 .speed_div = parport_speed_div,
527 .speed = parport_speed,
528 .execute_queue = bitbang_execute_queue,
529 };
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)