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