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