?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add SWD protocol support to buspirate (2nd try)
[openocd.git] / src / jtag / drivers / buspirate.c
blob76be103e6928edab77ffe0c6b0851bc31046931d
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, char *, 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, char *buf, int size);
159 static int buspirate_serial_read(int fd, char *buf, int size);
160 static void buspirate_serial_close(int fd);
161 static void buspirate_print_buffer(char *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 DEBUG_JTAG_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 DEBUG_JTAG_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 DEBUG_JTAG_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 DEBUG_JTAG_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 DEBUG_JTAG_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 DEBUG_JTAG_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 DEBUG_JTAG_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 char 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 },
495 {
496 .name = "buspirate_vreg",
497 .usage = "<1|0>",
498 .handler = &buspirate_handle_vreg_command,
499 .mode = COMMAND_CONFIG,
500 .help = "changes the state of voltage regulators",
501 },
502 {
503 .name = "buspirate_pullup",
504 .usage = "<1|0>",
505 .handler = &buspirate_handle_pullup_command,
506 .mode = COMMAND_CONFIG,
507 .help = "changes the state of pullup",
508 },
509 {
510 .name = "buspirate_led",
511 .usage = "<1|0>",
512 .handler = &buspirate_handle_led_command,
513 .mode = COMMAND_EXEC,
514 .help = "changes the state of led",
515 },
516 {
517 .name = "buspirate_speed",
518 .usage = "<normal|fast>",
519 .handler = &buspirate_handle_speed_command,
520 .mode = COMMAND_CONFIG,
521 .help = "speed of the interface",
522 },
523 {
524 .name = "buspirate_mode",
525 .usage = "<normal|open-drain>",
526 .handler = &buspirate_handle_mode_command,
527 .mode = COMMAND_CONFIG,
528 .help = "pin mode of the interface",
529 },
530 {
531 .name = "buspirate_port",
532 .usage = "/dev/ttyUSB0",
533 .handler = &buspirate_handle_port_command,
534 .mode = COMMAND_CONFIG,
535 .help = "name of the serial port to open",
536 },
537 COMMAND_REGISTRATION_DONE
538 };
539
540 static const struct swd_driver buspirate_swd = {
541 .init = buspirate_swd_init,
542 .switch_seq = buspirate_swd_switch_seq,
543 .read_reg = buspirate_swd_read_reg,
544 .write_reg = buspirate_swd_write_reg,
545 .run = buspirate_swd_run_queue,
546 };
547
548 static const char * const buspirate_transports[] = { "jtag", "swd", NULL };
549
550 struct jtag_interface buspirate_interface = {
551 .name = "buspirate",
552 .execute_queue = buspirate_execute_queue,
553 .commands = buspirate_command_handlers,
554 .transports = buspirate_transports,
555 .swd = &buspirate_swd,
556 .init = buspirate_init,
557 .quit = buspirate_quit
558 };
559
560 /*************** jtag execute commands **********************/
561 static void buspirate_end_state(tap_state_t state)
562 {
563 if (tap_is_state_stable(state))
564 tap_set_end_state(state);
565 else {
566 LOG_ERROR("BUG: %i is not a valid end state", state);
567 exit(-1);
568 }
569 }
570
571 static void buspirate_state_move(void)
572 {
573 int i = 0, tms = 0;
574 uint8_t tms_scan = tap_get_tms_path(tap_get_state(),
575 tap_get_end_state());
576 int tms_count = tap_get_tms_path_len(tap_get_state(),
577 tap_get_end_state());
578
579 for (i = 0; i < tms_count; i++) {
580 tms = (tms_scan >> i) & 1;
581 buspirate_tap_append(tms, 0);
582 }
583
584 tap_set_state(tap_get_end_state());
585 }
586
587 static void buspirate_path_move(int num_states, tap_state_t *path)
588 {
589 int i;
590
591 for (i = 0; i < num_states; i++) {
592 if (tap_state_transition(tap_get_state(), false) == path[i]) {
593 buspirate_tap_append(0, 0);
594 } else if (tap_state_transition(tap_get_state(), true)
595 == path[i]) {
596 buspirate_tap_append(1, 0);
597 } else {
598 LOG_ERROR("BUG: %s -> %s isn't a valid "
599 "TAP transition",
600 tap_state_name(tap_get_state()),
601 tap_state_name(path[i]));
602 exit(-1);
603 }
604
605 tap_set_state(path[i]);
606 }
607
608 tap_set_end_state(tap_get_state());
609 }
610
611 static void buspirate_runtest(int num_cycles)
612 {
613 int i;
614
615 tap_state_t saved_end_state = tap_get_end_state();
616
617 /* only do a state_move when we're not already in IDLE */
618 if (tap_get_state() != TAP_IDLE) {
619 buspirate_end_state(TAP_IDLE);
620 buspirate_state_move();
621 }
622
623 for (i = 0; i < num_cycles; i++)
624 buspirate_tap_append(0, 0);
625
626 DEBUG_JTAG_IO("runtest: cur_state %s end_state %s",
627 tap_state_name(tap_get_state()),
628 tap_state_name(tap_get_end_state()));
629
630 /* finish in end_state */
631 buspirate_end_state(saved_end_state);
632 if (tap_get_state() != tap_get_end_state())
633 buspirate_state_move();
634 }
635
636 static void buspirate_scan(bool ir_scan, enum scan_type type,
637 uint8_t *buffer, int scan_size, struct scan_command *command)
638 {
639 tap_state_t saved_end_state;
640
641 buspirate_tap_make_space(1, scan_size+8);
642 /* is 8 correct ? (2 moves = 16) */
643
644 saved_end_state = tap_get_end_state();
645
646 buspirate_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
647
648 /* Only move if we're not already there */
649 if (tap_get_state() != tap_get_end_state())
650 buspirate_state_move();
651
652 buspirate_tap_append_scan(scan_size, buffer, command);
653
654 /* move to PAUSE */
655 buspirate_tap_append(0, 0);
656
657 /* restore the saved state */
658 buspirate_end_state(saved_end_state);
659 tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
660
661 if (tap_get_state() != tap_get_end_state())
662 buspirate_state_move();
663 }
664
665 static void buspirate_stableclocks(int num_cycles)
666 {
667 int i;
668 int tms = (tap_get_state() == TAP_RESET ? 1 : 0);
669
670 buspirate_tap_make_space(0, num_cycles);
671
672 for (i = 0; i < num_cycles; i++)
673 buspirate_tap_append(tms, 0);
674 }
675
676 /************************* TAP related stuff **********/
677
678 /* This buffer size matches the maximum CMD_TAP_SHIFT bit length in the Bus Pirate firmware,
679 look for constant 0x2000 in OpenOCD.c . */
680 #define BUSPIRATE_BUFFER_SIZE 1024
681
682 /* The old value of 32 scans was not enough to achieve near 100% utilisation ratio
683 for the current BUSPIRATE_BUFFER_SIZE value of 1024.
684 With 128 scans I am getting full USB 2.0 high speed packets (512 bytes long) when
685 using the JtagDue firmware on the Arduino Due instead of the Bus Pirate, which
686 amounts approximately to a 10% overall speed gain. Bigger packets should also
687 benefit the Bus Pirate, but the speed difference is much smaller.
688 Unfortunately, each 512-byte packet is followed by a 329-byte one, which is not ideal.
689 However, increasing BUSPIRATE_BUFFER_SIZE for the benefit of the JtagDue would
690 make it incompatible with the Bus Pirate firmware. */
691 #define BUSPIRATE_MAX_PENDING_SCANS 128
692
693 static char tms_chain[BUSPIRATE_BUFFER_SIZE]; /* send */
694 static char tdi_chain[BUSPIRATE_BUFFER_SIZE]; /* send */
695 static int tap_chain_index;
696
697 struct pending_scan_result /* this was stolen from arm-jtag-ew */
698 {
699 int first; /* First bit position in tdo_buffer to read */
700 int length; /* Number of bits to read */
701 struct scan_command *command; /* Corresponding scan command */
702 uint8_t *buffer;
703 };
704
705 static struct pending_scan_result
706 tap_pending_scans[BUSPIRATE_MAX_PENDING_SCANS];
707 static int tap_pending_scans_num;
708
709 static void buspirate_tap_init(void)
710 {
711 tap_chain_index = 0;
712 tap_pending_scans_num = 0;
713 }
714
715 static int buspirate_tap_execute(void)
716 {
717 static const int CMD_TAP_SHIFT_HEADER_LEN = 3;
718
719 char tmp[4096];
720 uint8_t *in_buf;
721 int i;
722 int fill_index = 0;
723 int ret;
724 int bytes_to_send;
725
726 if (tap_chain_index <= 0)
727 return ERROR_OK;
728
729 LOG_DEBUG("executing tap num bits = %i scans = %i",
730 tap_chain_index, tap_pending_scans_num);
731
732 bytes_to_send = DIV_ROUND_UP(tap_chain_index, 8);
733
734 tmp[0] = CMD_TAP_SHIFT; /* this command expects number of bits */
735 tmp[1] = (char)(tap_chain_index >> 8); /* high */
736 tmp[2] = (char)(tap_chain_index); /* low */
737
738 fill_index = CMD_TAP_SHIFT_HEADER_LEN;
739 for (i = 0; i < bytes_to_send; i++) {
740 tmp[fill_index] = tdi_chain[i];
741 fill_index++;
742 tmp[fill_index] = tms_chain[i];
743 fill_index++;
744 }
745
746 /* jlink.c calls the routine below, which may be useful for debugging purposes.
747 For example, enabling this allows you to compare the log outputs from jlink.c
748 and from this module for JTAG development or troubleshooting purposes. */
749 if (false) {
750 last_tap_state = jtag_debug_state_machine(tms_chain, tdi_chain,
751 tap_chain_index, last_tap_state);
752 }
753
754 ret = buspirate_serial_write(buspirate_fd, tmp, CMD_TAP_SHIFT_HEADER_LEN + bytes_to_send*2);
755 if (ret != bytes_to_send*2+CMD_TAP_SHIFT_HEADER_LEN) {
756 LOG_ERROR("error writing :(");
757 return ERROR_JTAG_DEVICE_ERROR;
758 }
759
760 ret = buspirate_serial_read(buspirate_fd, tmp, bytes_to_send + CMD_TAP_SHIFT_HEADER_LEN);
761 if (ret != bytes_to_send + CMD_TAP_SHIFT_HEADER_LEN) {
762 LOG_ERROR("error reading");
763 return ERROR_FAIL;
764 }
765 in_buf = (uint8_t *)(&tmp[CMD_TAP_SHIFT_HEADER_LEN]);
766
767 /* parse the scans */
768 for (i = 0; i < tap_pending_scans_num; i++) {
769 uint8_t *buffer = tap_pending_scans[i].buffer;
770 int length = tap_pending_scans[i].length;
771 int first = tap_pending_scans[i].first;
772 struct scan_command *command = tap_pending_scans[i].command;
773
774 /* copy bits from buffer */
775 buf_set_buf(in_buf, first, buffer, 0, length);
776
777 /* return buffer to higher level */
778 if (jtag_read_buffer(buffer, command) != ERROR_OK) {
779 buspirate_tap_init();
780 return ERROR_JTAG_QUEUE_FAILED;
781 }
782
783 free(buffer);
784 }
785 buspirate_tap_init();
786 return ERROR_OK;
787 }
788
789 static void buspirate_tap_make_space(int scans, int bits)
790 {
791 int have_scans = BUSPIRATE_MAX_PENDING_SCANS - tap_pending_scans_num;
792 int have_bits = BUSPIRATE_BUFFER_SIZE * 8 - tap_chain_index;
793
794 if ((have_scans < scans) || (have_bits < bits))
795 buspirate_tap_execute();
796 }
797
798 static void buspirate_tap_append(int tms, int tdi)
799 {
800 int chain_index;
801
802 buspirate_tap_make_space(0, 1);
803 chain_index = tap_chain_index / 8;
804
805 if (chain_index < BUSPIRATE_BUFFER_SIZE) {
806 int bit_index = tap_chain_index % 8;
807 uint8_t bit = 1 << bit_index;
808
809 if (0 == bit_index) {
810 /* Let's say that the TAP shift operation wants to shift 9 bits,
811 so we will be sending to the Bus Pirate a bit count of 9 but still
812 full 16 bits (2 bytes) of shift data.
813 If we don't clear all bits at this point, the last 7 bits will contain
814 random data from the last buffer contents, which is not pleasant to the eye.
815 Besides, the Bus Pirate (or some clone) may want to assert in debug builds
816 that, after consuming all significant data bits, the rest of them are zero.
817 Therefore, for aesthetic and for assert purposes, we clear all bits below. */
818 tms_chain[chain_index] = 0;
819 tdi_chain[chain_index] = 0;
820 }
821
822 if (tms)
823 tms_chain[chain_index] |= bit;
824 else
825 tms_chain[chain_index] &= ~bit;
826
827 if (tdi)
828 tdi_chain[chain_index] |= bit;
829 else
830 tdi_chain[chain_index] &= ~bit;
831
832 tap_chain_index++;
833 } else {
834 LOG_ERROR("tap_chain overflow, bad things will happen");
835 /* Exit abruptly, like jlink.c does. After a buffer overflow we don't want
836 to carry on, as data will be corrupt. Another option would be to return
837 some error code at this point. */
838 exit(-1);
839 }
840 }
841
842 static void buspirate_tap_append_scan(int length, uint8_t *buffer,
843 struct scan_command *command)
844 {
845 int i;
846 tap_pending_scans[tap_pending_scans_num].length = length;
847 tap_pending_scans[tap_pending_scans_num].buffer = buffer;
848 tap_pending_scans[tap_pending_scans_num].command = command;
849 tap_pending_scans[tap_pending_scans_num].first = tap_chain_index;
850
851 for (i = 0; i < length; i++) {
852 int tms = (i < length-1 ? 0 : 1);
853 int tdi = (buffer[i/8] >> (i%8)) & 1;
854 buspirate_tap_append(tms, tdi);
855 }
856 tap_pending_scans_num++;
857 }
858
859 /*************** wrapper functions *********************/
860
861 /* (1) assert or (0) deassert reset lines */
862 static void buspirate_reset(int trst, int srst)
863 {
864 LOG_DEBUG("trst: %i, srst: %i", trst, srst);
865
866 if (trst)
867 buspirate_set_feature(buspirate_fd, FEATURE_TRST, ACTION_DISABLE);
868 else
869 buspirate_set_feature(buspirate_fd, FEATURE_TRST, ACTION_ENABLE);
870
871 if (srst)
872 buspirate_set_feature(buspirate_fd, FEATURE_SRST, ACTION_DISABLE);
873 else
874 buspirate_set_feature(buspirate_fd, FEATURE_SRST, ACTION_ENABLE);
875 }
876
877 static void buspirate_set_feature(int fd, char feat, char action)
878 {
879 if (swd_mode)
880 buspirate_swd_set_feature(fd, feat, action);
881 else
882 buspirate_jtag_set_feature(fd, feat, action);
883 }
884
885 static void buspirate_set_mode(int fd, char mode)
886 {
887 if (swd_mode)
888 buspirate_swd_set_mode(fd, mode);
889 else
890 buspirate_jtag_set_mode(fd, mode);
891 }
892
893 static void buspirate_set_speed(int fd, char speed)
894 {
895 if (swd_mode)
896 buspirate_swd_set_speed(fd, speed);
897 else
898 buspirate_jtag_set_speed(fd, speed);
899 }
900
901
902 /*************** swd lowlevel functions ********************/
903
904 static void buspirate_swd_set_speed(int fd, char speed)
905 {
906 int ret;
907 char tmp[1];
908
909 LOG_DEBUG("Buspirate speed setting in SWD mode defaults to 400 kHz");
910
911 /* speed settings */
912 tmp[0] = CMD_RAW_SPEED | SPEED_RAW_400_KHZ;
913 buspirate_serial_write(fd, tmp, 1);
914 ret = buspirate_serial_read(fd, tmp, 1);
915 if (ret != 1) {
916 LOG_ERROR("Buspirate did not answer correctly");
917 exit(-1);
918 }
919 if (tmp[0] != 1) {
920 LOG_ERROR("Buspirate did not reply as expected to the speed change command");
921 exit(-1);
922 }
923 }
924
925 static void buspirate_swd_set_mode(int fd, char mode)
926 {
927 int ret;
928 char tmp[1];
929
930 /* raw-wire mode configuration */
931 if (mode == MODE_HIZ)
932 tmp[0] = CMD_RAW_MODE | CMD_RAW_CONFIG_LSB;
933 else
934 tmp[0] = CMD_RAW_MODE | CMD_RAW_CONFIG_LSB | CMD_RAW_CONFIG_3V3;
935
936 buspirate_serial_write(fd, tmp, 1);
937 ret = buspirate_serial_read(fd, tmp, 1);
938 if (ret != 1) {
939 LOG_ERROR("Buspirate did not answer correctly");
940 exit(-1);
941 }
942 if (tmp[0] != 1) {
943 LOG_ERROR("Buspirate did not reply as expected to the configure command");
944 exit(-1);
945 }
946 }
947
948 static void buspirate_swd_set_feature(int fd, char feat, char action)
949 {
950 int ret;
951 char tmp[1];
952
953 switch (feat) {
954 case FEATURE_TRST:
955 LOG_DEBUG("Buspirate TRST feature not available in SWD mode");
956 return;
957 case FEATURE_LED:
958 LOG_ERROR("Buspirate LED feature not available in SWD mode");
959 return;
960 case FEATURE_SRST:
961 swd_features = (action == ACTION_ENABLE) ? swd_features | 0x02 : swd_features & 0x0D;
962 break;
963 case FEATURE_PULLUP:
964 swd_features = (action == ACTION_ENABLE) ? swd_features | 0x04 : swd_features & 0x0B;
965 break;
966 case FEATURE_VREG:
967 swd_features = (action == ACTION_ENABLE) ? swd_features | 0x08 : swd_features & 0x07;
968 break;
969 default:
970 LOG_DEBUG("Buspirate unknown feature %d", feat);
971 return;
972 }
973
974 tmp[0] = CMD_RAW_PERIPH | swd_features;
975 buspirate_serial_write(fd, tmp, 1);
976 ret = buspirate_serial_read(fd, tmp, 1);
977 if (ret != 1) {
978 LOG_DEBUG("Buspirate feature %d not supported in SWD mode", feat);
979 } else if (tmp[0] != 1) {
980 LOG_ERROR("Buspirate did not reply as expected to the configure command");
981 exit(-1);
982 }
983 }
984
985 /*************** jtag lowlevel functions ********************/
986 static void buspirate_bbio_enable(int fd)
987 {
988 int ret;
989 char command;
990 const char *mode_answers[2] = { "OCD1", "RAW1" };
991 const char *correct_ans = NULL;
992 char tmp[21] = { [0 ... 20] = 0x00 };
993 int done = 0;
994 int cmd_sent = 0;
995
996 if (swd_mode) {
997 command = CMD_ENTER_RWIRE;
998 correct_ans = mode_answers[1];
999 } else {
1000 command = CMD_ENTER_OOCD;
1001 correct_ans = mode_answers[0];
1002 }
1003
1004 LOG_DEBUG("Entering binary mode, that is %s", correct_ans);
1005 buspirate_serial_write(fd, tmp, 20);
1006 usleep(10000);
1007
1008 /* reads 1 to n "BBIO1"s and one "OCD1" or "RAW1" */
1009 while (!done) {
1010 ret = buspirate_serial_read(fd, tmp, 4);
1011 if (ret != 4) {
1012 LOG_ERROR("Buspirate error. Is binary"
1013 "/OpenOCD support enabled?");
1014 exit(-1);
1015 }
1016 if (strncmp(tmp, "BBIO", 4) == 0) {
1017 ret = buspirate_serial_read(fd, tmp, 1);
1018 if (ret != 1) {
1019 LOG_ERROR("Buspirate did not answer correctly! "
1020 "Do you have correct firmware?");
1021 exit(-1);
1022 }
1023 if (tmp[0] != '1') {
1024 LOG_ERROR("Unsupported binary protocol");
1025 exit(-1);
1026 }
1027 if (cmd_sent == 0) {
1028 cmd_sent = 1;
1029 tmp[0] = command;
1030 ret = buspirate_serial_write(fd, tmp, 1);
1031 if (ret != 1) {
1032 LOG_ERROR("error reading");
1033 exit(-1);
1034 }
1035 }
1036 } else if (strncmp(tmp, correct_ans, 4) == 0)
1037 done = 1;
1038 else {
1039 LOG_ERROR("Buspirate did not answer correctly! "
1040 "Do you have correct firmware?");
1041 exit(-1);
1042 }
1043 }
1044
1045 }
1046
1047 static void buspirate_jtag_reset(int fd)
1048 {
1049 char tmp[5];
1050
1051 tmp[0] = 0x00; /* exit OCD1 mode */
1052 buspirate_serial_write(fd, tmp, 1);
1053 usleep(10000);
1054 /* We ignore the return value here purposly, nothing we can do */
1055 buspirate_serial_read(fd, tmp, 5);
1056 if (strncmp(tmp, "BBIO1", 5) == 0) {
1057 tmp[0] = 0x0F; /* reset BP */
1058 buspirate_serial_write(fd, tmp, 1);
1059 } else
1060 LOG_ERROR("Unable to restart buspirate!");
1061 }
1062
1063 static void buspirate_jtag_set_speed(int fd, char speed)
1064 {
1065 int ret;
1066 char tmp[2];
1067 char ack[2];
1068
1069 ack[0] = 0xAA;
1070 ack[1] = 0x55;
1071
1072 tmp[0] = CMD_UART_SPEED;
1073 tmp[1] = speed;
1074 buspirate_jtag_command(fd, tmp, 2);
1075
1076 /* here the adapter changes speed, we need follow */
1077 if (-1 == buspirate_serial_setspeed(fd, speed, NORMAL_TIMEOUT)) {
1078 LOG_ERROR("Error configuring the serial port.");
1079 exit(-1);
1080 }
1081
1082 buspirate_serial_write(fd, ack, 2);
1083 ret = buspirate_serial_read(fd, tmp, 2);
1084 if (ret != 2) {
1085 LOG_ERROR("Buspirate did not ack speed change");
1086 exit(-1);
1087 }
1088 if ((tmp[0] != CMD_UART_SPEED) || (tmp[1] != speed)) {
1089 LOG_ERROR("Buspirate did not reply as expected to the speed change command");
1090 exit(-1);
1091 }
1092 LOG_INFO("Buspirate switched to %s mode",
1093 (speed == SERIAL_NORMAL) ? "normal" : "FAST");
1094 }
1095
1096
1097 static void buspirate_jtag_set_mode(int fd, char mode)
1098 {
1099 char tmp[2];
1100 tmp[0] = CMD_PORT_MODE;
1101 tmp[1] = mode;
1102 buspirate_jtag_command(fd, tmp, 2);
1103 }
1104
1105 static void buspirate_jtag_set_feature(int fd, char feat, char action)
1106 {
1107 char tmp[3];
1108 tmp[0] = CMD_FEATURE;
1109 tmp[1] = feat; /* what */
1110 tmp[2] = action; /* action */
1111 buspirate_jtag_command(fd, tmp, 3);
1112 }
1113
1114 static void buspirate_jtag_get_adcs(int fd)
1115 {
1116 uint8_t tmp[10];
1117 uint16_t a, b, c, d;
1118 tmp[0] = CMD_READ_ADCS;
1119 buspirate_jtag_command(fd, (char *)tmp, 1);
1120 a = tmp[2] << 8 | tmp[3];
1121 b = tmp[4] << 8 | tmp[5];
1122 c = tmp[6] << 8 | tmp[7];
1123 d = tmp[8] << 8 | tmp[9];
1124
1125 LOG_INFO("ADC: ADC_Pin = %.02f VPullup = %.02f V33 = %.02f "
1126 "V50 = %.02f",
1127 ((float)a)/155.1515, ((float)b)/155.1515,
1128 ((float)c)/155.1515, ((float)d)/155.1515);
1129 }
1130
1131 static unsigned char buspirate_jtag_command(int fd,
1132 char *cmd, int cmdlen)
1133 {
1134 int res;
1135 int len = 0;
1136
1137 res = buspirate_serial_write(fd, cmd, cmdlen);
1138
1139 if ((cmd[0] == CMD_UART_SPEED)
1140 || (cmd[0] == CMD_PORT_MODE)
1141 || (cmd[0] == CMD_FEATURE)
1142 || (cmd[0] == CMD_JTAG_SPEED))
1143 return 1;
1144
1145 if (res == cmdlen) {
1146 switch (cmd[0]) {
1147 case CMD_READ_ADCS:
1148 len = 10; /* 2*sizeof(char)+4*sizeof(uint16_t) */
1149 break;
1150 case CMD_TAP_SHIFT:
1151 len = cmdlen;
1152 break;
1153 default:
1154 LOG_INFO("Wrong !");
1155 }
1156 res = buspirate_serial_read(fd, cmd, len);
1157 if (res > 0)
1158 return (unsigned char)cmd[1];
1159 else
1160 return -1;
1161 } else
1162 return -1;
1163 return 0;
1164 }
1165
1166 /* low level serial port */
1167 /* TODO add support for WIN32 and others ! */
1168 static int buspirate_serial_open(char *port)
1169 {
1170 int fd;
1171 fd = open(buspirate_port, O_RDWR | O_NOCTTY | O_NDELAY);
1172 return fd;
1173 }
1174
1175
1176 /* Returns -1 on error. */
1177
1178 static int buspirate_serial_setspeed(int fd, char speed, cc_t timeout)
1179 {
1180 struct termios t_opt;
1181 speed_t baud = (speed == SERIAL_FAST) ? B1000000 : B115200;
1182
1183 /* set the serial port parameters */
1184 fcntl(fd, F_SETFL, 0);
1185 if (0 != tcgetattr(fd, &t_opt))
1186 return -1;
1187
1188 if (0 != cfsetispeed(&t_opt, baud))
1189 return -1;
1190
1191 if (0 != cfsetospeed(&t_opt, baud))
1192 return -1;
1193
1194 t_opt.c_cflag |= (CLOCAL | CREAD);
1195 t_opt.c_cflag &= ~PARENB;
1196 t_opt.c_cflag &= ~CSTOPB;
1197 t_opt.c_cflag &= ~CSIZE;
1198 t_opt.c_cflag |= CS8;
1199 t_opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
1200
1201 /* The serial port may have been configured for human interaction with
1202 the Bus Pirate console, but OpenOCD is going to use a binary protocol,
1203 so make sure to turn off any CR/LF translation and the like. */
1204 t_opt.c_iflag &= ~(IXON | IXOFF | IXANY | INLCR | ICRNL);
1205
1206 t_opt.c_oflag &= ~OPOST;
1207 t_opt.c_cc[VMIN] = 0;
1208 t_opt.c_cc[VTIME] = timeout;
1209
1210 /* Note that, in the past, TCSANOW was used below instead of TCSADRAIN,
1211 and CMD_UART_SPEED did not work properly then, at least with
1212 the Bus Pirate v3.5 (USB). */
1213 if (0 != tcsetattr(fd, TCSADRAIN, &t_opt)) {
1214 /* According to the Linux documentation, this is actually not enough
1215 to detect errors, you need to call tcgetattr() and check that
1216 all changes have been performed successfully. */
1217 return -1;
1218 }
1219
1220 return 0;
1221 }
1222
1223 static int buspirate_serial_write(int fd, char *buf, int size)
1224 {
1225 int ret = 0;
1226
1227 ret = write(fd, buf, size);
1228
1229 LOG_DEBUG("size = %d ret = %d", size, ret);
1230 buspirate_print_buffer(buf, size);
1231
1232 if (ret != size)
1233 LOG_ERROR("Error sending data");
1234
1235 return ret;
1236 }
1237
1238 static int buspirate_serial_read(int fd, char *buf, int size)
1239 {
1240 int len = 0;
1241 int ret = 0;
1242 int timeout = 0;
1243
1244 while (len < size) {
1245 ret = read(fd, buf+len, size-len);
1246 if (ret == -1)
1247 return -1;
1248
1249 if (ret == 0) {
1250 timeout++;
1251
1252 if (timeout >= 10)
1253 break;
1254
1255 continue;
1256 }
1257
1258 len += ret;
1259 }
1260
1261 LOG_DEBUG("should have read = %d actual size = %d", size, len);
1262 buspirate_print_buffer(buf, len);
1263
1264 if (len != size)
1265 LOG_ERROR("Error reading data");
1266
1267 return len;
1268 }
1269
1270 static void buspirate_serial_close(int fd)
1271 {
1272 close(fd);
1273 }
1274
1275 #define LINE_SIZE 81
1276 #define BYTES_PER_LINE 16
1277 static void buspirate_print_buffer(char *buf, int size)
1278 {
1279 char line[LINE_SIZE];
1280 char tmp[10];
1281 int offset = 0;
1282
1283 line[0] = 0;
1284 while (offset < size) {
1285 snprintf(tmp, 5, "%02x ", (uint8_t)buf[offset]);
1286 offset++;
1287
1288 strcat(line, tmp);
1289
1290 if (offset % BYTES_PER_LINE == 0) {
1291 LOG_DEBUG("%s", line);
1292 line[0] = 0;
1293 }
1294 }
1295
1296 if (line[0] != 0)
1297 LOG_DEBUG("%s", line);
1298 }
1299
1300 /************************* SWD related stuff **********/
1301
1302 static int buspirate_swd_init(void)
1303 {
1304 LOG_INFO("Buspirate SWD mode enabled");
1305 swd_mode = true;
1306
1307 return ERROR_OK;
1308 }
1309
1310 static int buspirate_swd_switch_seq(enum swd_special_seq seq)
1311 {
1312 const uint8_t *sequence;
1313 int sequence_len;
1314 char tmp[64];
1315
1316 switch (seq) {
1317 case LINE_RESET:
1318 LOG_DEBUG("SWD line reset");
1319 sequence = swd_seq_line_reset;
1320 sequence_len = DIV_ROUND_UP(swd_seq_line_reset_len, 8);
1321 break;
1322 case JTAG_TO_SWD:
1323 LOG_DEBUG("JTAG-to-SWD");
1324 sequence = swd_seq_jtag_to_swd;
1325 sequence_len = DIV_ROUND_UP(swd_seq_jtag_to_swd_len, 8);
1326 break;
1327 case SWD_TO_JTAG:
1328 LOG_DEBUG("SWD-to-JTAG");
1329 sequence = swd_seq_swd_to_jtag;
1330 sequence_len = DIV_ROUND_UP(swd_seq_swd_to_jtag_len, 8);
1331 break;
1332 default:
1333 LOG_ERROR("Sequence %d not supported", seq);
1334 return ERROR_FAIL;
1335 }
1336
1337 /* FIXME: all above sequences fit into one pirate command for now
1338 * but it may cause trouble later
1339 */
1340
1341 tmp[0] = 0x10 + ((sequence_len - 1) & 0x0F);
1342 memcpy(tmp + 1, sequence, sequence_len);
1343
1344 buspirate_serial_write(buspirate_fd, tmp, sequence_len + 1);
1345 buspirate_serial_read(buspirate_fd, tmp, sequence_len + 1);
1346
1347 return ERROR_OK;
1348 }
1349
1350 static uint8_t buspirate_swd_write_header(uint8_t cmd)
1351 {
1352 char tmp[8];
1353 int to_send;
1354
1355 tmp[0] = 0x10; /* bus pirate: send 1 byte */
1356 tmp[1] = cmd; /* swd cmd */
1357 tmp[2] = 0x07; /* ack __x */
1358 tmp[3] = 0x07; /* ack _x_ */
1359 tmp[4] = 0x07; /* ack x__ */
1360 tmp[5] = 0x07; /* write mode trn_1 */
1361 tmp[6] = 0x07; /* write mode trn_2 */
1362
1363 to_send = ((cmd & SWD_CMD_RnW) == 0) ? 7 : 5;
1364 buspirate_serial_write(buspirate_fd, tmp, to_send);
1365
1366 /* read ack */
1367 buspirate_serial_read(buspirate_fd, tmp, 2); /* drop pirate command ret vals */
1368 buspirate_serial_read(buspirate_fd, tmp, to_send - 2); /* ack bits */
1369
1370 return tmp[2] << 2 | tmp[1] << 1 | tmp[0];
1371 }
1372
1373 static void buspirate_swd_idle_clocks(uint32_t no_bits)
1374 {
1375 uint32_t no_bytes;
1376 char tmp[20];
1377
1378 no_bytes = (no_bits + 7) / 8;
1379 memset(tmp + 1, 0x00, sizeof(tmp) - 1);
1380
1381 /* unfortunately bus pirate misbehaves when clocks are sent in parts
1382 * so we need to limit at 128 clock cycles
1383 */
1384 if (no_bytes > 16)
1385 no_bytes = 16;
1386
1387 while (no_bytes) {
1388 uint8_t to_send = no_bytes > 16 ? 16 : no_bytes;
1389 tmp[0] = 0x10 + ((to_send - 1) & 0x0F);
1390
1391 buspirate_serial_write(buspirate_fd, tmp, to_send + 1);
1392 buspirate_serial_read(buspirate_fd, tmp, to_send + 1);
1393
1394 no_bytes -= to_send;
1395 }
1396 }
1397
1398 static void buspirate_swd_clear_sticky_errors(void)
1399 {
1400 buspirate_swd_write_reg(swd_cmd(false, false, DP_ABORT),
1401 STKCMPCLR | STKERRCLR | WDERRCLR | ORUNERRCLR, 0);
1402 }
1403
1404 static void buspirate_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
1405 {
1406 char tmp[16];
1407
1408 LOG_DEBUG("buspirate_swd_read_reg");
1409 assert(cmd & SWD_CMD_RnW);
1410
1411 if (queued_retval != ERROR_OK) {
1412 LOG_DEBUG("Skip buspirate_swd_read_reg because queued_retval=%d", queued_retval);
1413 return;
1414 }
1415
1416 cmd |= SWD_CMD_START | SWD_CMD_PARK;
1417 uint8_t ack = buspirate_swd_write_header(cmd);
1418
1419 /* do a read transaction */
1420 tmp[0] = 0x06; /* 4 data bytes */
1421 tmp[1] = 0x06;
1422 tmp[2] = 0x06;
1423 tmp[3] = 0x06;
1424 tmp[4] = 0x07; /* parity bit */
1425 tmp[5] = 0x21; /* 2 turnaround clocks */
1426
1427 buspirate_serial_write(buspirate_fd, tmp, 6);
1428 buspirate_serial_read(buspirate_fd, tmp, 6);
1429
1430 /* store the data and parity */
1431 uint32_t data = (uint8_t) tmp[0];
1432 data |= (uint8_t) tmp[1] << 8;
1433 data |= (uint8_t) tmp[2] << 16;
1434 data |= (uint8_t) tmp[3] << 24;
1435 int parity = tmp[4] ? 0x01 : 0x00;
1436
1437 LOG_DEBUG("%s %s %s reg %X = %08"PRIx32,
1438 ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
1439 cmd & SWD_CMD_APnDP ? "AP" : "DP",
1440 cmd & SWD_CMD_RnW ? "read" : "write",
1441 (cmd & SWD_CMD_A32) >> 1,
1442 data);
1443
1444 switch (ack) {
1445 case SWD_ACK_OK:
1446 if (parity != parity_u32(data)) {
1447 LOG_DEBUG("Read data parity mismatch %x %x", parity, parity_u32(data));
1448 queued_retval = ERROR_FAIL;
1449 return;
1450 }
1451 if (value)
1452 *value = data;
1453 if (cmd & SWD_CMD_APnDP)
1454 buspirate_swd_idle_clocks(ap_delay_clk);
1455 return;
1456 case SWD_ACK_WAIT:
1457 LOG_DEBUG("SWD_ACK_WAIT");
1458 buspirate_swd_clear_sticky_errors();
1459 return;
1460 case SWD_ACK_FAULT:
1461 LOG_DEBUG("SWD_ACK_FAULT");
1462 queued_retval = ack;
1463 return;
1464 default:
1465 LOG_DEBUG("No valid acknowledge: ack=%d", ack);
1466 queued_retval = ack;
1467 return;
1468 }
1469 }
1470
1471 static void buspirate_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
1472 {
1473 char tmp[16];
1474
1475 LOG_DEBUG("buspirate_swd_write_reg");
1476 assert(!(cmd & SWD_CMD_RnW));
1477
1478 if (queued_retval != ERROR_OK) {
1479 LOG_DEBUG("Skip buspirate_swd_write_reg because queued_retval=%d", queued_retval);
1480 return;
1481 }
1482
1483 cmd |= SWD_CMD_START | SWD_CMD_PARK;
1484 uint8_t ack = buspirate_swd_write_header(cmd);
1485
1486 /* do a write transaction */
1487 tmp[0] = 0x10 + ((4 + 1 - 1) & 0xF); /* bus pirate: send 4+1 bytes */
1488 buf_set_u32((uint8_t *) tmp + 1, 0, 32, value);
1489 /* write sequence ends with parity bit and 7 idle ticks */
1490 tmp[5] = parity_u32(value) ? 0x01 : 0x00;
1491
1492 buspirate_serial_write(buspirate_fd, tmp, 6);
1493 buspirate_serial_read(buspirate_fd, tmp, 6);
1494
1495 LOG_DEBUG("%s %s %s reg %X = %08"PRIx32,
1496 ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
1497 cmd & SWD_CMD_APnDP ? "AP" : "DP",
1498 cmd & SWD_CMD_RnW ? "read" : "write",
1499 (cmd & SWD_CMD_A32) >> 1,
1500 value);
1501
1502 switch (ack) {
1503 case SWD_ACK_OK:
1504 if (cmd & SWD_CMD_APnDP)
1505 buspirate_swd_idle_clocks(ap_delay_clk);
1506 return;
1507 case SWD_ACK_WAIT:
1508 LOG_DEBUG("SWD_ACK_WAIT");
1509 buspirate_swd_clear_sticky_errors();
1510 return;
1511 case SWD_ACK_FAULT:
1512 LOG_DEBUG("SWD_ACK_FAULT");
1513 queued_retval = ack;
1514 return;
1515 default:
1516 LOG_DEBUG("No valid acknowledge: ack=%d", ack);
1517 queued_retval = ack;
1518 return;
1519 }
1520 }
1521
1522 static int buspirate_swd_run_queue(void)
1523 {
1524 LOG_DEBUG("buspirate_swd_run_queue");
1525 /* A transaction must be followed by another transaction or at least 8 idle cycles to
1526 * ensure that data is clocked through the AP. */
1527 buspirate_swd_idle_clocks(8);
1528
1529 int retval = queued_retval;
1530 queued_retval = ERROR_OK;
1531 LOG_DEBUG("SWD queue return value: %02x", retval);
1532 return retval;
1533 }
1534
1535
Official OpenOCD Mirror