Code Review / openocd.git / blob
? search:


5e329d42f23403edd9d213dab78453dd4062846f
[openocd.git] / src / jtag / 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, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
27 #include "interface.h"
28 #include "bitbang.h"
29
30 /* -ino: 060521-1036 */
31 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
32 #include <machine/sysarch.h>
33 #include <machine/cpufunc.h>
34 #define ioperm(startport,length,enable)\
35 i386_set_ioperm((startport), (length), (enable))
36 #endif /* __FreeBSD__ */
37
38 #if PARPORT_USE_PPDEV == 1
39 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
40 #include <dev/ppbus/ppi.h>
41 #include <dev/ppbus/ppbconf.h>
42 #define PPRSTATUS PPIGSTATUS
43 #define PPWDATA PPISDATA
44 #else
45 #include <linux/parport.h>
46 #include <linux/ppdev.h>
47 #endif
48 #include <sys/ioctl.h>
49 #else /* not PARPORT_USE_PPDEV */
50 #ifndef _WIN32
51 #include <sys/io.h>
52 #endif
53 #endif
54
55 #if PARPORT_USE_GIVEIO == 1 && IS_CYGWIN == 1
56 #include <windows.h>
57 #endif
58
59
60 /* parallel port cable description
61 */
62 typedef struct cable_s
63 {
64 char* name;
65 uint8_t TDO_MASK; /* status port bit containing current TDO value */
66 uint8_t TRST_MASK; /* data port bit for TRST */
67 uint8_t TMS_MASK; /* data port bit for TMS */
68 uint8_t TCK_MASK; /* data port bit for TCK */
69 uint8_t TDI_MASK; /* data port bit for TDI */
70 uint8_t SRST_MASK; /* data port bit for SRST */
71 uint8_t OUTPUT_INVERT; /* data port bits that should be inverted */
72 uint8_t INPUT_INVERT; /* status port that should be inverted */
73 uint8_t PORT_INIT; /* initialize data port with this value */
74 uint8_t PORT_EXIT; /* de-initialize data port with this value */
75 uint8_t LED_MASK; /* data port bit for LED */
76 } cable_t;
77
78 static cable_t cables[] =
79 {
80 /* name tdo trst tms tck tdi srst o_inv i_inv init exit led */
81 { "wiggler", 0x80, 0x10, 0x02, 0x04, 0x08, 0x01, 0x01, 0x80, 0x80, 0x80, 0x00 },
82 { "wiggler2", 0x80, 0x10, 0x02, 0x04, 0x08, 0x01, 0x01, 0x80, 0x80, 0x00, 0x20 },
83 { "wiggler_ntrst_inverted",
84 0x80, 0x10, 0x02, 0x04, 0x08, 0x01, 0x11, 0x80, 0x80, 0x80, 0x00 },
85 { "old_amt_wiggler", 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x11, 0x80, 0x80, 0x80, 0x00 },
86 { "arm-jtag", 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x01, 0x80, 0x80, 0x80, 0x00 },
87 { "chameleon", 0x80, 0x00, 0x04, 0x01, 0x02, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00 },
88 { "dlc5", 0x10, 0x00, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00 },
89 { "triton", 0x80, 0x08, 0x04, 0x01, 0x02, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00 },
90 { "lattice", 0x40, 0x10, 0x04, 0x02, 0x01, 0x08, 0x00, 0x00, 0x18, 0x18, 0x00 },
91 { "flashlink", 0x20, 0x10, 0x02, 0x01, 0x04, 0x20, 0x30, 0x20, 0x00, 0x00, 0x00 },
92 /* Altium Universal JTAG cable. Set the cable to Xilinx Mode and wire to target as follows:
93 HARD TCK - Target TCK
94 HARD TMS - Target TMS
95 HARD TDI - Target TDI
96 HARD TDO - Target TDO
97 SOFT TCK - Target TRST
98 SOFT TDI - Target SRST
99 */
100 { "altium", 0x10, 0x20, 0x04, 0x02, 0x01, 0x80, 0x00, 0x00, 0x10, 0x00, 0x08 },
101 { NULL, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
102 };
103
104 /* configuration */
105 static char* parport_cable = NULL;
106 static uint16_t parport_port;
107 static int parport_exit = 0;
108
109 /* interface variables
110 */
111 static cable_t* cable;
112 static uint8_t dataport_value = 0x0;
113
114 #if PARPORT_USE_PPDEV == 1
115 static int device_handle;
116 #else
117 static unsigned long dataport;
118 static unsigned long statusport;
119 #endif
120
121 /* low level command set
122 */
123 static int parport_read(void);
124 static void parport_write(int tck, int tms, int tdi);
125 static void parport_reset(int trst, int srst);
126 static void parport_led(int on);
127
128 static int parport_speed(int speed);
129 static int parport_register_commands(struct command_context_s *cmd_ctx);
130 static int parport_init(void);
131 static int parport_quit(void);
132
133 /* interface commands */
134 static int parport_handle_parport_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
135 static int parport_handle_parport_cable_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
136 static int parport_handle_write_on_exit_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
137
138 jtag_interface_t parport_interface =
139 {
140 .name = "parport",
141
142 .execute_queue = bitbang_execute_queue,
143
144 .speed = parport_speed,
145 .register_commands = parport_register_commands,
146 .init = parport_init,
147 .quit = parport_quit,
148 };
149
150 static bitbang_interface_t parport_bitbang =
151 {
152 .read = parport_read,
153 .write = parport_write,
154 .reset = parport_reset,
155 .blink = parport_led
156 };
157
158 static int parport_read(void)
159 {
160 int data = 0;
161
162 #if PARPORT_USE_PPDEV == 1
163 ioctl(device_handle, PPRSTATUS, & data);
164 #else
165 data = inb(statusport);
166 #endif
167
168 if ((data ^ cable->INPUT_INVERT) & cable->TDO_MASK)
169 return 1;
170 else
171 return 0;
172 }
173
174 static __inline__ void parport_write_data(void)
175 {
176 uint8_t output;
177 output = dataport_value ^ cable->OUTPUT_INVERT;
178
179 #if PARPORT_USE_PPDEV == 1
180 ioctl(device_handle, PPWDATA, &output);
181 #else
182 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
183 outb(dataport, output);
184 #else
185 outb(output, dataport);
186 #endif
187 #endif
188 }
189
190 static void parport_write(int tck, int tms, int tdi)
191 {
192 int i = jtag_get_speed() + 1;
193
194 if (tck)
195 dataport_value |= cable->TCK_MASK;
196 else
197 dataport_value &= ~cable->TCK_MASK;
198
199 if (tms)
200 dataport_value |= cable->TMS_MASK;
201 else
202 dataport_value &= ~cable->TMS_MASK;
203
204 if (tdi)
205 dataport_value |= cable->TDI_MASK;
206 else
207 dataport_value &= ~cable->TDI_MASK;
208
209 while (i-- > 0)
210 parport_write_data();
211 }
212
213 /* (1) assert or (0) deassert reset lines */
214 static void parport_reset(int trst, int srst)
215 {
216 LOG_DEBUG("trst: %i, srst: %i", trst, srst);
217
218 if (trst == 0)
219 dataport_value |= cable->TRST_MASK;
220 else if (trst == 1)
221 dataport_value &= ~cable->TRST_MASK;
222
223 if (srst == 0)
224 dataport_value |= cable->SRST_MASK;
225 else if (srst == 1)
226 dataport_value &= ~cable->SRST_MASK;
227
228 parport_write_data();
229 }
230
231 /* turn LED on parport adapter on (1) or off (0) */
232 static void parport_led(int on)
233 {
234 if (on)
235 dataport_value |= cable->LED_MASK;
236 else
237 dataport_value &= ~cable->LED_MASK;
238
239 parport_write_data();
240 }
241
242 static int parport_speed(int speed)
243 {
244 return ERROR_OK;
245 }
246
247 static int parport_register_commands(struct command_context_s *cmd_ctx)
248 {
249 register_command(cmd_ctx, NULL, "parport_port", parport_handle_parport_port_command,
250 COMMAND_CONFIG, "either the address of the I/O port or the number of the \91/dev/parport\92 device");
251 register_command(cmd_ctx, NULL, "parport_cable", parport_handle_parport_cable_command,
252 COMMAND_CONFIG, "the layout of the parallel port cable used to connect to the target");
253 register_command(cmd_ctx, NULL, "parport_write_on_exit", parport_handle_write_on_exit_command,
254 COMMAND_CONFIG, "configure the parallel driver to write a known value to the parallel interface");
255
256 return ERROR_OK;
257 }
258
259 #if PARPORT_USE_GIVEIO == 1
260 static int parport_get_giveio_access(void)
261 {
262 HANDLE h;
263 OSVERSIONINFO version;
264
265 version.dwOSVersionInfoSize = sizeof version;
266 if (!GetVersionEx( &version )) {
267 errno = EINVAL;
268 return -1;
269 }
270 if (version.dwPlatformId != VER_PLATFORM_WIN32_NT)
271 return 0;
272
273 h = CreateFile( "\\\\.\\giveio", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
274 if (h == INVALID_HANDLE_VALUE) {
275 errno = ENODEV;
276 return -1;
277 }
278
279 CloseHandle( h );
280
281 return 0;
282 }
283 #endif
284
285 static int parport_init(void)
286 {
287 cable_t *cur_cable;
288 #if PARPORT_USE_PPDEV == 1
289 char buffer[256];
290 int i = 0;
291 #endif
292
293 cur_cable = cables;
294
295 if ((parport_cable == NULL) || (parport_cable[0] == 0))
296 {
297 parport_cable = "wiggler";
298 LOG_WARNING("No parport cable specified, using default 'wiggler'");
299 }
300
301 while (cur_cable->name)
302 {
303 if (strcmp(cur_cable->name, parport_cable) == 0)
304 {
305 cable = cur_cable;
306 break;
307 }
308 cur_cable++;
309 }
310
311 if (!cable)
312 {
313 LOG_ERROR("No matching cable found for %s", parport_cable);
314 return ERROR_JTAG_INIT_FAILED;
315 }
316
317 dataport_value = cable->PORT_INIT;
318
319 #if PARPORT_USE_PPDEV == 1
320 if (device_handle > 0)
321 {
322 LOG_ERROR("device is already opened");
323 return ERROR_JTAG_INIT_FAILED;
324 }
325
326 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
327 LOG_DEBUG("opening /dev/ppi%d...", parport_port);
328
329 snprintf(buffer, 256, "/dev/ppi%d", parport_port);
330 device_handle = open(buffer, O_WRONLY);
331 #else /* not __FreeBSD__, __FreeBSD_kernel__ */
332 LOG_DEBUG("opening /dev/parport%d...", parport_port);
333
334 snprintf(buffer, 256, "/dev/parport%d", parport_port);
335 device_handle = open(buffer, O_WRONLY);
336 #endif /* __FreeBSD__, __FreeBSD_kernel__ */
337
338 if (device_handle < 0)
339 {
340 LOG_ERROR("cannot open device. check it exists and that user read and write rights are set");
341 return ERROR_JTAG_INIT_FAILED;
342 }
343
344 LOG_DEBUG("...open");
345
346 #if !defined(__FreeBSD__) && !defined(__FreeBSD_kernel__)
347 i = ioctl(device_handle, PPCLAIM);
348 if (i<0)
349 {
350 LOG_ERROR("cannot claim device");
351 return ERROR_JTAG_INIT_FAILED;
352 }
353
354 i = PARPORT_MODE_COMPAT;
355 i= ioctl(device_handle, PPSETMODE, & i);
356 if (i<0)
357 {
358 LOG_ERROR(" cannot set compatible mode to device");
359 return ERROR_JTAG_INIT_FAILED;
360 }
361
362 i = IEEE1284_MODE_COMPAT;
363 i = ioctl(device_handle, PPNEGOT, & i);
364 if (i<0)
365 {
366 LOG_ERROR("cannot set compatible 1284 mode to device");
367 return ERROR_JTAG_INIT_FAILED;
368 }
369 #endif /* not __FreeBSD__, __FreeBSD_kernel__ */
370
371 #else /* not PARPORT_USE_PPDEV */
372 if (parport_port == 0)
373 {
374 parport_port = 0x378;
375 LOG_WARNING("No parport port specified, using default '0x378' (LPT1)");
376 }
377
378 dataport = parport_port;
379 statusport = parport_port + 1;
380
381 LOG_DEBUG("requesting privileges for parallel port 0x%lx...", dataport);
382 #if PARPORT_USE_GIVEIO == 1
383 if (parport_get_giveio_access() != 0)
384 #else /* PARPORT_USE_GIVEIO */
385 if (ioperm(dataport, 3, 1) != 0)
386 #endif /* PARPORT_USE_GIVEIO */
387 {
388 LOG_ERROR("missing privileges for direct i/o");
389 return ERROR_JTAG_INIT_FAILED;
390 }
391 LOG_DEBUG("...privileges granted");
392
393 /* make sure parallel port is in right mode (clear tristate and interrupt */
394 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
395 outb(parport_port + 2, 0x0);
396 #else
397 outb(0x0, parport_port + 2);
398 #endif
399
400 #endif /* PARPORT_USE_PPDEV */
401
402 parport_reset(0, 0);
403 parport_write(0, 0, 0);
404 parport_led(1);
405
406 bitbang_interface = &parport_bitbang;
407
408 return ERROR_OK;
409 }
410
411 static int parport_quit(void)
412 {
413 parport_led(0);
414
415 if (parport_exit)
416 {
417 dataport_value = cable->PORT_EXIT;
418 parport_write_data();
419 }
420
421 if (parport_cable)
422 {
423 free(parport_cable);
424 parport_cable = NULL;
425 }
426
427 return ERROR_OK;
428 }
429
430 static int parport_handle_parport_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
431 {
432 if (argc == 1)
433 {
434 /* only if the port wasn't overwritten by cmdline */
435 if (parport_port == 0)
436 {
437 int retval = parse_u16(args[0], &parport_port);
438 if (ERROR_OK != retval)
439 return retval;
440 }
441 else
442 {
443 LOG_ERROR("The parport port was already configured!");
444 return ERROR_FAIL;
445 }
446 }
447
448 command_print(cmd_ctx, "parport port = %u", parport_port);
449
450 return ERROR_OK;
451 }
452
453 static int parport_handle_parport_cable_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
454 {
455 if (argc == 0)
456 return ERROR_OK;
457
458 /* only if the cable name wasn't overwritten by cmdline */
459 if (parport_cable == 0)
460 {
461 parport_cable = malloc(strlen(args[0]) + sizeof(char));
462 strcpy(parport_cable, args[0]);
463 }
464
465 return ERROR_OK;
466 }
467
468 static int parport_handle_write_on_exit_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
469 {
470 if (argc != 1)
471 {
472 command_print(cmd_ctx, "usage: parport_write_on_exit <on|off>");
473 return ERROR_OK;
474 }
475
476 if (strcmp(args[0], "on") == 0)
477 parport_exit = 1;
478 else if (strcmp(args[0], "off") == 0)
479 parport_exit = 0;
480
481 return ERROR_OK;
482 }
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)