?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
hla: move memory read/write functionality to driver
[openocd.git] / src / jtag / drivers / ti_icdi_usb.c
blob0d7d943bede0ed04734930860b4c3bb152d34b68
1 /***************************************************************************
2 * *
3 * Copyright (C) 2012 by Spencer Oliver *
4 * spen@spen-soft.co.uk *
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, write to the *
18 * Free Software Foundation, Inc., *
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
20 ***************************************************************************/
21
22 #ifdef HAVE_CONFIG_H
23 #include "config.h"
24 #endif
25
26 /* project specific includes */
27 #include <helper/binarybuffer.h>
28 #include <jtag/interface.h>
29 #include <jtag/hla/hla_layout.h>
30 #include <jtag/hla/hla_transport.h>
31 #include <jtag/hla/hla_interface.h>
32 #include <target/target.h>
33
34 #include <target/cortex_m.h>
35
36 #include <libusb.h>
37
38 #define ICDI_WRITE_ENDPOINT 0x02
39 #define ICDI_READ_ENDPOINT 0x83
40
41 #define ICDI_WRITE_TIMEOUT 1000
42 #define ICDI_READ_TIMEOUT 1000
43 #define ICDI_PACKET_SIZE 2048
44
45 #define PACKET_START "$"
46 #define PACKET_END "#"
47
48 struct icdi_usb_handle_s {
49 libusb_context *usb_ctx;
50 libusb_device_handle *usb_dev;
51
52 char *read_buffer;
53 char *write_buffer;
54 int max_packet;
55 int read_count;
56 uint32_t max_rw_packet; /* max X packet (read/write memory) transfers */
57 };
58
59 static int icdi_usb_read_mem(void *handle, uint32_t addr, uint32_t size,
60 uint32_t count, uint8_t *buffer);
61 static int icdi_usb_write_mem(void *handle, uint32_t addr, uint32_t size,
62 uint32_t count, const uint8_t *buffer);
63
64 static int remote_escape_output(const char *buffer, int len, char *out_buf, int *out_len, int out_maxlen)
65 {
66 int input_index, output_index;
67
68 output_index = 0;
69
70 for (input_index = 0; input_index < len; input_index++) {
71
72 char b = buffer[input_index];
73
74 if (b == '$' || b == '#' || b == '}' || b == '*') {
75 /* These must be escaped. */
76 if (output_index + 2 > out_maxlen)
77 break;
78 out_buf[output_index++] = '}';
79 out_buf[output_index++] = b ^ 0x20;
80 } else {
81 if (output_index + 1 > out_maxlen)
82 break;
83 out_buf[output_index++] = b;
84 }
85 }
86
87 *out_len = input_index;
88 return output_index;
89 }
90
91 static int remote_unescape_input(const char *buffer, int len, char *out_buf, int out_maxlen)
92 {
93 int input_index, output_index;
94 int escaped;
95
96 output_index = 0;
97 escaped = 0;
98
99 for (input_index = 0; input_index < len; input_index++) {
100
101 char b = buffer[input_index];
102
103 if (output_index + 1 > out_maxlen)
104 LOG_ERROR("Received too much data from the target.");
105
106 if (escaped) {
107 out_buf[output_index++] = b ^ 0x20;
108 escaped = 0;
109 } else if (b == '}')
110 escaped = 1;
111 else
112 out_buf[output_index++] = b;
113 }
114
115 if (escaped)
116 LOG_ERROR("Unmatched escape character in target response.");
117
118 return output_index;
119 }
120
121 static int icdi_send_packet(void *handle, int len)
122 {
123 unsigned char cksum = 0;
124 struct icdi_usb_handle_s *h;
125 int result, retry = 0;
126 int transferred = 0;
127
128 assert(handle != NULL);
129 h = (struct icdi_usb_handle_s *)handle;
130
131 /* check we have a large enough buffer for checksum "#00" */
132 if (len + 3 > h->max_packet) {
133 LOG_ERROR("packet buffer too small");
134 return ERROR_FAIL;
135 }
136
137 /* calculate checksum - offset start of packet */
138 for (int i = 1; i < len; i++)
139 cksum += h->write_buffer[i];
140
141 len += sprintf(&h->write_buffer[len], PACKET_END "%02x", cksum);
142
143 #ifdef _DEBUG_USB_COMMS_
144 char buffer[50];
145 char ch = h->write_buffer[1];
146 if (ch == 'x' || ch == 'X')
147 LOG_DEBUG("writing packet: <binary>");
148 else {
149 memcpy(buffer, h->write_buffer, len >= 50 ? 50-1 : len);
150 buffer[len] = 0;
151 LOG_DEBUG("writing packet: %s", buffer);
152 }
153 #endif
154
155 while (1) {
156
157 result = libusb_bulk_transfer(h->usb_dev, ICDI_WRITE_ENDPOINT, (unsigned char *)h->write_buffer, len,
158 &transferred, ICDI_WRITE_TIMEOUT);
159 if (result != 0 || transferred != len) {
160 LOG_DEBUG("Error TX Data %d", result);
161 return ERROR_FAIL;
162 }
163
164 /* check that the client got the message ok, or shall we resend */
165 result = libusb_bulk_transfer(h->usb_dev, ICDI_READ_ENDPOINT, (unsigned char *)h->read_buffer, h->max_packet,
166 &transferred, ICDI_READ_TIMEOUT);
167 if (result != 0 || transferred < 1) {
168 LOG_DEBUG("Error RX Data %d", result);
169 return ERROR_FAIL;
170 }
171
172 #ifdef _DEBUG_USB_COMMS_
173 LOG_DEBUG("received reply: '%c' : count %d", h->read_buffer[0], transferred);
174 #endif
175
176 if (h->read_buffer[0] == '-') {
177 LOG_DEBUG("Resending packet %d", ++retry);
178 } else {
179 if (h->read_buffer[0] != '+')
180 LOG_DEBUG("Unexpected Reply from ICDI: %c", h->read_buffer[0]);
181 break;
182 }
183
184 if (retry == 3) {
185 LOG_DEBUG("maximum nack retries attempted");
186 return ERROR_FAIL;
187 }
188 }
189
190 retry = 0;
191 h->read_count = transferred;
192
193 while (1) {
194
195 /* read reply from icdi */
196 result = libusb_bulk_transfer(h->usb_dev, ICDI_READ_ENDPOINT, (unsigned char *)h->read_buffer + h->read_count,
197 h->max_packet - h->read_count, &transferred, ICDI_READ_TIMEOUT);
198
199 #ifdef _DEBUG_USB_COMMS_
200 LOG_DEBUG("received data: count %d", transferred);
201 #endif
202
203 /* check for errors but retry for timeout */
204 if (result != 0) {
205
206 if (result == LIBUSB_ERROR_TIMEOUT) {
207 LOG_DEBUG("Error RX timeout %d", result);
208 } else {
209 LOG_DEBUG("Error RX Data %d", result);
210 return ERROR_FAIL;
211 }
212 }
213
214 h->read_count += transferred;
215
216 /* we need to make sure we have a full packet, including checksum */
217 if (h->read_count > 5) {
218
219 /* check that we have received an packet delimiter
220 * we do not validate the checksum
221 * reply should contain $...#AA - so we check for # */
222 if (h->read_buffer[h->read_count - 3] == '#')
223 return ERROR_OK;
224 }
225
226 if (retry++ == 3) {
227 LOG_DEBUG("maximum data retries attempted");
228 break;
229 }
230 }
231
232 return ERROR_FAIL;
233 }
234
235 static int icdi_send_cmd(void *handle, const char *cmd)
236 {
237 struct icdi_usb_handle_s *h;
238 h = (struct icdi_usb_handle_s *)handle;
239
240 int cmd_len = snprintf(h->write_buffer, h->max_packet, PACKET_START "%s", cmd);
241 return icdi_send_packet(handle, cmd_len);
242 }
243
244 static int icdi_send_remote_cmd(void *handle, const char *data)
245 {
246 struct icdi_usb_handle_s *h;
247 h = (struct icdi_usb_handle_s *)handle;
248
249 size_t cmd_len = sprintf(h->write_buffer, PACKET_START "qRcmd,");
250 cmd_len += hexify(h->write_buffer + cmd_len, data, 0, h->max_packet - cmd_len);
251
252 return icdi_send_packet(handle, cmd_len);
253 }
254
255 static int icdi_get_cmd_result(void *handle)
256 {
257 struct icdi_usb_handle_s *h;
258 int offset = 0;
259 char ch;
260
261 assert(handle != NULL);
262 h = (struct icdi_usb_handle_s *)handle;
263
264 do {
265 ch = h->read_buffer[offset++];
266 if (offset > h->read_count)
267 return ERROR_FAIL;
268 } while (ch != '$');
269
270 if (memcmp("OK", h->read_buffer + offset, 2) == 0)
271 return ERROR_OK;
272
273 if (h->read_buffer[offset] == 'E') {
274 /* get error code */
275 char result;
276 if (unhexify(&result, h->read_buffer + offset + 1, 1) != 1)
277 return ERROR_FAIL;
278 return result;
279 }
280
281 /* for now we assume everything else is ok */
282 return ERROR_OK;
283 }
284
285 static int icdi_usb_idcode(void *handle, uint32_t *idcode)
286 {
287 return ERROR_OK;
288 }
289
290 static int icdi_usb_write_debug_reg(void *handle, uint32_t addr, uint32_t val)
291 {
292 return icdi_usb_write_mem(handle, addr, 4, 1, (uint8_t *)&val);
293 }
294
295 static enum target_state icdi_usb_state(void *handle)
296 {
297 int result;
298 struct icdi_usb_handle_s *h;
299 uint32_t dhcsr;
300
301 h = (struct icdi_usb_handle_s *)handle;
302
303 result = icdi_usb_read_mem(h, DCB_DHCSR, 4, 1, (uint8_t *)&dhcsr);
304 if (result != ERROR_OK)
305 return TARGET_UNKNOWN;
306
307 if (dhcsr & S_HALT)
308 return TARGET_HALTED;
309
310 return TARGET_RUNNING;
311 }
312
313 static int icdi_usb_version(void *handle)
314 {
315 struct icdi_usb_handle_s *h;
316 h = (struct icdi_usb_handle_s *)handle;
317
318 char version[20];
319
320 /* get info about icdi */
321 int result = icdi_send_remote_cmd(handle, "version");
322 if (result != ERROR_OK)
323 return result;
324
325 if (h->read_count < 8) {
326 LOG_ERROR("Invalid Reply Received");
327 return ERROR_FAIL;
328 }
329
330 /* convert reply */
331 if (unhexify(version, h->read_buffer + 2, 4) != 4) {
332 LOG_WARNING("unable to get ICDI version");
333 return ERROR_OK;
334 }
335
336 /* null terminate and print info */
337 version[4] = 0;
338
339 LOG_INFO("ICDI Firmware version: %s", version);
340
341 return ERROR_OK;
342 }
343
344 static int icdi_usb_query(void *handle)
345 {
346 int result;
347
348 struct icdi_usb_handle_s *h;
349 h = (struct icdi_usb_handle_s *)handle;
350
351 result = icdi_send_cmd(handle, "qSupported");
352 if (result != ERROR_OK)
353 return result;
354
355 /* check result */
356 result = icdi_get_cmd_result(handle);
357 if (result != ERROR_OK) {
358 LOG_ERROR("query supported failed: 0x%x", result);
359 return ERROR_FAIL;
360 }
361
362 /* from this we can get the max packet supported */
363
364 /* query packet buffer size */
365 char *offset = strstr(h->read_buffer, "PacketSize");
366 if (offset) {
367 char *separator;
368 int max_packet;
369
370 max_packet = strtoul(offset + 11, &separator, 16);
371 if (!max_packet)
372 LOG_ERROR("invalid max packet, using defaults");
373 else
374 h->max_packet = max_packet;
375 LOG_DEBUG("max packet supported : %" PRIu32 " bytes", h->max_packet);
376 }
377
378
379 /* if required re allocate packet buffer */
380 if (h->max_packet != ICDI_PACKET_SIZE) {
381 h->read_buffer = realloc(h->read_buffer, h->max_packet);
382 h->write_buffer = realloc(h->write_buffer, h->max_packet);
383 if (h->read_buffer == 0 || h->write_buffer == 0) {
384 LOG_ERROR("unable to reallocate memory");
385 return ERROR_FAIL;
386 }
387 }
388
389 /* set extended mode */
390 result = icdi_send_cmd(handle, "!");
391 if (result != ERROR_OK)
392 return result;
393
394 /* check result */
395 result = icdi_get_cmd_result(handle);
396 if (result != ERROR_OK) {
397 LOG_ERROR("unable to enable extended mode: 0x%x", result);
398 return ERROR_FAIL;
399 }
400
401 return ERROR_OK;
402 }
403
404 static int icdi_usb_reset(void *handle)
405 {
406 /* we do this in hla_target.c */
407 return ERROR_OK;
408 }
409
410 static int icdi_usb_assert_srst(void *handle, int srst)
411 {
412 /* TODO not supported yet */
413 return ERROR_COMMAND_NOTFOUND;
414 }
415
416 static int icdi_usb_run(void *handle)
417 {
418 int result;
419
420 /* resume target at current address */
421 result = icdi_send_cmd(handle, "c");
422 if (result != ERROR_OK)
423 return result;
424
425 /* check result */
426 result = icdi_get_cmd_result(handle);
427 if (result != ERROR_OK) {
428 LOG_ERROR("continue failed: 0x%x", result);
429 return ERROR_FAIL;
430 }
431
432 return result;
433 }
434
435 static int icdi_usb_halt(void *handle)
436 {
437 int result;
438
439 /* this query halts the target ?? */
440 result = icdi_send_cmd(handle, "?");
441 if (result != ERROR_OK)
442 return result;
443
444 /* check result */
445 result = icdi_get_cmd_result(handle);
446 if (result != ERROR_OK) {
447 LOG_ERROR("halt failed: 0x%x", result);
448 return ERROR_FAIL;
449 }
450
451 return result;
452 }
453
454 static int icdi_usb_step(void *handle)
455 {
456 int result;
457
458 /* step target at current address */
459 result = icdi_send_cmd(handle, "s");
460 if (result != ERROR_OK)
461 return result;
462
463 /* check result */
464 result = icdi_get_cmd_result(handle);
465 if (result != ERROR_OK) {
466 LOG_ERROR("step failed: 0x%x", result);
467 return ERROR_FAIL;
468 }
469
470 return result;
471 }
472
473 static int icdi_usb_read_regs(void *handle)
474 {
475 /* currently unsupported */
476 return ERROR_OK;
477 }
478
479 static int icdi_usb_read_reg(void *handle, int num, uint32_t *val)
480 {
481 int result;
482 struct icdi_usb_handle_s *h;
483 char cmd[10];
484
485 h = (struct icdi_usb_handle_s *)handle;
486
487 snprintf(cmd, sizeof(cmd), "p%x", num);
488 result = icdi_send_cmd(handle, cmd);
489 if (result != ERROR_OK)
490 return result;
491
492 /* check result */
493 result = icdi_get_cmd_result(handle);
494 if (result != ERROR_OK) {
495 LOG_ERROR("register read failed: 0x%x", result);
496 return ERROR_FAIL;
497 }
498
499 /* convert result */
500 if (unhexify((char *)val, h->read_buffer + 2, 4) != 4) {
501 LOG_ERROR("failed to convert result");
502 return ERROR_FAIL;
503 }
504
505 return result;
506 }
507
508 static int icdi_usb_write_reg(void *handle, int num, uint32_t val)
509 {
510 int result;
511 char cmd[20];
512
513 int cmd_len = snprintf(cmd, sizeof(cmd), "P%x=", num);
514 hexify(cmd + cmd_len, (char *)&val, 4, sizeof(cmd));
515
516 result = icdi_send_cmd(handle, cmd);
517 if (result != ERROR_OK)
518 return result;
519
520 /* check result */
521 result = icdi_get_cmd_result(handle);
522 if (result != ERROR_OK) {
523 LOG_ERROR("register write failed: 0x%x", result);
524 return ERROR_FAIL;
525 }
526
527 return result;
528 }
529
530 static int icdi_usb_read_mem_int(void *handle, uint32_t addr, uint32_t len, uint8_t *buffer)
531 {
532 int result;
533 struct icdi_usb_handle_s *h;
534 char cmd[20];
535
536 h = (struct icdi_usb_handle_s *)handle;
537
538 snprintf(cmd, sizeof(cmd), "x%x,%x", addr, len);
539 result = icdi_send_cmd(handle, cmd);
540 if (result != ERROR_OK)
541 return result;
542
543 /* check result */
544 result = icdi_get_cmd_result(handle);
545 if (result != ERROR_OK) {
546 LOG_ERROR("memory read failed: 0x%x", result);
547 return ERROR_FAIL;
548 }
549
550 /* unescape input */
551 int read_len = remote_unescape_input(h->read_buffer + 5, h->read_count - 8, (char *)buffer, len);
552 if (read_len != (int)len) {
553 LOG_ERROR("read more bytes than expected: actual 0x%" PRIx32 " expected 0x%" PRIx32, read_len, len);
554 return ERROR_FAIL;
555 }
556
557 return ERROR_OK;
558 }
559
560 static int icdi_usb_write_mem_int(void *handle, uint32_t addr, uint32_t len, const uint8_t *buffer)
561 {
562 int result;
563 struct icdi_usb_handle_s *h;
564
565 h = (struct icdi_usb_handle_s *)handle;
566
567 size_t cmd_len = snprintf(h->write_buffer, h->max_packet, PACKET_START "X%x,%x:", addr, len);
568
569 int out_len;
570 cmd_len += remote_escape_output((char *)buffer, len, h->write_buffer + cmd_len,
571 &out_len, h->max_packet - cmd_len);
572
573 if (out_len < (int)len) {
574 /* for now issue a error as we have no way of allocating a larger buffer */
575 LOG_ERROR("memory buffer too small: requires 0x%" PRIx32 " actual 0x%" PRIx32, out_len, len);
576 return ERROR_FAIL;
577 }
578
579 result = icdi_send_packet(handle, cmd_len);
580 if (result != ERROR_OK)
581 return result;
582
583 /* check result */
584 result = icdi_get_cmd_result(handle);
585 if (result != ERROR_OK) {
586 LOG_ERROR("memory write failed: 0x%x", result);
587 return ERROR_FAIL;
588 }
589
590 return ERROR_OK;
591 }
592
593 static int icdi_usb_read_mem(void *handle, uint32_t addr, uint32_t size,
594 uint32_t count, uint8_t *buffer)
595 {
596 int retval = ERROR_OK;
597 struct icdi_usb_handle_s *h = (struct icdi_usb_handle_s *)handle;
598 uint32_t bytes_remaining;
599
600 /* calculate byte count */
601 count *= size;
602
603 while (count) {
604
605 bytes_remaining = h->max_rw_packet;
606 if (count < bytes_remaining)
607 bytes_remaining = count;
608
609 retval = icdi_usb_read_mem_int(handle, addr, bytes_remaining, buffer);
610 if (retval != ERROR_OK)
611 return retval;
612
613 buffer += bytes_remaining;
614 addr += bytes_remaining;
615 count -= bytes_remaining;
616 }
617
618 return retval;
619 }
620
621 static int icdi_usb_write_mem(void *handle, uint32_t addr, uint32_t size,
622 uint32_t count, const uint8_t *buffer)
623 {
624 int retval = ERROR_OK;
625 struct icdi_usb_handle_s *h = (struct icdi_usb_handle_s *)handle;
626 uint32_t bytes_remaining;
627
628 /* calculate byte count */
629 count *= size;
630
631 while (count) {
632
633 bytes_remaining = h->max_rw_packet;
634 if (count < bytes_remaining)
635 bytes_remaining = count;
636
637 retval = icdi_usb_write_mem_int(handle, addr, bytes_remaining, buffer);
638 if (retval != ERROR_OK)
639 return retval;
640
641 buffer += bytes_remaining;
642 addr += bytes_remaining;
643 count -= bytes_remaining;
644 }
645
646 return retval;
647 }
648
649 static int icdi_usb_close(void *handle)
650 {
651 struct icdi_usb_handle_s *h;
652
653 h = (struct icdi_usb_handle_s *)handle;
654
655 if (h->usb_dev)
656 libusb_close(h->usb_dev);
657
658 if (h->usb_ctx)
659 libusb_exit(h->usb_ctx);
660
661 if (h->read_buffer)
662 free(h->read_buffer);
663
664 if (h->write_buffer)
665 free(h->write_buffer);
666
667 free(handle);
668
669 return ERROR_OK;
670 }
671
672 static int icdi_usb_open(struct hl_interface_param_s *param, void **fd)
673 {
674 int retval;
675 struct icdi_usb_handle_s *h;
676
677 LOG_DEBUG("icdi_usb_open");
678
679 h = calloc(1, sizeof(struct icdi_usb_handle_s));
680
681 if (h == 0) {
682 LOG_ERROR("unable to allocate memory");
683 return ERROR_FAIL;
684 }
685
686 LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x", param->transport,
687 param->vid, param->pid);
688
689 if (libusb_init(&h->usb_ctx) != 0) {
690 LOG_ERROR("libusb init failed");
691 goto error_open;
692 }
693
694 h->usb_dev = libusb_open_device_with_vid_pid(h->usb_ctx, param->vid, param->pid);
695 if (!h->usb_dev) {
696 LOG_ERROR("open failed");
697 goto error_open;
698 }
699
700 if (libusb_claim_interface(h->usb_dev, 2)) {
701 LOG_DEBUG("claim interface failed");
702 goto error_open;
703 }
704
705 /* check if mode is supported */
706 retval = ERROR_OK;
707
708 switch (param->transport) {
709 #if 0
710 /* TODO place holder as swd is not currently supported */
711 case HL_TRANSPORT_SWD:
712 #endif
713 case HL_TRANSPORT_JTAG:
714 break;
715 default:
716 retval = ERROR_FAIL;
717 break;
718 }
719
720 if (retval != ERROR_OK) {
721 LOG_ERROR("mode (transport) not supported by device");
722 goto error_open;
723 }
724
725 /* allocate buffer */
726 h->read_buffer = malloc(ICDI_PACKET_SIZE);
727 h->write_buffer = malloc(ICDI_PACKET_SIZE);
728 h->max_packet = ICDI_PACKET_SIZE;
729
730 if (h->read_buffer == 0 || h->write_buffer == 0) {
731 LOG_DEBUG("malloc failed");
732 goto error_open;
733 }
734
735 /* query icdi version etc */
736 retval = icdi_usb_version(h);
737 if (retval != ERROR_OK)
738 goto error_open;
739
740 /* query icdi support */
741 retval = icdi_usb_query(h);
742 if (retval != ERROR_OK)
743 goto error_open;
744
745 *fd = h;
746
747 /* set the max target read/write buffer in bytes
748 * as we are using gdb binary packets to transfer memory we have to
749 * reserve half the buffer for any possible escape chars plus
750 * at least 64 bytes for the gdb packet header */
751 h->max_rw_packet = (((h->max_packet - 64) / 4) * 4) / 2;
752
753 return ERROR_OK;
754
755 error_open:
756 icdi_usb_close(h);
757
758 return ERROR_FAIL;
759 }
760
761 struct hl_layout_api_s icdi_usb_layout_api = {
762 .open = icdi_usb_open,
763 .close = icdi_usb_close,
764 .idcode = icdi_usb_idcode,
765 .state = icdi_usb_state,
766 .reset = icdi_usb_reset,
767 .assert_srst = icdi_usb_assert_srst,
768 .run = icdi_usb_run,
769 .halt = icdi_usb_halt,
770 .step = icdi_usb_step,
771 .read_regs = icdi_usb_read_regs,
772 .read_reg = icdi_usb_read_reg,
773 .write_reg = icdi_usb_write_reg,
774 .read_mem = icdi_usb_read_mem,
775 .write_mem = icdi_usb_write_mem,
776 .write_debug_reg = icdi_usb_write_debug_reg
777 };
Official OpenOCD Mirror