34dcd2b52e5679b59f3ea22fd9b9b06a9f0e9110
[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 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
19 ***************************************************************************/
20
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24
25 #include <jtag/interface.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
45 #define CMD_UNKNOWN 0x00
46 #define CMD_PORT_MODE 0x01
47 #define CMD_FEATURE 0x02
48 #define CMD_READ_ADCS 0x03
49 /*#define CMD_TAP_SHIFT 0x04 // old protocol */
50 #define CMD_TAP_SHIFT 0x05
51 #define CMD_ENTER_OOCD 0x06
52 #define CMD_UART_SPEED 0x07
53 #define CMD_JTAG_SPEED 0x08
54
55 /* Not all OSes have this speed defined */
56 #if !defined(B1000000)
57 #define B1000000 0010010
58 #endif
59
60 enum {
61 MODE_HIZ = 0,
62 MODE_JTAG = 1, /* push-pull outputs */
63 MODE_JTAG_OD = 2, /* open-drain outputs */
64 };
65
66 enum {
67 FEATURE_LED = 0x01,
68 FEATURE_VREG = 0x02,
69 FEATURE_TRST = 0x04,
70 FEATURE_SRST = 0x08,
71 FEATURE_PULLUP = 0x10
72 };
73
74 enum {
75 ACTION_DISABLE = 0,
76 ACTION_ENABLE = 1
77 };
78
79 enum {
80 SERIAL_NORMAL = 0,
81 SERIAL_FAST = 1
82 };
83
84 static int buspirate_fd = -1;
85 static int buspirate_pinmode = MODE_JTAG_OD;
86 static int buspirate_baudrate = SERIAL_NORMAL;
87 static int buspirate_vreg;
88 static int buspirate_pullup;
89 static char *buspirate_port;
90
91 /* TAP interface */
92 static void buspirate_tap_init(void);
93 static int buspirate_tap_execute(void);
94 static void buspirate_tap_append(int tms, int tdi);
95 static void buspirate_tap_append_scan(int length, uint8_t *buffer,
96 struct scan_command *command);
97 static void buspirate_tap_make_space(int scan, int bits);
98
99 static void buspirate_reset(int trst, int srst);
100
101 /* low level interface */
102 static void buspirate_jtag_reset(int);
103 static void buspirate_jtag_enable(int);
104 static unsigned char buspirate_jtag_command(int, char *, int);
105 static void buspirate_jtag_set_speed(int, char);
106 static void buspirate_jtag_set_mode(int, char);
107 static void buspirate_jtag_set_feature(int, char, char);
108 static void buspirate_jtag_get_adcs(int);
109
110 /* low level HW communication interface */
111 static int buspirate_serial_open(char *port);
112 static int buspirate_serial_setspeed(int fd, char speed);
113 static int buspirate_serial_write(int fd, char *buf, int size);
114 static int buspirate_serial_read(int fd, char *buf, int size);
115 static void buspirate_serial_close(int fd);
116 static void buspirate_print_buffer(char *buf, int size);
117
118 static int buspirate_execute_queue(void)
119 {
120 /* currently processed command */
121 struct jtag_command *cmd = jtag_command_queue;
122 int scan_size;
123 enum scan_type type;
124 uint8_t *buffer;
125
126 while (cmd) {
127 switch (cmd->type) {
128 case JTAG_RUNTEST:
129 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
130 cmd->cmd.runtest->num_cycles,
131 tap_state_name(cmd->cmd.runtest
132 ->end_state));
133 buspirate_end_state(cmd->cmd.runtest
134 ->end_state);
135 buspirate_runtest(cmd->cmd.runtest
136 ->num_cycles);
137 break;
138 case JTAG_TLR_RESET:
139 DEBUG_JTAG_IO("statemove end in %s",
140 tap_state_name(cmd->cmd.statemove
141 ->end_state));
142 buspirate_end_state(cmd->cmd.statemove
143 ->end_state);
144 buspirate_state_move();
145 break;
146 case JTAG_PATHMOVE:
147 DEBUG_JTAG_IO("pathmove: %i states, end in %s",
148 cmd->cmd.pathmove->num_states,
149 tap_state_name(cmd->cmd.pathmove
150 ->path[cmd->cmd.pathmove
151 ->num_states - 1]));
152 buspirate_path_move(cmd->cmd.pathmove
153 ->num_states,
154 cmd->cmd.pathmove->path);
155 break;
156 case JTAG_SCAN:
157 DEBUG_JTAG_IO("scan end in %s",
158 tap_state_name(cmd->cmd.scan
159 ->end_state));
160
161 buspirate_end_state(cmd->cmd.scan
162 ->end_state);
163
164 scan_size = jtag_build_buffer(cmd->cmd.scan,
165 &buffer);
166 type = jtag_scan_type(cmd->cmd.scan);
167 buspirate_scan(cmd->cmd.scan->ir_scan, type,
168 buffer, scan_size, cmd->cmd.scan);
169
170 break;
171 case JTAG_RESET:
172 DEBUG_JTAG_IO("reset trst: %i srst %i",
173 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
174
175 /* flush buffers, so we can reset */
176 buspirate_tap_execute();
177
178 if (cmd->cmd.reset->trst == 1)
179 tap_set_state(TAP_RESET);
180 buspirate_reset(cmd->cmd.reset->trst,
181 cmd->cmd.reset->srst);
182 break;
183 case JTAG_SLEEP:
184 DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
185 buspirate_tap_execute();
186 jtag_sleep(cmd->cmd.sleep->us);
187 break;
188 default:
189 LOG_ERROR("BUG: unknown JTAG command type encountered");
190 exit(-1);
191 }
192
193 cmd = cmd->next;
194 }
195
196 return buspirate_tap_execute();
197 }
198
199 static int buspirate_init(void)
200 {
201 if (buspirate_port == NULL) {
202 LOG_ERROR("You need to specify the serial port!");
203 return ERROR_JTAG_INIT_FAILED;
204 }
205
206 buspirate_fd = buspirate_serial_open(buspirate_port);
207 if (buspirate_fd == -1) {
208 LOG_ERROR("Could not open serial port");
209 return ERROR_JTAG_INIT_FAILED;
210 }
211
212 buspirate_serial_setspeed(buspirate_fd, SERIAL_NORMAL);
213
214 buspirate_jtag_enable(buspirate_fd);
215
216 if (buspirate_baudrate != SERIAL_NORMAL)
217 buspirate_jtag_set_speed(buspirate_fd, SERIAL_FAST);
218
219 LOG_INFO("Buspirate Interface ready!");
220
221 buspirate_tap_init();
222 buspirate_jtag_set_mode(buspirate_fd, buspirate_pinmode);
223 buspirate_jtag_set_feature(buspirate_fd, FEATURE_VREG,
224 (buspirate_vreg == 1) ? ACTION_ENABLE : ACTION_DISABLE);
225 buspirate_jtag_set_feature(buspirate_fd, FEATURE_PULLUP,
226 (buspirate_pullup == 1) ? ACTION_ENABLE : ACTION_DISABLE);
227 buspirate_reset(0, 0);
228
229 return ERROR_OK;
230 }
231
232 static int buspirate_quit(void)
233 {
234 LOG_INFO("Shutting down buspirate.");
235 buspirate_jtag_set_mode(buspirate_fd, MODE_HIZ);
236
237 buspirate_jtag_set_speed(buspirate_fd, SERIAL_NORMAL);
238 buspirate_jtag_reset(buspirate_fd);
239
240 buspirate_serial_close(buspirate_fd);
241
242 if (buspirate_port) {
243 free(buspirate_port);
244 buspirate_port = NULL;
245 }
246 return ERROR_OK;
247 }
248
249 /* openocd command interface */
250 COMMAND_HANDLER(buspirate_handle_adc_command)
251 {
252 if (buspirate_fd == -1)
253 return ERROR_OK;
254
255 /* send the command */
256 buspirate_jtag_get_adcs(buspirate_fd);
257
258 return ERROR_OK;
259
260 }
261
262 COMMAND_HANDLER(buspirate_handle_vreg_command)
263 {
264 if (CMD_ARGC < 1)
265 return ERROR_COMMAND_SYNTAX_ERROR;
266
267 if (atoi(CMD_ARGV[0]) == 1)
268 buspirate_vreg = 1;
269 else if (atoi(CMD_ARGV[0]) == 0)
270 buspirate_vreg = 0;
271 else
272 LOG_ERROR("usage: buspirate_vreg <1|0>");
273
274 return ERROR_OK;
275
276 }
277
278 COMMAND_HANDLER(buspirate_handle_pullup_command)
279 {
280 if (CMD_ARGC < 1)
281 return ERROR_COMMAND_SYNTAX_ERROR;
282
283 if (atoi(CMD_ARGV[0]) == 1)
284 buspirate_pullup = 1;
285 else if (atoi(CMD_ARGV[0]) == 0)
286 buspirate_pullup = 0;
287 else
288 LOG_ERROR("usage: buspirate_pullup <1|0>");
289
290 return ERROR_OK;
291
292 }
293
294 COMMAND_HANDLER(buspirate_handle_led_command)
295 {
296 if (CMD_ARGC < 1)
297 return ERROR_COMMAND_SYNTAX_ERROR;
298
299 if (atoi(CMD_ARGV[0]) == 1) {
300 /* enable led */
301 buspirate_jtag_set_feature(buspirate_fd, FEATURE_LED,
302 ACTION_ENABLE);
303 } else if (atoi(CMD_ARGV[0]) == 0) {
304 /* disable led */
305 buspirate_jtag_set_feature(buspirate_fd, FEATURE_LED,
306 ACTION_DISABLE);
307 } else {
308 LOG_ERROR("usage: buspirate_led <1|0>");
309 }
310
311 return ERROR_OK;
312
313 }
314
315 COMMAND_HANDLER(buspirate_handle_mode_command)
316 {
317 if (CMD_ARGC < 1)
318 return ERROR_COMMAND_SYNTAX_ERROR;
319
320 if (CMD_ARGV[0][0] == 'n')
321 buspirate_pinmode = MODE_JTAG;
322 else if (CMD_ARGV[0][0] == 'o')
323 buspirate_pinmode = MODE_JTAG_OD;
324 else
325 LOG_ERROR("usage: buspirate_mode <normal|open-drain>");
326
327 return ERROR_OK;
328
329 }
330
331 COMMAND_HANDLER(buspirate_handle_speed_command)
332 {
333 if (CMD_ARGC < 1)
334 return ERROR_COMMAND_SYNTAX_ERROR;
335
336 if (CMD_ARGV[0][0] == 'n')
337 buspirate_baudrate = SERIAL_NORMAL;
338 else if (CMD_ARGV[0][0] == 'f')
339 buspirate_baudrate = SERIAL_FAST;
340 else
341 LOG_ERROR("usage: buspirate_speed <normal|fast>");
342
343 return ERROR_OK;
344
345 }
346
347 COMMAND_HANDLER(buspirate_handle_port_command)
348 {
349 if (CMD_ARGC < 1)
350 return ERROR_COMMAND_SYNTAX_ERROR;
351
352 if (buspirate_port == NULL)
353 buspirate_port = strdup(CMD_ARGV[0]);
354
355 return ERROR_OK;
356
357 }
358
359 static const struct command_registration buspirate_command_handlers[] = {
360 {
361 .name = "buspirate_adc",
362 .handler = &buspirate_handle_adc_command,
363 .mode = COMMAND_EXEC,
364 .help = "reads voltages on adc pins",
365 },
366 {
367 .name = "buspirate_vreg",
368 .usage = "<1|0>",
369 .handler = &buspirate_handle_vreg_command,
370 .mode = COMMAND_CONFIG,
371 .help = "changes the state of voltage regulators",
372 },
373 {
374 .name = "buspirate_pullup",
375 .usage = "<1|0>",
376 .handler = &buspirate_handle_pullup_command,
377 .mode = COMMAND_CONFIG,
378 .help = "changes the state of pullup",
379 },
380 {
381 .name = "buspirate_led",
382 .usage = "<1|0>",
383 .handler = &buspirate_handle_led_command,
384 .mode = COMMAND_EXEC,
385 .help = "changes the state of led",
386 },
387 {
388 .name = "buspirate_speed",
389 .usage = "<normal|fast>",
390 .handler = &buspirate_handle_speed_command,
391 .mode = COMMAND_CONFIG,
392 .help = "speed of the interface",
393 },
394 {
395 .name = "buspirate_mode",
396 .usage = "<normal|open-drain>",
397 .handler = &buspirate_handle_mode_command,
398 .mode = COMMAND_CONFIG,
399 .help = "pin mode of the interface",
400 },
401 {
402 .name = "buspirate_port",
403 .usage = "/dev/ttyUSB0",
404 .handler = &buspirate_handle_port_command,
405 .mode = COMMAND_CONFIG,
406 .help = "name of the serial port to open",
407 },
408 COMMAND_REGISTRATION_DONE
409 };
410
411 struct jtag_interface buspirate_interface = {
412 .name = "buspirate",
413 .execute_queue = buspirate_execute_queue,
414 .commands = buspirate_command_handlers,
415 .init = buspirate_init,
416 .quit = buspirate_quit
417 };
418
419 /*************** jtag execute commands **********************/
420 static void buspirate_end_state(tap_state_t state)
421 {
422 if (tap_is_state_stable(state))
423 tap_set_end_state(state);
424 else {
425 LOG_ERROR("BUG: %i is not a valid end state", state);
426 exit(-1);
427 }
428 }
429
430 static void buspirate_state_move(void)
431 {
432 int i = 0, tms = 0;
433 uint8_t tms_scan = tap_get_tms_path(tap_get_state(),
434 tap_get_end_state());
435 int tms_count = tap_get_tms_path_len(tap_get_state(),
436 tap_get_end_state());
437
438 for (i = 0; i < tms_count; i++) {
439 tms = (tms_scan >> i) & 1;
440 buspirate_tap_append(tms, 0);
441 }
442
443 tap_set_state(tap_get_end_state());
444 }
445
446 static void buspirate_path_move(int num_states, tap_state_t *path)
447 {
448 int i;
449
450 for (i = 0; i < num_states; i++) {
451 if (tap_state_transition(tap_get_state(), false) == path[i]) {
452 buspirate_tap_append(0, 0);
453 } else if (tap_state_transition(tap_get_state(), true)
454 == path[i]) {
455 buspirate_tap_append(1, 0);
456 } else {
457 LOG_ERROR("BUG: %s -> %s isn't a valid "
458 "TAP transition",
459 tap_state_name(tap_get_state()),
460 tap_state_name(path[i]));
461 exit(-1);
462 }
463
464 tap_set_state(path[i]);
465 }
466
467 tap_set_end_state(tap_get_state());
468 }
469
470 static void buspirate_runtest(int num_cycles)
471 {
472 int i;
473
474 tap_state_t saved_end_state = tap_get_end_state();
475
476 /* only do a state_move when we're not already in IDLE */
477 if (tap_get_state() != TAP_IDLE) {
478 buspirate_end_state(TAP_IDLE);
479 buspirate_state_move();
480 }
481
482 for (i = 0; i < num_cycles; i++)
483 buspirate_tap_append(0, 0);
484
485 DEBUG_JTAG_IO("runtest: cur_state %s end_state %s",
486 tap_state_name(tap_get_state()),
487 tap_state_name(tap_get_end_state()));
488
489 /* finish in end_state */
490 buspirate_end_state(saved_end_state);
491 if (tap_get_state() != tap_get_end_state())
492 buspirate_state_move();
493 }
494
495 static void buspirate_scan(bool ir_scan, enum scan_type type,
496 uint8_t *buffer, int scan_size, struct scan_command *command)
497 {
498 tap_state_t saved_end_state;
499
500 buspirate_tap_make_space(1, scan_size+8);
501 /* is 8 correct ? (2 moves = 16) */
502
503 saved_end_state = tap_get_end_state();
504
505 buspirate_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
506
507 /* Only move if we're not already there */
508 if (tap_get_state() != tap_get_end_state())
509 buspirate_state_move();
510
511 buspirate_tap_append_scan(scan_size, buffer, command);
512
513 /* move to PAUSE */
514 buspirate_tap_append(0, 0);
515
516 /* restore the saved state */
517 buspirate_end_state(saved_end_state);
518 tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
519
520 if (tap_get_state() != tap_get_end_state())
521 buspirate_state_move();
522 }
523
524
525 /************************* TAP related stuff **********/
526
527 #define BUSPIRATE_BUFFER_SIZE 1024
528 #define BUSPIRATE_MAX_PENDING_SCANS 32
529
530 static char tms_chain[BUSPIRATE_BUFFER_SIZE]; /* send */
531 static char tdi_chain[BUSPIRATE_BUFFER_SIZE]; /* send */
532 static int tap_chain_index;
533
534 struct pending_scan_result /* this was stolen from arm-jtag-ew */
535 {
536 int first; /* First bit position in tdo_buffer to read */
537 int length; /* Number of bits to read */
538 struct scan_command *command; /* Corresponding scan command */
539 uint8_t *buffer;
540 };
541
542 static struct pending_scan_result
543 tap_pending_scans[BUSPIRATE_MAX_PENDING_SCANS];
544 static int tap_pending_scans_num;
545
546 static void buspirate_tap_init(void)
547 {
548 tap_chain_index = 0;
549 tap_pending_scans_num = 0;
550 }
551
552 static int buspirate_tap_execute(void)
553 {
554 char tmp[4096];
555 uint8_t *in_buf;
556 int i;
557 int fill_index = 0;
558 int ret;
559 int bytes_to_send;
560
561 if (tap_chain_index <= 0)
562 return ERROR_OK;
563
564 LOG_DEBUG("executing tap num bits = %i scans = %i",
565 tap_chain_index, tap_pending_scans_num);
566
567 bytes_to_send = (tap_chain_index+7) / 8;
568
569 tmp[0] = CMD_TAP_SHIFT; /* this command expects number of bits */
570 tmp[1] = (char)(tap_chain_index >> 8); /* high */
571 tmp[2] = (char)(tap_chain_index); /* low */
572
573 fill_index = 3;
574 for (i = 0; i < bytes_to_send; i++) {
575 tmp[fill_index] = tdi_chain[i];
576 fill_index++;
577 tmp[fill_index] = tms_chain[i];
578 fill_index++;
579 }
580
581 ret = buspirate_serial_write(buspirate_fd, tmp, 3 + bytes_to_send*2);
582 if (ret != bytes_to_send*2+3) {
583 LOG_ERROR("error writing :(");
584 return ERROR_JTAG_DEVICE_ERROR;
585 }
586
587 ret = buspirate_serial_read(buspirate_fd, tmp, bytes_to_send + 3);
588 if (ret != bytes_to_send + 3) {
589 LOG_ERROR("error reading");
590 return ERROR_FAIL;
591 }
592 in_buf = (uint8_t *)(&tmp[3]);
593
594 /* parse the scans */
595 for (i = 0; i < tap_pending_scans_num; i++) {
596 uint8_t *buffer = tap_pending_scans[i].buffer;
597 int length = tap_pending_scans[i].length;
598 int first = tap_pending_scans[i].first;
599 struct scan_command *command = tap_pending_scans[i].command;
600
601 /* copy bits from buffer */
602 buf_set_buf(in_buf, first, buffer, 0, length);
603
604 /* return buffer to higher level */
605 if (jtag_read_buffer(buffer, command) != ERROR_OK) {
606 buspirate_tap_init();
607 return ERROR_JTAG_QUEUE_FAILED;
608 }
609
610 free(buffer);
611 }
612 tap_pending_scans_num = 0;
613 tap_chain_index = 0;
614 return ERROR_OK;
615 }
616
617 static void buspirate_tap_make_space(int scans, int bits)
618 {
619 int have_scans = BUSPIRATE_MAX_PENDING_SCANS - tap_pending_scans_num;
620 int have_bits = BUSPIRATE_BUFFER_SIZE * 8 - tap_chain_index;
621
622 if ((have_scans < scans) || (have_bits < bits))
623 buspirate_tap_execute();
624 }
625
626 static void buspirate_tap_append(int tms, int tdi)
627 {
628 int chain_index;
629
630 buspirate_tap_make_space(0, 1);
631 chain_index = tap_chain_index / 8;
632
633 if (chain_index < BUSPIRATE_BUFFER_SIZE) {
634 int bit_index = tap_chain_index % 8;
635 uint8_t bit = 1 << bit_index;
636
637 if (tms)
638 tms_chain[chain_index] |= bit;
639 else
640 tms_chain[chain_index] &= ~bit;
641
642 if (tdi)
643 tdi_chain[chain_index] |= bit;
644 else
645 tdi_chain[chain_index] &= ~bit;
646
647 tap_chain_index++;
648 } else
649 LOG_ERROR("tap_chain overflow, bad things will happen");
650
651 }
652
653 static void buspirate_tap_append_scan(int length, uint8_t *buffer,
654 struct scan_command *command)
655 {
656 int i;
657 tap_pending_scans[tap_pending_scans_num].length = length;
658 tap_pending_scans[tap_pending_scans_num].buffer = buffer;
659 tap_pending_scans[tap_pending_scans_num].command = command;
660 tap_pending_scans[tap_pending_scans_num].first = tap_chain_index;
661
662 for (i = 0; i < length; i++) {
663 int tms = (i < length-1 ? 0 : 1);
664 int tdi = (buffer[i/8] >> (i%8)) & 1;
665 buspirate_tap_append(tms, tdi);
666 }
667 tap_pending_scans_num++;
668 }
669
670 /*************** jtag wrapper functions *********************/
671
672 /* (1) assert or (0) deassert reset lines */
673 static void buspirate_reset(int trst, int srst)
674 {
675 LOG_DEBUG("trst: %i, srst: %i", trst, srst);
676
677 if (trst)
678 buspirate_jtag_set_feature(buspirate_fd,
679 FEATURE_TRST, ACTION_DISABLE);
680 else
681 buspirate_jtag_set_feature(buspirate_fd,
682 FEATURE_TRST, ACTION_ENABLE);
683
684 if (srst)
685 buspirate_jtag_set_feature(buspirate_fd,
686 FEATURE_SRST, ACTION_DISABLE);
687 else
688 buspirate_jtag_set_feature(buspirate_fd,
689 FEATURE_SRST, ACTION_ENABLE);
690 }
691
692 /*************** jtag lowlevel functions ********************/
693 static void buspirate_jtag_enable(int fd)
694 {
695 int ret;
696 char tmp[21] = { [0 ... 20] = 0x00 };
697 int done = 0;
698 int cmd_sent = 0;
699
700 LOG_DEBUG("Entering binary mode");
701 buspirate_serial_write(fd, tmp, 20);
702 usleep(10000);
703
704 /* reads 1 to n "BBIO1"s and one "OCD1" */
705 while (!done) {
706 ret = buspirate_serial_read(fd, tmp, 4);
707 if (ret != 4) {
708 LOG_ERROR("Buspirate error. Is binary"
709 "/OpenOCD support enabled?");
710 exit(-1);
711 }
712 if (strncmp(tmp, "BBIO", 4) == 0) {
713 ret = buspirate_serial_read(fd, tmp, 1);
714 if (ret != 1) {
715 LOG_ERROR("Buspirate did not answer correctly! "
716 "Do you have correct firmware?");
717 exit(-1);
718 }
719 if (tmp[0] != '1') {
720 LOG_ERROR("Unsupported binary protocol");
721 exit(-1);
722 }
723 if (cmd_sent == 0) {
724 cmd_sent = 1;
725 tmp[0] = CMD_ENTER_OOCD;
726 ret = buspirate_serial_write(fd, tmp, 1);
727 if (ret != 1) {
728 LOG_ERROR("error reading");
729 exit(-1);
730 }
731 }
732 } else if (strncmp(tmp, "OCD1", 4) == 0)
733 done = 1;
734 else {
735 LOG_ERROR("Buspirate did not answer correctly! "
736 "Do you have correct firmware?");
737 exit(-1);
738 }
739 }
740
741 }
742
743 static void buspirate_jtag_reset(int fd)
744 {
745 char tmp[5];
746
747 tmp[0] = 0x00; /* exit OCD1 mode */
748 buspirate_serial_write(fd, tmp, 1);
749 usleep(10000);
750 /* We ignore the return value here purposly, nothing we can do */
751 buspirate_serial_read(fd, tmp, 5);
752 if (strncmp(tmp, "BBIO1", 5) == 0) {
753 tmp[0] = 0x0F; /* reset BP */
754 buspirate_serial_write(fd, tmp, 1);
755 } else
756 LOG_ERROR("Unable to restart buspirate!");
757 }
758
759 static void buspirate_jtag_set_speed(int fd, char speed)
760 {
761 int ret;
762 char tmp[2];
763 char ack[2];
764
765 ack[0] = 0xAA;
766 ack[1] = 0x55;
767
768 tmp[0] = CMD_UART_SPEED;
769 tmp[1] = speed;
770 buspirate_jtag_command(fd, tmp, 2);
771
772 /* here the adapter changes speed, we need follow */
773 buspirate_serial_setspeed(fd, speed);
774
775 buspirate_serial_write(fd, ack, 2);
776 ret = buspirate_serial_read(fd, tmp, 2);
777 if (ret != 2) {
778 LOG_ERROR("Buspirate did not ack speed change");
779 exit(-1);
780 }
781 if ((tmp[0] != CMD_UART_SPEED) || (tmp[1] != speed)) {
782 LOG_ERROR("Buspirate did not reply as expected");
783 exit(-1);
784 }
785 LOG_INFO("Buspirate switched to %s mode",
786 (speed == SERIAL_NORMAL) ? "normal" : "FAST");
787 }
788
789
790 static void buspirate_jtag_set_mode(int fd, char mode)
791 {
792 char tmp[2];
793 tmp[0] = CMD_PORT_MODE;
794 tmp[1] = mode;
795 buspirate_jtag_command(fd, tmp, 2);
796 }
797
798 static void buspirate_jtag_set_feature(int fd, char feat, char action)
799 {
800 char tmp[3];
801 tmp[0] = CMD_FEATURE;
802 tmp[1] = feat; /* what */
803 tmp[2] = action; /* action */
804 buspirate_jtag_command(fd, tmp, 3);
805 }
806
807 static void buspirate_jtag_get_adcs(int fd)
808 {
809 uint8_t tmp[10];
810 uint16_t a, b, c, d;
811 tmp[0] = CMD_READ_ADCS;
812 buspirate_jtag_command(fd, (char *)tmp, 1);
813 a = tmp[2] << 8 | tmp[3];
814 b = tmp[4] << 8 | tmp[5];
815 c = tmp[6] << 8 | tmp[7];
816 d = tmp[8] << 8 | tmp[9];
817
818 LOG_INFO("ADC: ADC_Pin = %.02f VPullup = %.02f V33 = %.02f "
819 "V50 = %.02f",
820 ((float)a)/155.1515, ((float)b)/155.1515,
821 ((float)c)/155.1515, ((float)d)/155.1515);
822 }
823
824 static unsigned char buspirate_jtag_command(int fd,
825 char *cmd, int cmdlen)
826 {
827 int res;
828 int len = 0;
829
830 res = buspirate_serial_write(fd, cmd, cmdlen);
831
832 if ((cmd[0] == CMD_UART_SPEED)
833 || (cmd[0] == CMD_PORT_MODE)
834 || (cmd[0] == CMD_FEATURE)
835 || (cmd[0] == CMD_JTAG_SPEED))
836 return 1;
837
838 if (res == cmdlen) {
839 switch (cmd[0]) {
840 case CMD_READ_ADCS:
841 len = 10; /* 2*sizeof(char)+4*sizeof(uint16_t) */
842 break;
843 case CMD_TAP_SHIFT:
844 len = cmdlen;
845 break;
846 default:
847 LOG_INFO("Wrong !");
848 }
849 res = buspirate_serial_read(fd, cmd, len);
850 if (res > 0)
851 return (unsigned char)cmd[1];
852 else
853 return -1;
854 } else
855 return -1;
856 return 0;
857 }
858
859 /* low level serial port */
860 /* TODO add support for WIN32 and others ! */
861 static int buspirate_serial_open(char *port)
862 {
863 int fd;
864 fd = open(buspirate_port, O_RDWR | O_NOCTTY | O_NDELAY);
865 return fd;
866 }
867
868 static int buspirate_serial_setspeed(int fd, char speed)
869 {
870 struct termios t_opt;
871 speed_t baud = (speed == SERIAL_FAST) ? B1000000 : B115200;
872
873 /* set the serial port parameters */
874 fcntl(fd, F_SETFL, 0);
875 tcgetattr(fd, &t_opt);
876 cfsetispeed(&t_opt, baud);
877 cfsetospeed(&t_opt, baud);
878 t_opt.c_cflag |= (CLOCAL | CREAD);
879 t_opt.c_cflag &= ~PARENB;
880 t_opt.c_cflag &= ~CSTOPB;
881 t_opt.c_cflag &= ~CSIZE;
882 t_opt.c_cflag |= CS8;
883 t_opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
884 t_opt.c_iflag &= ~(IXON | IXOFF | IXANY);
885 t_opt.c_oflag &= ~OPOST;
886 t_opt.c_cc[VMIN] = 0;
887 t_opt.c_cc[VTIME] = 10;
888 tcflush(fd, TCIFLUSH);
889 tcsetattr(fd, TCSANOW, &t_opt);
890
891 return 0;
892 }
893
894 static int buspirate_serial_write(int fd, char *buf, int size)
895 {
896 int ret = 0;
897
898 ret = write(fd, buf, size);
899
900 LOG_DEBUG("size = %d ret = %d", size, ret);
901 buspirate_print_buffer(buf, size);
902
903 if (ret != size)
904 LOG_ERROR("Error sending data");
905
906 return ret;
907 }
908
909 static int buspirate_serial_read(int fd, char *buf, int size)
910 {
911 int len = 0;
912 int ret = 0;
913 int timeout = 0;
914
915 while (len < size) {
916 ret = read(fd, buf+len, size-len);
917 if (ret == -1)
918 return -1;
919
920 if (ret == 0) {
921 timeout++;
922
923 if (timeout >= 10)
924 break;
925
926 continue;
927 }
928
929 len += ret;
930 }
931
932 LOG_DEBUG("should have read = %d actual size = %d", size, len);
933 buspirate_print_buffer(buf, len);
934
935 if (len != size)
936 LOG_ERROR("Error reading data");
937
938 return len;
939 }
940
941 static void buspirate_serial_close(int fd)
942 {
943 close(fd);
944 }
945
946 #define LINE_SIZE 81
947 #define BYTES_PER_LINE 16
948 static void buspirate_print_buffer(char *buf, int size)
949 {
950 char line[LINE_SIZE];
951 char tmp[10];
952 int offset = 0;
953
954 line[0] = 0;
955 while (offset < size) {
956 snprintf(tmp, 5, "%02x ", (uint8_t)buf[offset]);
957 offset++;
958
959 strcat(line, tmp);
960
961 if (offset % BYTES_PER_LINE == 0) {
962 LOG_DEBUG("%s", line);
963 line[0] = 0;
964 }
965 }
966
967 if (line[0] != 0)
968 LOG_DEBUG("%s", line);
969 }