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