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