Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Convert DEBUG_JTAG_IO to LOG_DEBUG_IO
[openocd.git] / src / jtag / drivers / buspirate.c
1 /***************************************************************************
2 * Copyright (C) 2010 by Michal Demin *
3 * based on usbprog.c and arm-jtag-ew.c *
4 * Several fixes by R. Diez in 2013. *
5 * *
6 * This program is free software; you can redistribute it and/or modify *
7 * it under the terms of the GNU General Public License as published by *
8 * the Free Software Foundation; either version 2 of the License, or *
9 * (at your option) any later version. *
10 * *
11 * This program is distributed in the hope that it will be useful, *
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
14 * GNU General Public License for more details. *
15 * *
16 * You should have received a copy of the GNU General Public License *
17 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
18 ***************************************************************************/
19
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include <jtag/interface.h>
25 #include <jtag/swd.h>
26 #include <jtag/commands.h>
27
28 #include <termios.h>
29 #include <fcntl.h>
30 #include <sys/ioctl.h>
31
32 #undef DEBUG_SERIAL
33 /*#define DEBUG_SERIAL */
34 static int buspirate_execute_queue(void);
35 static int buspirate_init(void);
36 static int buspirate_quit(void);
37
38 static void buspirate_end_state(tap_state_t state);
39 static void buspirate_state_move(void);
40 static void buspirate_path_move(int num_states, tap_state_t *path);
41 static void buspirate_runtest(int num_cycles);
42 static void buspirate_scan(bool ir_scan, enum scan_type type,
43 uint8_t *buffer, int scan_size, struct scan_command *command);
44 static void buspirate_stableclocks(int num_cycles);
45
46 #define CMD_UNKNOWN 0x00
47 #define CMD_PORT_MODE 0x01
48 #define CMD_FEATURE 0x02
49 #define CMD_READ_ADCS 0x03
50 /*#define CMD_TAP_SHIFT 0x04 // old protocol */
51 #define CMD_TAP_SHIFT 0x05
52 #define CMD_ENTER_RWIRE 0x05
53 #define CMD_ENTER_OOCD 0x06
54 #define CMD_UART_SPEED 0x07
55 #define CMD_JTAG_SPEED 0x08
56 #define CMD_RAW_PERIPH 0x40
57 #define CMD_RAW_SPEED 0x60
58 #define CMD_RAW_MODE 0x80
59
60 /* raw-wire mode configuration */
61 #define CMD_RAW_CONFIG_HIZ 0x00
62 #define CMD_RAW_CONFIG_3V3 0x08
63 #define CMD_RAW_CONFIG_2W 0x00
64 #define CMD_RAW_CONFIG_3W 0x04
65 #define CMD_RAW_CONFIG_MSB 0x00
66 #define CMD_RAW_CONFIG_LSB 0x02
67
68 /* Not all OSes have this speed defined */
69 #if !defined(B1000000)
70 #define B1000000 0010010
71 #endif
72
73 enum {
74 MODE_HIZ = 0,
75 MODE_JTAG = 1, /* push-pull outputs */
76 MODE_JTAG_OD = 2, /* open-drain outputs */
77 };
78
79 enum {
80 FEATURE_LED = 0x01,
81 FEATURE_VREG = 0x02,
82 FEATURE_TRST = 0x04,
83 FEATURE_SRST = 0x08,
84 FEATURE_PULLUP = 0x10
85 };
86
87 enum {
88 ACTION_DISABLE = 0,
89 ACTION_ENABLE = 1
90 };
91
92 enum {
93 SERIAL_NORMAL = 0,
94 SERIAL_FAST = 1
95 };
96
97 enum {
98 SPEED_RAW_5_KHZ = 0x0,
99 SPEED_RAW_50_KHZ = 0x1,
100 SPEED_RAW_100_KHZ = 0x2,
101 SPEED_RAW_400_KHZ = 0x3
102 };
103
104 /* SWD mode specific */
105 static bool swd_mode;
106 static int queued_retval;
107 static char swd_features;
108
109 static const cc_t SHORT_TIMEOUT = 1; /* Must be at least 1. */
110 static const cc_t NORMAL_TIMEOUT = 10;
111
112 static int buspirate_fd = -1;
113 static int buspirate_pinmode = MODE_JTAG_OD;
114 static int buspirate_baudrate = SERIAL_NORMAL;
115 static int buspirate_vreg;
116 static int buspirate_pullup;
117 static char *buspirate_port;
118
119 static enum tap_state last_tap_state = TAP_RESET;
120
121 /* SWD interface */
122 static int buspirate_swd_init(void);
123 static void buspirate_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk);
124 static void buspirate_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk);
125 static int buspirate_swd_switch_seq(enum swd_special_seq seq);
126 static int buspirate_swd_run_queue(void);
127
128 /* TAP interface */
129 static void buspirate_tap_init(void);
130 static int buspirate_tap_execute(void);
131 static void buspirate_tap_append(int tms, int tdi);
132 static void buspirate_tap_append_scan(int length, uint8_t *buffer,
133 struct scan_command *command);
134 static void buspirate_tap_make_space(int scan, int bits);
135
136 static void buspirate_reset(int trst, int srst);
137 static void buspirate_set_feature(int, char, char);
138 static void buspirate_set_mode(int, char);
139 static void buspirate_set_speed(int, char);
140
141 /* low level interface */
142 static void buspirate_bbio_enable(int);
143 static void buspirate_jtag_reset(int);
144 static unsigned char buspirate_jtag_command(int, uint8_t *, int);
145 static void buspirate_jtag_set_speed(int, char);
146 static void buspirate_jtag_set_mode(int, char);
147 static void buspirate_jtag_set_feature(int, char, char);
148 static void buspirate_jtag_get_adcs(int);
149
150 /* low level two-wire interface */
151 static void buspirate_swd_set_speed(int, char);
152 static void buspirate_swd_set_feature(int, char, char);
153 static void buspirate_swd_set_mode(int, char);
154
155 /* low level HW communication interface */
156 static int buspirate_serial_open(char *port);
157 static int buspirate_serial_setspeed(int fd, char speed, cc_t timeout);
158 static int buspirate_serial_write(int fd, uint8_t *buf, int size);
159 static int buspirate_serial_read(int fd, uint8_t *buf, int size);
160 static void buspirate_serial_close(int fd);
161 static void buspirate_print_buffer(uint8_t *buf, int size);
162
163 static int buspirate_execute_queue(void)
164 {
165 /* currently processed command */
166 struct jtag_command *cmd = jtag_command_queue;
167 int scan_size;
168 enum scan_type type;
169 uint8_t *buffer;
170
171 while (cmd) {
172 switch (cmd->type) {
173 case JTAG_RUNTEST:
174 LOG_DEBUG_IO("runtest %i cycles, end in %s",
175 cmd->cmd.runtest->num_cycles,
176 tap_state_name(cmd->cmd.runtest
177 ->end_state));
178 buspirate_end_state(cmd->cmd.runtest
179 ->end_state);
180 buspirate_runtest(cmd->cmd.runtest
181 ->num_cycles);
182 break;
183 case JTAG_TLR_RESET:
184 LOG_DEBUG_IO("statemove end in %s",
185 tap_state_name(cmd->cmd.statemove
186 ->end_state));
187 buspirate_end_state(cmd->cmd.statemove
188 ->end_state);
189 buspirate_state_move();
190 break;
191 case JTAG_PATHMOVE:
192 LOG_DEBUG_IO("pathmove: %i states, end in %s",
193 cmd->cmd.pathmove->num_states,
194 tap_state_name(cmd->cmd.pathmove
195 ->path[cmd->cmd.pathmove
196 ->num_states - 1]));
197 buspirate_path_move(cmd->cmd.pathmove
198 ->num_states,
199 cmd->cmd.pathmove->path);
200 break;
201 case JTAG_SCAN:
202 LOG_DEBUG_IO("scan end in %s",
203 tap_state_name(cmd->cmd.scan
204 ->end_state));
205
206 buspirate_end_state(cmd->cmd.scan
207 ->end_state);
208
209 scan_size = jtag_build_buffer(cmd->cmd.scan,
210 &buffer);
211 type = jtag_scan_type(cmd->cmd.scan);
212 buspirate_scan(cmd->cmd.scan->ir_scan, type,
213 buffer, scan_size, cmd->cmd.scan);
214
215 break;
216 case JTAG_RESET:
217 LOG_DEBUG_IO("reset trst: %i srst %i",
218 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
219
220 /* flush buffers, so we can reset */
221 buspirate_tap_execute();
222
223 if (cmd->cmd.reset->trst == 1)
224 tap_set_state(TAP_RESET);
225 buspirate_reset(cmd->cmd.reset->trst,
226 cmd->cmd.reset->srst);
227 break;
228 case JTAG_SLEEP:
229 LOG_DEBUG_IO("sleep %i", cmd->cmd.sleep->us);
230 buspirate_tap_execute();
231 jtag_sleep(cmd->cmd.sleep->us);
232 break;
233 case JTAG_STABLECLOCKS:
234 LOG_DEBUG_IO("stable clock %i cycles", cmd->cmd.stableclocks->num_cycles);
235 buspirate_stableclocks(cmd->cmd.stableclocks->num_cycles);
236 break;
237 default:
238 LOG_ERROR("BUG: unknown JTAG command type encountered");
239 exit(-1);
240 }
241
242 cmd = cmd->next;
243 }
244
245 return buspirate_tap_execute();
246 }
247
248
249 /* Returns true if successful, false if error. */
250
251 static bool read_and_discard_all_data(const int fd)
252 {
253 /* LOG_INFO("Discarding any stale data from a previous connection..."); */
254
255 bool was_msg_already_printed = false;
256
257 for ( ; ; ) {
258 uint8_t buffer[1024]; /* Any size will do, it's a trade-off between stack size and performance. */
259
260 const ssize_t read_count = read(fd, buffer, sizeof(buffer));
261
262 if (read_count == 0) {
263 /* This is the "end of file" or "connection closed at the other end" condition. */
264 return true;
265 }
266
267 if (read_count > 0) {
268 if (!was_msg_already_printed) {
269 LOG_INFO("Some stale data from a previous connection was discarded.");
270 was_msg_already_printed = true;
271 }
272
273 continue;
274 }
275
276 assert(read_count == -1); /* According to the specification. */
277
278 const int errno_code = errno;
279
280 if (errno_code == EINTR)
281 continue;
282
283 if (errno_code == EAGAIN ||
284 errno_code == EWOULDBLOCK) {
285 /* We know that the file descriptor has been opened with O_NONBLOCK or O_NDELAY,
286 and these codes mean that there is no data to read at present. */
287 return true;
288 }
289
290 /* Some other error has occurred. */
291 return false;
292 }
293 }
294
295
296 static int buspirate_init(void)
297 {
298 if (buspirate_port == NULL) {
299 LOG_ERROR("You need to specify the serial port!");
300 return ERROR_JTAG_INIT_FAILED;
301 }
302
303 buspirate_fd = buspirate_serial_open(buspirate_port);
304 if (buspirate_fd == -1) {
305 LOG_ERROR("Could not open serial port");
306 return ERROR_JTAG_INIT_FAILED;
307 }
308
309 /* The Operating System or the device itself may deliver stale data from the last connection,
310 so discard all available bytes right after the new connection has been established.
311 After all, we are implementing here a master/slave protocol, so the slave should have nothing
312 to say until the master sends the first command.
313
314 In the past, there was a tcflush() call in buspirate_serial_setspeed(), but that
315 was not enough. I guess you must actively read from the serial port to trigger any
316 data collection from the device and/or lower USB layers. If you disable the serial port
317 read timeout (if you set SHORT_TIMEOUT to 0), then the discarding does not work any more.
318
319 Note that we are lowering the serial port timeout for this first read operation,
320 otherwise the normal initialisation would be delayed for too long. */
321
322 if (-1 == buspirate_serial_setspeed(buspirate_fd, SERIAL_NORMAL, SHORT_TIMEOUT)) {
323 LOG_ERROR("Error configuring the serial port.");
324 return ERROR_JTAG_INIT_FAILED;
325 }
326
327 if (!read_and_discard_all_data(buspirate_fd)) {
328 LOG_ERROR("Error while attempting to discard any stale data right after establishing the connection.");
329 return ERROR_JTAG_INIT_FAILED;
330 }
331
332 if (-1 == buspirate_serial_setspeed(buspirate_fd, SERIAL_NORMAL, NORMAL_TIMEOUT)) {
333 LOG_ERROR("Error configuring the serial port.");
334 return ERROR_JTAG_INIT_FAILED;
335 }
336
337 buspirate_bbio_enable(buspirate_fd);
338
339 if (swd_mode || buspirate_baudrate != SERIAL_NORMAL)
340 buspirate_set_speed(buspirate_fd, SERIAL_FAST);
341
342 LOG_INFO("Buspirate %s Interface ready!", swd_mode ? "SWD" : "JTAG");
343
344 if (!swd_mode)
345 buspirate_tap_init();
346
347 buspirate_set_mode(buspirate_fd, buspirate_pinmode);
348 buspirate_set_feature(buspirate_fd, FEATURE_VREG,
349 (buspirate_vreg == 1) ? ACTION_ENABLE : ACTION_DISABLE);
350 buspirate_set_feature(buspirate_fd, FEATURE_PULLUP,
351 (buspirate_pullup == 1) ? ACTION_ENABLE : ACTION_DISABLE);
352 buspirate_reset(0, 0);
353
354 return ERROR_OK;
355 }
356
357 static int buspirate_quit(void)
358 {
359 LOG_INFO("Shutting down buspirate.");
360 buspirate_set_mode(buspirate_fd, MODE_HIZ);
361 buspirate_set_speed(buspirate_fd, SERIAL_NORMAL);
362
363 buspirate_jtag_reset(buspirate_fd);
364
365 buspirate_serial_close(buspirate_fd);
366
367 if (buspirate_port) {
368 free(buspirate_port);
369 buspirate_port = NULL;
370 }
371 return ERROR_OK;
372 }
373
374 /* openocd command interface */
375 COMMAND_HANDLER(buspirate_handle_adc_command)
376 {
377 if (buspirate_fd == -1)
378 return ERROR_OK;
379
380 /* unavailable in SWD mode */
381 if (swd_mode)
382 return ERROR_OK;
383
384 /* send the command */
385 buspirate_jtag_get_adcs(buspirate_fd);
386
387 return ERROR_OK;
388
389 }
390
391 COMMAND_HANDLER(buspirate_handle_vreg_command)
392 {
393 if (CMD_ARGC < 1)
394 return ERROR_COMMAND_SYNTAX_ERROR;
395
396 if (atoi(CMD_ARGV[0]) == 1)
397 buspirate_vreg = 1;
398 else if (atoi(CMD_ARGV[0]) == 0)
399 buspirate_vreg = 0;
400 else
401 LOG_ERROR("usage: buspirate_vreg <1|0>");
402
403 return ERROR_OK;
404
405 }
406
407 COMMAND_HANDLER(buspirate_handle_pullup_command)
408 {
409 if (CMD_ARGC < 1)
410 return ERROR_COMMAND_SYNTAX_ERROR;
411
412 if (atoi(CMD_ARGV[0]) == 1)
413 buspirate_pullup = 1;
414 else if (atoi(CMD_ARGV[0]) == 0)
415 buspirate_pullup = 0;
416 else
417 LOG_ERROR("usage: buspirate_pullup <1|0>");
418
419 return ERROR_OK;
420
421 }
422
423 COMMAND_HANDLER(buspirate_handle_led_command)
424 {
425 if (CMD_ARGC < 1)
426 return ERROR_COMMAND_SYNTAX_ERROR;
427
428 if (atoi(CMD_ARGV[0]) == 1) {
429 /* enable led */
430 buspirate_set_feature(buspirate_fd, FEATURE_LED,
431 ACTION_ENABLE);
432 } else if (atoi(CMD_ARGV[0]) == 0) {
433 /* disable led */
434 buspirate_set_feature(buspirate_fd, FEATURE_LED,
435 ACTION_DISABLE);
436 } else {
437 LOG_ERROR("usage: buspirate_led <1|0>");
438 }
439
440 return ERROR_OK;
441
442 }
443
444 COMMAND_HANDLER(buspirate_handle_mode_command)
445 {
446 if (CMD_ARGC < 1)
447 return ERROR_COMMAND_SYNTAX_ERROR;
448
449 if (CMD_ARGV[0][0] == 'n')
450 buspirate_pinmode = MODE_JTAG;
451 else if (CMD_ARGV[0][0] == 'o')
452 buspirate_pinmode = MODE_JTAG_OD;
453 else
454 LOG_ERROR("usage: buspirate_mode <normal|open-drain>");
455
456 return ERROR_OK;
457
458 }
459
460 COMMAND_HANDLER(buspirate_handle_speed_command)
461 {
462 if (CMD_ARGC < 1)
463 return ERROR_COMMAND_SYNTAX_ERROR;
464
465 if (CMD_ARGV[0][0] == 'n')
466 buspirate_baudrate = SERIAL_NORMAL;
467 else if (CMD_ARGV[0][0] == 'f')
468 buspirate_baudrate = SERIAL_FAST;
469 else
470 LOG_ERROR("usage: buspirate_speed <normal|fast>");
471
472 return ERROR_OK;
473
474 }
475
476 COMMAND_HANDLER(buspirate_handle_port_command)
477 {
478 if (CMD_ARGC < 1)
479 return ERROR_COMMAND_SYNTAX_ERROR;
480
481 if (buspirate_port == NULL)
482 buspirate_port = strdup(CMD_ARGV[0]);
483
484 return ERROR_OK;
485
486 }
487
488 static const struct command_registration buspirate_command_handlers[] = {
489 {
490 .name = "buspirate_adc",
491 .handler = &buspirate_handle_adc_command,
492 .mode = COMMAND_EXEC,
493 .help = "reads voltages on adc pins",
494 .usage = "",
495 },
496 {
497 .name = "buspirate_vreg",
498 .usage = "<1|0>",
499 .handler = &buspirate_handle_vreg_command,
500 .mode = COMMAND_CONFIG,
501 .help = "changes the state of voltage regulators",
502 },
503 {
504 .name = "buspirate_pullup",
505 .usage = "<1|0>",
506 .handler = &buspirate_handle_pullup_command,
507 .mode = COMMAND_CONFIG,
508 .help = "changes the state of pullup",
509 },
510 {
511 .name = "buspirate_led",
512 .usage = "<1|0>",
513 .handler = &buspirate_handle_led_command,
514 .mode = COMMAND_EXEC,
515 .help = "changes the state of led",
516 },
517 {
518 .name = "buspirate_speed",
519 .usage = "<normal|fast>",
520 .handler = &buspirate_handle_speed_command,
521 .mode = COMMAND_CONFIG,
522 .help = "speed of the interface",
523 },
524 {
525 .name = "buspirate_mode",
526 .usage = "<normal|open-drain>",
527 .handler = &buspirate_handle_mode_command,
528 .mode = COMMAND_CONFIG,
529 .help = "pin mode of the interface",
530 },
531 {
532 .name = "buspirate_port",
533 .usage = "/dev/ttyUSB0",
534 .handler = &buspirate_handle_port_command,
535 .mode = COMMAND_CONFIG,
536 .help = "name of the serial port to open",
537 },
538 COMMAND_REGISTRATION_DONE
539 };
540
541 static const struct swd_driver buspirate_swd = {
542 .init = buspirate_swd_init,
543 .switch_seq = buspirate_swd_switch_seq,
544 .read_reg = buspirate_swd_read_reg,
545 .write_reg = buspirate_swd_write_reg,
546 .run = buspirate_swd_run_queue,
547 };
548
549 static const char * const buspirate_transports[] = { "jtag", "swd", NULL };
550
551 struct jtag_interface buspirate_interface = {
552 .name = "buspirate",
553 .execute_queue = buspirate_execute_queue,
554 .commands = buspirate_command_handlers,
555 .transports = buspirate_transports,
556 .swd = &buspirate_swd,
557 .init = buspirate_init,
558 .quit = buspirate_quit
559 };
560
561 /*************** jtag execute commands **********************/
562 static void buspirate_end_state(tap_state_t state)
563 {
564 if (tap_is_state_stable(state))
565 tap_set_end_state(state);
566 else {
567 LOG_ERROR("BUG: %i is not a valid end state", state);
568 exit(-1);
569 }
570 }
571
572 static void buspirate_state_move(void)
573 {
574 int i = 0, tms = 0;
575 uint8_t tms_scan = tap_get_tms_path(tap_get_state(),
576 tap_get_end_state());
577 int tms_count = tap_get_tms_path_len(tap_get_state(),
578 tap_get_end_state());
579
580 for (i = 0; i < tms_count; i++) {
581 tms = (tms_scan >> i) & 1;
582 buspirate_tap_append(tms, 0);
583 }
584
585 tap_set_state(tap_get_end_state());
586 }
587
588 static void buspirate_path_move(int num_states, tap_state_t *path)
589 {
590 int i;
591
592 for (i = 0; i < num_states; i++) {
593 if (tap_state_transition(tap_get_state(), false) == path[i]) {
594 buspirate_tap_append(0, 0);
595 } else if (tap_state_transition(tap_get_state(), true)
596 == path[i]) {
597 buspirate_tap_append(1, 0);
598 } else {
599 LOG_ERROR("BUG: %s -> %s isn't a valid "
600 "TAP transition",
601 tap_state_name(tap_get_state()),
602 tap_state_name(path[i]));
603 exit(-1);
604 }
605
606 tap_set_state(path[i]);
607 }
608
609 tap_set_end_state(tap_get_state());
610 }
611
612 static void buspirate_runtest(int num_cycles)
613 {
614 int i;
615
616 tap_state_t saved_end_state = tap_get_end_state();
617
618 /* only do a state_move when we're not already in IDLE */
619 if (tap_get_state() != TAP_IDLE) {
620 buspirate_end_state(TAP_IDLE);
621 buspirate_state_move();
622 }
623
624 for (i = 0; i < num_cycles; i++)
625 buspirate_tap_append(0, 0);
626
627 LOG_DEBUG_IO("runtest: cur_state %s end_state %s",
628 tap_state_name(tap_get_state()),
629 tap_state_name(tap_get_end_state()));
630
631 /* finish in end_state */
632 buspirate_end_state(saved_end_state);
633 if (tap_get_state() != tap_get_end_state())
634 buspirate_state_move();
635 }
636
637 static void buspirate_scan(bool ir_scan, enum scan_type type,
638 uint8_t *buffer, int scan_size, struct scan_command *command)
639 {
640 tap_state_t saved_end_state;
641
642 buspirate_tap_make_space(1, scan_size+8);
643 /* is 8 correct ? (2 moves = 16) */
644
645 saved_end_state = tap_get_end_state();
646
647 buspirate_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
648
649 /* Only move if we're not already there */
650 if (tap_get_state() != tap_get_end_state())
651 buspirate_state_move();
652
653 buspirate_tap_append_scan(scan_size, buffer, command);
654
655 /* move to PAUSE */
656 buspirate_tap_append(0, 0);
657
658 /* restore the saved state */
659 buspirate_end_state(saved_end_state);
660 tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
661
662 if (tap_get_state() != tap_get_end_state())
663 buspirate_state_move();
664 }
665
666 static void buspirate_stableclocks(int num_cycles)
667 {
668 int i;
669 int tms = (tap_get_state() == TAP_RESET ? 1 : 0);
670
671 buspirate_tap_make_space(0, num_cycles);
672
673 for (i = 0; i < num_cycles; i++)
674 buspirate_tap_append(tms, 0);
675 }
676
677 /************************* TAP related stuff **********/
678
679 /* This buffer size matches the maximum CMD_TAP_SHIFT bit length in the Bus Pirate firmware,
680 look for constant 0x2000 in OpenOCD.c . */
681 #define BUSPIRATE_BUFFER_SIZE 1024
682
683 /* The old value of 32 scans was not enough to achieve near 100% utilisation ratio
684 for the current BUSPIRATE_BUFFER_SIZE value of 1024.
685 With 128 scans I am getting full USB 2.0 high speed packets (512 bytes long) when
686 using the JtagDue firmware on the Arduino Due instead of the Bus Pirate, which
687 amounts approximately to a 10% overall speed gain. Bigger packets should also
688 benefit the Bus Pirate, but the speed difference is much smaller.
689 Unfortunately, each 512-byte packet is followed by a 329-byte one, which is not ideal.
690 However, increasing BUSPIRATE_BUFFER_SIZE for the benefit of the JtagDue would
691 make it incompatible with the Bus Pirate firmware. */
692 #define BUSPIRATE_MAX_PENDING_SCANS 128
693
694 static uint8_t tms_chain[BUSPIRATE_BUFFER_SIZE]; /* send */
695 static uint8_t tdi_chain[BUSPIRATE_BUFFER_SIZE]; /* send */
696 static int tap_chain_index;
697
698 struct pending_scan_result /* this was stolen from arm-jtag-ew */
699 {
700 int first; /* First bit position in tdo_buffer to read */
701 int length; /* Number of bits to read */
702 struct scan_command *command; /* Corresponding scan command */
703 uint8_t *buffer;
704 };
705
706 static struct pending_scan_result
707 tap_pending_scans[BUSPIRATE_MAX_PENDING_SCANS];
708 static int tap_pending_scans_num;
709
710 static void buspirate_tap_init(void)
711 {
712 tap_chain_index = 0;
713 tap_pending_scans_num = 0;
714 }
715
716 static int buspirate_tap_execute(void)
717 {
718 static const int CMD_TAP_SHIFT_HEADER_LEN = 3;
719
720 uint8_t tmp[4096];
721 uint8_t *in_buf;
722 int i;
723 int fill_index = 0;
724 int ret;
725 int bytes_to_send;
726
727 if (tap_chain_index <= 0)
728 return ERROR_OK;
729
730 LOG_DEBUG("executing tap num bits = %i scans = %i",
731 tap_chain_index, tap_pending_scans_num);
732
733 bytes_to_send = DIV_ROUND_UP(tap_chain_index, 8);
734
735 tmp[0] = CMD_TAP_SHIFT; /* this command expects number of bits */
736 tmp[1] = tap_chain_index >> 8; /* high */
737 tmp[2] = tap_chain_index; /* low */
738
739 fill_index = CMD_TAP_SHIFT_HEADER_LEN;
740 for (i = 0; i < bytes_to_send; i++) {
741 tmp[fill_index] = tdi_chain[i];
742 fill_index++;
743 tmp[fill_index] = tms_chain[i];
744 fill_index++;
745 }
746
747 /* jlink.c calls the routine below, which may be useful for debugging purposes.
748 For example, enabling this allows you to compare the log outputs from jlink.c
749 and from this module for JTAG development or troubleshooting purposes. */
750 if (false) {
751 last_tap_state = jtag_debug_state_machine(tms_chain, tdi_chain,
752 tap_chain_index, last_tap_state);
753 }
754
755 ret = buspirate_serial_write(buspirate_fd, tmp, CMD_TAP_SHIFT_HEADER_LEN + bytes_to_send*2);
756 if (ret != bytes_to_send*2+CMD_TAP_SHIFT_HEADER_LEN) {
757 LOG_ERROR("error writing :(");
758 return ERROR_JTAG_DEVICE_ERROR;
759 }
760
761 ret = buspirate_serial_read(buspirate_fd, tmp, bytes_to_send + CMD_TAP_SHIFT_HEADER_LEN);
762 if (ret != bytes_to_send + CMD_TAP_SHIFT_HEADER_LEN) {
763 LOG_ERROR("error reading");
764 return ERROR_FAIL;
765 }
766 in_buf = (uint8_t *)(&tmp[CMD_TAP_SHIFT_HEADER_LEN]);
767
768 /* parse the scans */
769 for (i = 0; i < tap_pending_scans_num; i++) {
770 uint8_t *buffer = tap_pending_scans[i].buffer;
771 int length = tap_pending_scans[i].length;
772 int first = tap_pending_scans[i].first;
773 struct scan_command *command = tap_pending_scans[i].command;
774
775 /* copy bits from buffer */
776 buf_set_buf(in_buf, first, buffer, 0, length);
777
778 /* return buffer to higher level */
779 if (jtag_read_buffer(buffer, command) != ERROR_OK) {
780 buspirate_tap_init();
781 return ERROR_JTAG_QUEUE_FAILED;
782 }
783
784 free(buffer);
785 }
786 buspirate_tap_init();
787 return ERROR_OK;
788 }
789
790 static void buspirate_tap_make_space(int scans, int bits)
791 {
792 int have_scans = BUSPIRATE_MAX_PENDING_SCANS - tap_pending_scans_num;
793 int have_bits = BUSPIRATE_BUFFER_SIZE * 8 - tap_chain_index;
794
795 if ((have_scans < scans) || (have_bits < bits))
796 buspirate_tap_execute();
797 }
798
799 static void buspirate_tap_append(int tms, int tdi)
800 {
801 int chain_index;
802
803 buspirate_tap_make_space(0, 1);
804 chain_index = tap_chain_index / 8;
805
806 if (chain_index < BUSPIRATE_BUFFER_SIZE) {
807 int bit_index = tap_chain_index % 8;
808 uint8_t bit = 1 << bit_index;
809
810 if (0 == bit_index) {
811 /* Let's say that the TAP shift operation wants to shift 9 bits,
812 so we will be sending to the Bus Pirate a bit count of 9 but still
813 full 16 bits (2 bytes) of shift data.
814 If we don't clear all bits at this point, the last 7 bits will contain
815 random data from the last buffer contents, which is not pleasant to the eye.
816 Besides, the Bus Pirate (or some clone) may want to assert in debug builds
817 that, after consuming all significant data bits, the rest of them are zero.
818 Therefore, for aesthetic and for assert purposes, we clear all bits below. */
819 tms_chain[chain_index] = 0;
820 tdi_chain[chain_index] = 0;
821 }
822
823 if (tms)
824 tms_chain[chain_index] |= bit;
825 else
826 tms_chain[chain_index] &= ~bit;
827
828 if (tdi)
829 tdi_chain[chain_index] |= bit;
830 else
831 tdi_chain[chain_index] &= ~bit;
832
833 tap_chain_index++;
834 } else {
835 LOG_ERROR("tap_chain overflow, bad things will happen");
836 /* Exit abruptly, like jlink.c does. After a buffer overflow we don't want
837 to carry on, as data will be corrupt. Another option would be to return
838 some error code at this point. */
839 exit(-1);
840 }
841 }
842
843 static void buspirate_tap_append_scan(int length, uint8_t *buffer,
844 struct scan_command *command)
845 {
846 int i;
847 tap_pending_scans[tap_pending_scans_num].length = length;
848 tap_pending_scans[tap_pending_scans_num].buffer = buffer;
849 tap_pending_scans[tap_pending_scans_num].command = command;
850 tap_pending_scans[tap_pending_scans_num].first = tap_chain_index;
851
852 for (i = 0; i < length; i++) {
853 int tms = (i < length-1 ? 0 : 1);
854 int tdi = (buffer[i/8] >> (i%8)) & 1;
855 buspirate_tap_append(tms, tdi);
856 }
857 tap_pending_scans_num++;
858 }
859
860 /*************** wrapper functions *********************/
861
862 /* (1) assert or (0) deassert reset lines */
863 static void buspirate_reset(int trst, int srst)
864 {
865 LOG_DEBUG("trst: %i, srst: %i", trst, srst);
866
867 if (trst)
868 buspirate_set_feature(buspirate_fd, FEATURE_TRST, ACTION_DISABLE);
869 else
870 buspirate_set_feature(buspirate_fd, FEATURE_TRST, ACTION_ENABLE);
871
872 if (srst)
873 buspirate_set_feature(buspirate_fd, FEATURE_SRST, ACTION_DISABLE);
874 else
875 buspirate_set_feature(buspirate_fd, FEATURE_SRST, ACTION_ENABLE);
876 }
877
878 static void buspirate_set_feature(int fd, char feat, char action)
879 {
880 if (swd_mode)
881 buspirate_swd_set_feature(fd, feat, action);
882 else
883 buspirate_jtag_set_feature(fd, feat, action);
884 }
885
886 static void buspirate_set_mode(int fd, char mode)
887 {
888 if (swd_mode)
889 buspirate_swd_set_mode(fd, mode);
890 else
891 buspirate_jtag_set_mode(fd, mode);
892 }
893
894 static void buspirate_set_speed(int fd, char speed)
895 {
896 if (swd_mode)
897 buspirate_swd_set_speed(fd, speed);
898 else
899 buspirate_jtag_set_speed(fd, speed);
900 }
901
902
903 /*************** swd lowlevel functions ********************/
904
905 static void buspirate_swd_set_speed(int fd, char speed)
906 {
907 int ret;
908 uint8_t tmp[1];
909
910 LOG_DEBUG("Buspirate speed setting in SWD mode defaults to 400 kHz");
911
912 /* speed settings */
913 tmp[0] = CMD_RAW_SPEED | SPEED_RAW_400_KHZ;
914 buspirate_serial_write(fd, tmp, 1);
915 ret = buspirate_serial_read(fd, tmp, 1);
916 if (ret != 1) {
917 LOG_ERROR("Buspirate did not answer correctly");
918 exit(-1);
919 }
920 if (tmp[0] != 1) {
921 LOG_ERROR("Buspirate did not reply as expected to the speed change command");
922 exit(-1);
923 }
924 }
925
926 static void buspirate_swd_set_mode(int fd, char mode)
927 {
928 int ret;
929 uint8_t tmp[1];
930
931 /* raw-wire mode configuration */
932 if (mode == MODE_HIZ)
933 tmp[0] = CMD_RAW_MODE | CMD_RAW_CONFIG_LSB;
934 else
935 tmp[0] = CMD_RAW_MODE | CMD_RAW_CONFIG_LSB | CMD_RAW_CONFIG_3V3;
936
937 buspirate_serial_write(fd, tmp, 1);
938 ret = buspirate_serial_read(fd, tmp, 1);
939 if (ret != 1) {
940 LOG_ERROR("Buspirate did not answer correctly");
941 exit(-1);
942 }
943 if (tmp[0] != 1) {
944 LOG_ERROR("Buspirate did not reply as expected to the configure command");
945 exit(-1);
946 }
947 }
948
949 static void buspirate_swd_set_feature(int fd, char feat, char action)
950 {
951 int ret;
952 uint8_t tmp[1];
953
954 switch (feat) {
955 case FEATURE_TRST:
956 LOG_DEBUG("Buspirate TRST feature not available in SWD mode");
957 return;
958 case FEATURE_LED:
959 LOG_ERROR("Buspirate LED feature not available in SWD mode");
960 return;
961 case FEATURE_SRST:
962 swd_features = (action == ACTION_ENABLE) ? swd_features | 0x02 : swd_features & 0x0D;
963 break;
964 case FEATURE_PULLUP:
965 swd_features = (action == ACTION_ENABLE) ? swd_features | 0x04 : swd_features & 0x0B;
966 break;
967 case FEATURE_VREG:
968 swd_features = (action == ACTION_ENABLE) ? swd_features | 0x08 : swd_features & 0x07;
969 break;
970 default:
971 LOG_DEBUG("Buspirate unknown feature %d", feat);
972 return;
973 }
974
975 tmp[0] = CMD_RAW_PERIPH | swd_features;
976 buspirate_serial_write(fd, tmp, 1);
977 ret = buspirate_serial_read(fd, tmp, 1);
978 if (ret != 1) {
979 LOG_DEBUG("Buspirate feature %d not supported in SWD mode", feat);
980 } else if (tmp[0] != 1) {
981 LOG_ERROR("Buspirate did not reply as expected to the configure command");
982 exit(-1);
983 }
984 }
985
986 /*************** jtag lowlevel functions ********************/
987 static void buspirate_bbio_enable(int fd)
988 {
989 int ret;
990 char command;
991 const char *mode_answers[2] = { "OCD1", "RAW1" };
992 const char *correct_ans = NULL;
993 uint8_t tmp[21] = { [0 ... 20] = 0x00 };
994 int done = 0;
995 int cmd_sent = 0;
996
997 if (swd_mode) {
998 command = CMD_ENTER_RWIRE;
999 correct_ans = mode_answers[1];
1000 } else {
1001 command = CMD_ENTER_OOCD;
1002 correct_ans = mode_answers[0];
1003 }
1004
1005 LOG_DEBUG("Entering binary mode, that is %s", correct_ans);
1006 buspirate_serial_write(fd, tmp, 20);
1007 usleep(10000);
1008
1009 /* reads 1 to n "BBIO1"s and one "OCD1" or "RAW1" */
1010 while (!done) {
1011 ret = buspirate_serial_read(fd, tmp, 4);
1012 if (ret != 4) {
1013 LOG_ERROR("Buspirate error. Is binary"
1014 "/OpenOCD support enabled?");
1015 exit(-1);
1016 }
1017 if (strncmp((char *)tmp, "BBIO", 4) == 0) {
1018 ret = buspirate_serial_read(fd, tmp, 1);
1019 if (ret != 1) {
1020 LOG_ERROR("Buspirate did not answer correctly! "
1021 "Do you have correct firmware?");
1022 exit(-1);
1023 }
1024 if (tmp[0] != '1') {
1025 LOG_ERROR("Unsupported binary protocol");
1026 exit(-1);
1027 }
1028 if (cmd_sent == 0) {
1029 cmd_sent = 1;
1030 tmp[0] = command;
1031 ret = buspirate_serial_write(fd, tmp, 1);
1032 if (ret != 1) {
1033 LOG_ERROR("error reading");
1034 exit(-1);
1035 }
1036 }
1037 } else if (strncmp((char *)tmp, correct_ans, 4) == 0)
1038 done = 1;
1039 else {
1040 LOG_ERROR("Buspirate did not answer correctly! "
1041 "Do you have correct firmware?");
1042 exit(-1);
1043 }
1044 }
1045
1046 }
1047
1048 static void buspirate_jtag_reset(int fd)
1049 {
1050 uint8_t tmp[5];
1051
1052 tmp[0] = 0x00; /* exit OCD1 mode */
1053 buspirate_serial_write(fd, tmp, 1);
1054 usleep(10000);
1055 /* We ignore the return value here purposly, nothing we can do */
1056 buspirate_serial_read(fd, tmp, 5);
1057 if (strncmp((char *)tmp, "BBIO1", 5) == 0) {
1058 tmp[0] = 0x0F; /* reset BP */
1059 buspirate_serial_write(fd, tmp, 1);
1060 } else
1061 LOG_ERROR("Unable to restart buspirate!");
1062 }
1063
1064 static void buspirate_jtag_set_speed(int fd, char speed)
1065 {
1066 int ret;
1067 uint8_t tmp[2];
1068 uint8_t ack[2];
1069
1070 ack[0] = 0xAA;
1071 ack[1] = 0x55;
1072
1073 tmp[0] = CMD_UART_SPEED;
1074 tmp[1] = speed;
1075 buspirate_jtag_command(fd, tmp, 2);
1076
1077 /* here the adapter changes speed, we need follow */
1078 if (-1 == buspirate_serial_setspeed(fd, speed, NORMAL_TIMEOUT)) {
1079 LOG_ERROR("Error configuring the serial port.");
1080 exit(-1);
1081 }
1082
1083 buspirate_serial_write(fd, ack, 2);
1084 ret = buspirate_serial_read(fd, tmp, 2);
1085 if (ret != 2) {
1086 LOG_ERROR("Buspirate did not ack speed change");
1087 exit(-1);
1088 }
1089 if ((tmp[0] != CMD_UART_SPEED) || (tmp[1] != speed)) {
1090 LOG_ERROR("Buspirate did not reply as expected to the speed change command");
1091 exit(-1);
1092 }
1093 LOG_INFO("Buspirate switched to %s mode",
1094 (speed == SERIAL_NORMAL) ? "normal" : "FAST");
1095 }
1096
1097
1098 static void buspirate_jtag_set_mode(int fd, char mode)
1099 {
1100 uint8_t tmp[2];
1101 tmp[0] = CMD_PORT_MODE;
1102 tmp[1] = mode;
1103 buspirate_jtag_command(fd, tmp, 2);
1104 }
1105
1106 static void buspirate_jtag_set_feature(int fd, char feat, char action)
1107 {
1108 uint8_t tmp[3];
1109 tmp[0] = CMD_FEATURE;
1110 tmp[1] = feat; /* what */
1111 tmp[2] = action; /* action */
1112 buspirate_jtag_command(fd, tmp, 3);
1113 }
1114
1115 static void buspirate_jtag_get_adcs(int fd)
1116 {
1117 uint8_t tmp[10];
1118 uint16_t a, b, c, d;
1119 tmp[0] = CMD_READ_ADCS;
1120 buspirate_jtag_command(fd, tmp, 1);
1121 a = tmp[2] << 8 | tmp[3];
1122 b = tmp[4] << 8 | tmp[5];
1123 c = tmp[6] << 8 | tmp[7];
1124 d = tmp[8] << 8 | tmp[9];
1125
1126 LOG_INFO("ADC: ADC_Pin = %.02f VPullup = %.02f V33 = %.02f "
1127 "V50 = %.02f",
1128 ((float)a)/155.1515, ((float)b)/155.1515,
1129 ((float)c)/155.1515, ((float)d)/155.1515);
1130 }
1131
1132 static unsigned char buspirate_jtag_command(int fd,
1133 uint8_t *cmd, int cmdlen)
1134 {
1135 int res;
1136 int len = 0;
1137
1138 res = buspirate_serial_write(fd, cmd, cmdlen);
1139
1140 if ((cmd[0] == CMD_UART_SPEED)
1141 || (cmd[0] == CMD_PORT_MODE)
1142 || (cmd[0] == CMD_FEATURE)
1143 || (cmd[0] == CMD_JTAG_SPEED))
1144 return 1;
1145
1146 if (res == cmdlen) {
1147 switch (cmd[0]) {
1148 case CMD_READ_ADCS:
1149 len = 10; /* 2*sizeof(char)+4*sizeof(uint16_t) */
1150 break;
1151 case CMD_TAP_SHIFT:
1152 len = cmdlen;
1153 break;
1154 default:
1155 LOG_INFO("Wrong !");
1156 }
1157 res = buspirate_serial_read(fd, cmd, len);
1158 if (res > 0)
1159 return (unsigned char)cmd[1];
1160 else
1161 return -1;
1162 } else
1163 return -1;
1164 return 0;
1165 }
1166
1167 /* low level serial port */
1168 /* TODO add support for WIN32 and others ! */
1169 static int buspirate_serial_open(char *port)
1170 {
1171 int fd;
1172 fd = open(buspirate_port, O_RDWR | O_NOCTTY | O_NDELAY);
1173 return fd;
1174 }
1175
1176
1177 /* Returns -1 on error. */
1178
1179 static int buspirate_serial_setspeed(int fd, char speed, cc_t timeout)
1180 {
1181 struct termios t_opt;
1182 speed_t baud = (speed == SERIAL_FAST) ? B1000000 : B115200;
1183
1184 /* set the serial port parameters */
1185 fcntl(fd, F_SETFL, 0);
1186 if (0 != tcgetattr(fd, &t_opt))
1187 return -1;
1188
1189 if (0 != cfsetispeed(&t_opt, baud))
1190 return -1;
1191
1192 if (0 != cfsetospeed(&t_opt, baud))
1193 return -1;
1194
1195 t_opt.c_cflag |= (CLOCAL | CREAD);
1196 t_opt.c_cflag &= ~PARENB;
1197 t_opt.c_cflag &= ~CSTOPB;
1198 t_opt.c_cflag &= ~CSIZE;
1199 t_opt.c_cflag |= CS8;
1200 t_opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
1201
1202 /* The serial port may have been configured for human interaction with
1203 the Bus Pirate console, but OpenOCD is going to use a binary protocol,
1204 so make sure to turn off any CR/LF translation and the like. */
1205 t_opt.c_iflag &= ~(IXON | IXOFF | IXANY | INLCR | ICRNL);
1206
1207 t_opt.c_oflag &= ~OPOST;
1208 t_opt.c_cc[VMIN] = 0;
1209 t_opt.c_cc[VTIME] = timeout;
1210
1211 /* Note that, in the past, TCSANOW was used below instead of TCSADRAIN,
1212 and CMD_UART_SPEED did not work properly then, at least with
1213 the Bus Pirate v3.5 (USB). */
1214 if (0 != tcsetattr(fd, TCSADRAIN, &t_opt)) {
1215 /* According to the Linux documentation, this is actually not enough
1216 to detect errors, you need to call tcgetattr() and check that
1217 all changes have been performed successfully. */
1218 return -1;
1219 }
1220
1221 return 0;
1222 }
1223
1224 static int buspirate_serial_write(int fd, uint8_t *buf, int size)
1225 {
1226 int ret = 0;
1227
1228 ret = write(fd, buf, size);
1229
1230 LOG_DEBUG("size = %d ret = %d", size, ret);
1231 buspirate_print_buffer(buf, size);
1232
1233 if (ret != size)
1234 LOG_ERROR("Error sending data");
1235
1236 return ret;
1237 }
1238
1239 static int buspirate_serial_read(int fd, uint8_t *buf, int size)
1240 {
1241 int len = 0;
1242 int ret = 0;
1243 int timeout = 0;
1244
1245 while (len < size) {
1246 ret = read(fd, buf+len, size-len);
1247 if (ret == -1)
1248 return -1;
1249
1250 if (ret == 0) {
1251 timeout++;
1252
1253 if (timeout >= 10)
1254 break;
1255
1256 continue;
1257 }
1258
1259 len += ret;
1260 }
1261
1262 LOG_DEBUG("should have read = %d actual size = %d", size, len);
1263 buspirate_print_buffer(buf, len);
1264
1265 if (len != size)
1266 LOG_ERROR("Error reading data");
1267
1268 return len;
1269 }
1270
1271 static void buspirate_serial_close(int fd)
1272 {
1273 close(fd);
1274 }
1275
1276 #define LINE_SIZE 81
1277 #define BYTES_PER_LINE 16
1278 static void buspirate_print_buffer(uint8_t *buf, int size)
1279 {
1280 char line[LINE_SIZE];
1281 char tmp[10];
1282 int offset = 0;
1283
1284 line[0] = 0;
1285 while (offset < size) {
1286 snprintf(tmp, 5, "%02x ", (uint8_t)buf[offset]);
1287 offset++;
1288
1289 strcat(line, tmp);
1290
1291 if (offset % BYTES_PER_LINE == 0) {
1292 LOG_DEBUG("%s", line);
1293 line[0] = 0;
1294 }
1295 }
1296
1297 if (line[0] != 0)
1298 LOG_DEBUG("%s", line);
1299 }
1300
1301 /************************* SWD related stuff **********/
1302
1303 static int buspirate_swd_init(void)
1304 {
1305 LOG_INFO("Buspirate SWD mode enabled");
1306 swd_mode = true;
1307
1308 return ERROR_OK;
1309 }
1310
1311 static int buspirate_swd_switch_seq(enum swd_special_seq seq)
1312 {
1313 const uint8_t *sequence;
1314 int sequence_len;
1315 uint8_t tmp[64];
1316
1317 switch (seq) {
1318 case LINE_RESET:
1319 LOG_DEBUG("SWD line reset");
1320 sequence = swd_seq_line_reset;
1321 sequence_len = DIV_ROUND_UP(swd_seq_line_reset_len, 8);
1322 break;
1323 case JTAG_TO_SWD:
1324 LOG_DEBUG("JTAG-to-SWD");
1325 sequence = swd_seq_jtag_to_swd;
1326 sequence_len = DIV_ROUND_UP(swd_seq_jtag_to_swd_len, 8);
1327 break;
1328 case SWD_TO_JTAG:
1329 LOG_DEBUG("SWD-to-JTAG");
1330 sequence = swd_seq_swd_to_jtag;
1331 sequence_len = DIV_ROUND_UP(swd_seq_swd_to_jtag_len, 8);
1332 break;
1333 default:
1334 LOG_ERROR("Sequence %d not supported", seq);
1335 return ERROR_FAIL;
1336 }
1337
1338 /* FIXME: all above sequences fit into one pirate command for now
1339 * but it may cause trouble later
1340 */
1341
1342 tmp[0] = 0x10 + ((sequence_len - 1) & 0x0F);
1343 memcpy(tmp + 1, sequence, sequence_len);
1344
1345 buspirate_serial_write(buspirate_fd, tmp, sequence_len + 1);
1346 buspirate_serial_read(buspirate_fd, tmp, sequence_len + 1);
1347
1348 return ERROR_OK;
1349 }
1350
1351 static uint8_t buspirate_swd_write_header(uint8_t cmd)
1352 {
1353 uint8_t tmp[8];
1354 int to_send;
1355
1356 tmp[0] = 0x10; /* bus pirate: send 1 byte */
1357 tmp[1] = cmd; /* swd cmd */
1358 tmp[2] = 0x07; /* ack __x */
1359 tmp[3] = 0x07; /* ack _x_ */
1360 tmp[4] = 0x07; /* ack x__ */
1361 tmp[5] = 0x07; /* write mode trn_1 */
1362 tmp[6] = 0x07; /* write mode trn_2 */
1363
1364 to_send = ((cmd & SWD_CMD_RnW) == 0) ? 7 : 5;
1365 buspirate_serial_write(buspirate_fd, tmp, to_send);
1366
1367 /* read ack */
1368 buspirate_serial_read(buspirate_fd, tmp, 2); /* drop pirate command ret vals */
1369 buspirate_serial_read(buspirate_fd, tmp, to_send - 2); /* ack bits */
1370
1371 return tmp[2] << 2 | tmp[1] << 1 | tmp[0];
1372 }
1373
1374 static void buspirate_swd_idle_clocks(uint32_t no_bits)
1375 {
1376 uint32_t no_bytes;
1377 uint8_t tmp[20];
1378
1379 no_bytes = (no_bits + 7) / 8;
1380 memset(tmp + 1, 0x00, sizeof(tmp) - 1);
1381
1382 /* unfortunately bus pirate misbehaves when clocks are sent in parts
1383 * so we need to limit at 128 clock cycles
1384 */
1385 if (no_bytes > 16)
1386 no_bytes = 16;
1387
1388 while (no_bytes) {
1389 uint8_t to_send = no_bytes > 16 ? 16 : no_bytes;
1390 tmp[0] = 0x10 + ((to_send - 1) & 0x0F);
1391
1392 buspirate_serial_write(buspirate_fd, tmp, to_send + 1);
1393 buspirate_serial_read(buspirate_fd, tmp, to_send + 1);
1394
1395 no_bytes -= to_send;
1396 }
1397 }
1398
1399 static void buspirate_swd_clear_sticky_errors(void)
1400 {
1401 buspirate_swd_write_reg(swd_cmd(false, false, DP_ABORT),
1402 STKCMPCLR | STKERRCLR | WDERRCLR | ORUNERRCLR, 0);
1403 }
1404
1405 static void buspirate_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
1406 {
1407 uint8_t tmp[16];
1408
1409 LOG_DEBUG("buspirate_swd_read_reg");
1410 assert(cmd & SWD_CMD_RnW);
1411
1412 if (queued_retval != ERROR_OK) {
1413 LOG_DEBUG("Skip buspirate_swd_read_reg because queued_retval=%d", queued_retval);
1414 return;
1415 }
1416
1417 cmd |= SWD_CMD_START | SWD_CMD_PARK;
1418 uint8_t ack = buspirate_swd_write_header(cmd);
1419
1420 /* do a read transaction */
1421 tmp[0] = 0x06; /* 4 data bytes */
1422 tmp[1] = 0x06;
1423 tmp[2] = 0x06;
1424 tmp[3] = 0x06;
1425 tmp[4] = 0x07; /* parity bit */
1426 tmp[5] = 0x21; /* 2 turnaround clocks */
1427
1428 buspirate_serial_write(buspirate_fd, tmp, 6);
1429 buspirate_serial_read(buspirate_fd, tmp, 6);
1430
1431 /* store the data and parity */
1432 uint32_t data = (uint8_t) tmp[0];
1433 data |= (uint8_t) tmp[1] << 8;
1434 data |= (uint8_t) tmp[2] << 16;
1435 data |= (uint8_t) tmp[3] << 24;
1436 int parity = tmp[4] ? 0x01 : 0x00;
1437
1438 LOG_DEBUG("%s %s %s reg %X = %08"PRIx32,
1439 ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
1440 cmd & SWD_CMD_APnDP ? "AP" : "DP",
1441 cmd & SWD_CMD_RnW ? "read" : "write",
1442 (cmd & SWD_CMD_A32) >> 1,
1443 data);
1444
1445 switch (ack) {
1446 case SWD_ACK_OK:
1447 if (parity != parity_u32(data)) {
1448 LOG_DEBUG("Read data parity mismatch %x %x", parity, parity_u32(data));
1449 queued_retval = ERROR_FAIL;
1450 return;
1451 }
1452 if (value)
1453 *value = data;
1454 if (cmd & SWD_CMD_APnDP)
1455 buspirate_swd_idle_clocks(ap_delay_clk);
1456 return;
1457 case SWD_ACK_WAIT:
1458 LOG_DEBUG("SWD_ACK_WAIT");
1459 buspirate_swd_clear_sticky_errors();
1460 return;
1461 case SWD_ACK_FAULT:
1462 LOG_DEBUG("SWD_ACK_FAULT");
1463 queued_retval = ack;
1464 return;
1465 default:
1466 LOG_DEBUG("No valid acknowledge: ack=%d", ack);
1467 queued_retval = ack;
1468 return;
1469 }
1470 }
1471
1472 static void buspirate_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
1473 {
1474 uint8_t tmp[16];
1475
1476 LOG_DEBUG("buspirate_swd_write_reg");
1477 assert(!(cmd & SWD_CMD_RnW));
1478
1479 if (queued_retval != ERROR_OK) {
1480 LOG_DEBUG("Skip buspirate_swd_write_reg because queued_retval=%d", queued_retval);
1481 return;
1482 }
1483
1484 cmd |= SWD_CMD_START | SWD_CMD_PARK;
1485 uint8_t ack = buspirate_swd_write_header(cmd);
1486
1487 /* do a write transaction */
1488 tmp[0] = 0x10 + ((4 + 1 - 1) & 0xF); /* bus pirate: send 4+1 bytes */
1489 buf_set_u32((uint8_t *) tmp + 1, 0, 32, value);
1490 /* write sequence ends with parity bit and 7 idle ticks */
1491 tmp[5] = parity_u32(value) ? 0x01 : 0x00;
1492
1493 buspirate_serial_write(buspirate_fd, tmp, 6);
1494 buspirate_serial_read(buspirate_fd, tmp, 6);
1495
1496 LOG_DEBUG("%s %s %s reg %X = %08"PRIx32,
1497 ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
1498 cmd & SWD_CMD_APnDP ? "AP" : "DP",
1499 cmd & SWD_CMD_RnW ? "read" : "write",
1500 (cmd & SWD_CMD_A32) >> 1,
1501 value);
1502
1503 switch (ack) {
1504 case SWD_ACK_OK:
1505 if (cmd & SWD_CMD_APnDP)
1506 buspirate_swd_idle_clocks(ap_delay_clk);
1507 return;
1508 case SWD_ACK_WAIT:
1509 LOG_DEBUG("SWD_ACK_WAIT");
1510 buspirate_swd_clear_sticky_errors();
1511 return;
1512 case SWD_ACK_FAULT:
1513 LOG_DEBUG("SWD_ACK_FAULT");
1514 queued_retval = ack;
1515 return;
1516 default:
1517 LOG_DEBUG("No valid acknowledge: ack=%d", ack);
1518 queued_retval = ack;
1519 return;
1520 }
1521 }
1522
1523 static int buspirate_swd_run_queue(void)
1524 {
1525 LOG_DEBUG("buspirate_swd_run_queue");
1526 /* A transaction must be followed by another transaction or at least 8 idle cycles to
1527 * ensure that data is clocked through the AP. */
1528 buspirate_swd_idle_clocks(8);
1529
1530 int retval = queued_retval;
1531 queued_retval = ERROR_OK;
1532 LOG_DEBUG("SWD queue return value: %02x", retval);
1533 return retval;
1534 }
1535
1536
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)