1 /***************************************************************************
2 * Copyright (C) 2011-2012 by Mathias Kuester *
3 * Mathias Kuester <kesmtp@freenet.de> *
5 * This code is based on https://github.com/texane/stlink *
7 * This program is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation; either version 2 of the License, or *
10 * (at your option) any later version. *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
17 * You should have received a copy of the GNU General Public License *
18 * along with this program; if not, write to the *
19 * Free Software Foundation, Inc., *
20 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
21 ***************************************************************************/
27 /* project specific includes */
28 #include <helper/binarybuffer.h>
29 #include <jtag/interface.h>
30 #include <jtag/stlink/stlink_layout.h>
31 #include <jtag/stlink/stlink_transport.h>
32 #include <jtag/stlink/stlink_interface.h>
33 #include <target/target.h>
35 #include "libusb_common.h"
37 #define ENDPOINT_IN 0x80
38 #define ENDPOINT_OUT 0x00
40 #define STLINK_RX_EP (1|ENDPOINT_IN)
41 #define STLINK_TX_EP (2|ENDPOINT_OUT)
42 #define STLINK_CMD_SIZE (16)
43 #define STLINK_TX_SIZE (4*128)
44 #define STLINK_RX_SIZE (4*128)
46 enum stlink_jtag_api_version {
47 STLINK_JTAG_API_V1 = 0,
52 struct stlink_usb_version {
59 /** highest supported jtag api version */
60 enum stlink_jtag_api_version jtag_api_max;
64 struct stlink_usb_handle_s {
66 struct jtag_libusb_device_handle *fd;
68 struct libusb_transfer *trans;
70 uint8_t txbuf[STLINK_TX_SIZE];
72 uint8_t rxbuf[STLINK_RX_SIZE];
74 enum stlink_transports transport;
76 struct stlink_usb_version version;
83 /** this is the currently used jtag api */
84 enum stlink_jtag_api_version jtag_api;
87 #define STLINK_DEBUG_ERR_OK 0x80
88 #define STLINK_DEBUG_ERR_FAULT 0x81
89 #define STLINK_CORE_RUNNING 0x80
90 #define STLINK_CORE_HALTED 0x81
91 #define STLINK_CORE_STAT_UNKNOWN -1
93 #define STLINK_GET_VERSION 0xF1
94 #define STLINK_DEBUG_COMMAND 0xF2
95 #define STLINK_DFU_COMMAND 0xF3
96 #define STLINK_SWIM_COMMAND 0xF4
97 #define STLINK_GET_CURRENT_MODE 0xF5
99 #define STLINK_DEV_DFU_MODE 0x00
100 #define STLINK_DEV_MASS_MODE 0x01
101 #define STLINK_DEV_DEBUG_MODE 0x02
102 #define STLINK_DEV_SWIM_MODE 0x03
103 #define STLINK_DEV_BOOTLOADER_MODE 0x04
104 #define STLINK_DEV_UNKNOWN_MODE -1
106 #define STLINK_DFU_EXIT 0x07
108 #define STLINK_SWIM_ENTER 0x00
109 #define STLINK_SWIM_EXIT 0x01
111 #define STLINK_DEBUG_ENTER_JTAG 0x00
112 #define STLINK_DEBUG_GETSTATUS 0x01
113 #define STLINK_DEBUG_FORCEDEBUG 0x02
114 #define STLINK_DEBUG_APIV1_RESETSYS 0x03
115 #define STLINK_DEBUG_APIV1_READALLREGS 0x04
116 #define STLINK_DEBUG_APIV1_READREG 0x05
117 #define STLINK_DEBUG_APIV1_WRITEREG 0x06
118 #define STLINK_DEBUG_READMEM_32BIT 0x07
119 #define STLINK_DEBUG_WRITEMEM_32BIT 0x08
120 #define STLINK_DEBUG_RUNCORE 0x09
121 #define STLINK_DEBUG_STEPCORE 0x0a
122 #define STLINK_DEBUG_APIV1_SETFP 0x0b
123 #define STLINK_DEBUG_READMEM_8BIT 0x0c
124 #define STLINK_DEBUG_WRITEMEM_8BIT 0x0d
125 #define STLINK_DEBUG_APIV1_CLEARFP 0x0e
126 #define STLINK_DEBUG_APIV1_WRITEDEBUGREG 0x0f
127 #define STLINK_DEBUG_APIV1_SETWATCHPOINT 0x10
129 #define STLINK_DEBUG_ENTER_JTAG 0x00
130 #define STLINK_DEBUG_ENTER_SWD 0xa3
132 #define STLINK_DEBUG_APIV1_ENTER 0x20
133 #define STLINK_DEBUG_EXIT 0x21
134 #define STLINK_DEBUG_READCOREID 0x22
136 #define STLINK_DEBUG_APIV2_ENTER 0x30
137 #define STLINK_DEBUG_APIV2_READ_IDCODES 0x31
138 #define STLINK_DEBUG_APIV2_RESETSYS 0x32
139 #define STLINK_DEBUG_APIV2_READREG 0x33
140 #define STLINK_DEBUG_APIV2_WRITEREG 0x34
142 #define STLINK_DEBUG_APIV2_READALLREGS 0x3A
144 #define STLINK_DEBUG_APIV2_DRIVE_NRST 0x3C
146 #define STLINK_DEBUG_APIV2_DRIVE_NRST_LOW 0x00
147 #define STLINK_DEBUG_APIV2_DRIVE_NRST_HIGH 0x01
148 #define STLINK_DEBUG_APIV2_DRIVE_NRST_PULSE 0x02
152 STLINK_MODE_UNKNOWN = 0,
155 STLINK_MODE_DEBUG_JTAG,
156 STLINK_MODE_DEBUG_SWD,
157 STLINK_MODE_DEBUG_SWIM
161 static void stlink_usb_recv_v1_create_cmd(char *b, int s, uint32_t tag, uint32_t rxsize,
162 uint8_t flag, uint8_t lun, uint8_t length)
168 /* fill the send buffer */
172 buf_set_u32(b+i, 0, 32, tag);
174 buf_set_u32(b+i, 0, 32, rxsize);
182 static int stlink_usb_recv_v1_mass_storage_cmd(void *handle, const uint8_t *txbuf, int txsize, uint8_t *rxbuf,
186 struct stlink_usb_handle_s *h;
188 assert(handle != NULL);
190 h = (struct stlink_usb_handle_s *)handle;
191 h->sg_tag = (h->sg_tag + 1) & 1;
193 stlink_usb_recv_v1_create_cmd(sg_buffer, 31, h->sg_tag, rxsize, STLINK_TX_EP, 0x00, txsize);
195 memcpy(sg_buffer+15, txbuf, 10);
197 if (jtag_libusb_bulk_write(h->fd, STLINK_TX_EP, (char *)sg_buffer, 31,
199 printf("send failed\n");
206 #define REQUEST_SENSE 0x03
207 #define REQUEST_SENSE_LENGTH 18
210 static int stlink_usb_recv_v1_get_status(void *handle, char *sg_buffer, int len)
212 struct stlink_usb_handle_s *h;
214 assert(handle != NULL);
216 h = (struct stlink_usb_handle_s *)handle;
219 memset(sg_buffer, 0x00, len);
221 if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)sg_buffer,
227 t1 = buf_get_u32(sg_buffer+0, 0, 32);
228 t2 = buf_get_u32(sg_buffer+4, 0, 32);
231 if (t1 != 0x53425355)
238 static int stlink_usb_recv_v1_get_sense(void *handle)
240 struct stlink_usb_handle_s *h;
244 assert(handle != NULL);
246 h = (struct stlink_usb_handle_s *)handle;
247 h->sg_tag = (h->sg_tag + 1) & 1;
249 cdb[0] = REQUEST_SENSE;
250 cdb[4] = REQUEST_SENSE_LENGTH;
252 stlink_usb_recv_v1_create_cmd(sg_buffer, 31, h->sg_tag, REQUEST_SENSE_LENGTH, STLINK_TX_EP,
255 memcpy(sg_buffer+15, cdb, 16);
257 if (jtag_libusb_bulk_write(h->fd, STLINK_TX_EP, (char *)sg_buffer, 16,
261 if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)cdb,
265 if (stlink_usb_recv_v1_get_status(handle, sg_buffer, 13) != ERROR_OK)
267 /* check for sense */
268 if (sg_buffer[12] != 0)
271 /* if (sense[0] != 0x70 && sense[0] != 0x71) */
277 static int stlink_usb_recv_v1(void *handle, const uint8_t *txbuf, int txsize, uint8_t *rxbuf,
282 struct stlink_usb_handle_s *h;
284 assert(handle != NULL);
286 h = (struct stlink_usb_handle_s *)handle;
288 err = stlink_usb_recv_v1_mass_storage_cmd(handle, txbuf, txsize, rxbuf, rxsize);
293 if (rxsize && rxbuf) {
294 if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)rxbuf,
295 rxsize, 1000) != rxsize) {
296 LOG_DEBUG("jtag_libusb_bulk_read");
301 if (stlink_usb_recv_v1_get_status(handle, sg_buffer, 13) != ERROR_OK)
303 /* check for sense */
304 if (sg_buffer[12] == 1) {
305 LOG_DEBUG("get sense");
306 err = stlink_usb_recv_v1_get_sense(handle);
312 static int stlink_usb_recv_v2(void *handle, const uint8_t *txbuf, int txsize, uint8_t *rxbuf,
315 struct stlink_usb_handle_s *h;
317 assert(handle != NULL);
319 h = (struct stlink_usb_handle_s *)handle;
321 if (jtag_libusb_bulk_write(h->fd, STLINK_TX_EP, (char *)txbuf, txsize,
325 if (rxsize && rxbuf) {
326 if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)rxbuf,
327 rxsize, 1000) != rxsize) {
335 static int stlink_usb_recv(void *handle, const uint8_t *txbuf, int txsize, uint8_t *rxbuf,
338 struct stlink_usb_handle_s *h;
340 assert(handle != NULL);
342 h = (struct stlink_usb_handle_s *)handle;
344 if (h->version.stlink == 1) {
345 return stlink_usb_recv_v1(handle, txbuf, txsize, rxbuf, rxsize);
347 if (txsize < STLINK_CMD_SIZE)
348 txsize = STLINK_CMD_SIZE;
349 return stlink_usb_recv_v2(handle, txbuf, txsize, rxbuf, rxsize);
354 static void stlink_usb_init_buffer(void *handle)
356 struct stlink_usb_handle_s *h;
358 assert(handle != NULL);
360 h = (struct stlink_usb_handle_s *)handle;
362 memset(h->txbuf, 0, STLINK_TX_SIZE);
363 memset(h->rxbuf, 0, STLINK_RX_SIZE);
366 static const char * const stlink_usb_error_msg[] = {
371 static int stlink_usb_error_check(void *handle)
374 const char *err_msg = 0;
375 struct stlink_usb_handle_s *h;
377 assert(handle != NULL);
379 h = (struct stlink_usb_handle_s *)handle;
381 /* TODO: no error checking yet on api V1 */
382 if (h->jtag_api == STLINK_JTAG_API_V1)
383 h->rxbuf[0] = STLINK_DEBUG_ERR_OK;
385 switch (h->rxbuf[0]) {
386 case STLINK_DEBUG_ERR_OK:
389 case STLINK_DEBUG_ERR_FAULT:
391 err_msg = stlink_usb_error_msg[0];
397 LOG_DEBUG("status error: %d ('%s')", h->rxbuf[0], err_msg);
403 static int stlink_usb_version(void *handle)
407 struct stlink_usb_handle_s *h;
409 assert(handle != NULL);
411 h = (struct stlink_usb_handle_s *)handle;
413 stlink_usb_init_buffer(handle);
415 h->txbuf[0] = STLINK_GET_VERSION;
417 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 6);
422 v = (h->rxbuf[0] << 8) | h->rxbuf[1];
424 h->version.stlink = (v >> 12) & 0x0f;
425 h->version.jtag = (v >> 6) & 0x3f;
426 h->version.swim = v & 0x3f;
427 h->vid = buf_get_u32(h->rxbuf, 16, 16);
428 h->pid = buf_get_u32(h->rxbuf, 32, 16);
430 /* set the supported jtag api version
431 * V1 doesn't support API V2 at all
432 * V2 support API V2 since JTAG V13
434 if ((h->version.stlink == 2) && (h->version.jtag > 12))
435 h->version.jtag_api_max = STLINK_JTAG_API_V2;
437 h->version.jtag_api_max = STLINK_JTAG_API_V1;
439 LOG_DEBUG("STLINK v%d JTAG v%d API v%d SWIM v%d VID %04X PID %04X",
442 (h->version.jtag_api_max == STLINK_JTAG_API_V1) ? 1 : 2,
451 static int stlink_usb_current_mode(void *handle, uint8_t *mode)
454 struct stlink_usb_handle_s *h;
456 assert(handle != NULL);
458 h = (struct stlink_usb_handle_s *)handle;
460 stlink_usb_init_buffer(handle);
462 h->txbuf[0] = STLINK_GET_CURRENT_MODE;
464 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
475 static int stlink_usb_mode_enter(void *handle, enum stlink_mode type)
479 struct stlink_usb_handle_s *h;
481 assert(handle != NULL);
483 h = (struct stlink_usb_handle_s *)handle;
485 stlink_usb_init_buffer(handle);
488 case STLINK_MODE_DEBUG_JTAG:
489 h->txbuf[0] = STLINK_DEBUG_COMMAND;
490 if (h->jtag_api == STLINK_JTAG_API_V1)
491 h->txbuf[1] = STLINK_DEBUG_APIV1_ENTER;
493 h->txbuf[1] = STLINK_DEBUG_APIV2_ENTER;
494 h->txbuf[2] = STLINK_DEBUG_ENTER_JTAG;
496 case STLINK_MODE_DEBUG_SWD:
497 h->txbuf[0] = STLINK_DEBUG_COMMAND;
498 if (h->jtag_api == STLINK_JTAG_API_V1)
499 h->txbuf[1] = STLINK_DEBUG_APIV1_ENTER;
501 h->txbuf[1] = STLINK_DEBUG_APIV2_ENTER;
502 h->txbuf[2] = STLINK_DEBUG_ENTER_SWD;
504 case STLINK_MODE_DEBUG_SWIM:
505 h->txbuf[0] = STLINK_SWIM_COMMAND;
506 h->txbuf[1] = STLINK_SWIM_ENTER;
508 case STLINK_MODE_DFU:
509 case STLINK_MODE_MASS:
514 /* on api V2 we are able the read the latest command
516 * TODO: we need the test on api V1 too
518 if (h->jtag_api == STLINK_JTAG_API_V2)
521 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, rx_size);
526 res = stlink_usb_error_check(h);
532 static int stlink_usb_mode_leave(void *handle, enum stlink_mode type)
535 struct stlink_usb_handle_s *h;
537 assert(handle != NULL);
539 h = (struct stlink_usb_handle_s *)handle;
541 stlink_usb_init_buffer(handle);
544 case STLINK_MODE_DEBUG_JTAG:
545 case STLINK_MODE_DEBUG_SWD:
546 h->txbuf[0] = STLINK_DEBUG_COMMAND;
547 h->txbuf[1] = STLINK_DEBUG_EXIT;
549 case STLINK_MODE_DEBUG_SWIM:
550 h->txbuf[0] = STLINK_SWIM_COMMAND;
551 h->txbuf[1] = STLINK_SWIM_EXIT;
553 case STLINK_MODE_DFU:
554 h->txbuf[0] = STLINK_DFU_COMMAND;
555 h->txbuf[1] = STLINK_DFU_EXIT;
557 case STLINK_MODE_MASS:
562 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, 0, 0);
571 static int stlink_usb_init_mode(void *handle)
575 enum stlink_mode emode;
576 struct stlink_usb_handle_s *h;
578 assert(handle != NULL);
580 h = (struct stlink_usb_handle_s *)handle;
582 res = stlink_usb_current_mode(handle, &mode);
587 LOG_DEBUG("MODE: %02X", mode);
589 /* try to exit current mode */
591 case STLINK_DEV_DFU_MODE:
592 emode = STLINK_MODE_DFU;
594 case STLINK_DEV_DEBUG_MODE:
595 emode = STLINK_MODE_DEBUG_SWD;
597 case STLINK_DEV_SWIM_MODE:
598 emode = STLINK_MODE_DEBUG_SWIM;
600 case STLINK_DEV_BOOTLOADER_MODE:
601 case STLINK_DEV_MASS_MODE:
603 emode = STLINK_MODE_UNKNOWN;
607 if (emode != STLINK_MODE_UNKNOWN) {
608 res = stlink_usb_mode_leave(handle, emode);
614 res = stlink_usb_current_mode(handle, &mode);
619 LOG_DEBUG("MODE: %02X", mode);
621 /* set selected mode */
622 switch (h->transport) {
623 case STLINK_TRANSPORT_SWD:
624 emode = STLINK_MODE_DEBUG_SWD;
626 case STLINK_TRANSPORT_JTAG:
627 emode = STLINK_MODE_DEBUG_JTAG;
629 case STLINK_TRANSPORT_SWIM:
630 emode = STLINK_MODE_DEBUG_SWIM;
633 emode = STLINK_MODE_UNKNOWN;
637 if (emode == STLINK_MODE_UNKNOWN) {
638 LOG_ERROR("selected mode (transport) not supported");
642 res = stlink_usb_mode_enter(handle, emode);
647 res = stlink_usb_current_mode(handle, &mode);
652 LOG_DEBUG("MODE: %02X", mode);
658 static int stlink_usb_idcode(void *handle, uint32_t *idcode)
661 struct stlink_usb_handle_s *h;
663 assert(handle != NULL);
665 h = (struct stlink_usb_handle_s *)handle;
667 stlink_usb_init_buffer(handle);
669 h->txbuf[0] = STLINK_DEBUG_COMMAND;
670 h->txbuf[1] = STLINK_DEBUG_READCOREID;
672 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 4);
677 *idcode = le_to_h_u32(h->rxbuf);
679 LOG_DEBUG("IDCODE: %08X", *idcode);
685 static enum target_state stlink_usb_state(void *handle)
688 struct stlink_usb_handle_s *h;
690 assert(handle != NULL);
692 h = (struct stlink_usb_handle_s *)handle;
694 if (h->jtag_api == STLINK_JTAG_API_V2)
695 return TARGET_UNKNOWN;
697 stlink_usb_init_buffer(handle);
699 h->txbuf[0] = STLINK_DEBUG_COMMAND;
700 h->txbuf[1] = STLINK_DEBUG_GETSTATUS;
702 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
705 return TARGET_UNKNOWN;
707 if (h->rxbuf[0] == STLINK_CORE_RUNNING)
708 return TARGET_RUNNING;
709 if (h->rxbuf[0] == STLINK_CORE_HALTED)
710 return TARGET_HALTED;
712 return TARGET_UNKNOWN;
716 static int stlink_usb_reset(void *handle)
719 struct stlink_usb_handle_s *h;
721 assert(handle != NULL);
723 h = (struct stlink_usb_handle_s *)handle;
725 stlink_usb_init_buffer(handle);
727 h->txbuf[0] = STLINK_DEBUG_COMMAND;
729 if (h->jtag_api == STLINK_JTAG_API_V1)
730 h->txbuf[1] = STLINK_DEBUG_APIV1_RESETSYS;
732 h->txbuf[1] = STLINK_DEBUG_APIV2_RESETSYS;
734 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
739 LOG_DEBUG("RESET: %08X", h->rxbuf[0]);
745 static int stlink_usb_run(void *handle)
748 struct stlink_usb_handle_s *h;
750 assert(handle != NULL);
752 h = (struct stlink_usb_handle_s *)handle;
754 if (h->jtag_api == STLINK_JTAG_API_V2)
757 stlink_usb_init_buffer(handle);
759 h->txbuf[0] = STLINK_DEBUG_COMMAND;
760 h->txbuf[1] = STLINK_DEBUG_RUNCORE;
762 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
771 static int stlink_usb_halt(void *handle)
774 struct stlink_usb_handle_s *h;
776 assert(handle != NULL);
778 h = (struct stlink_usb_handle_s *)handle;
780 if (h->jtag_api == STLINK_JTAG_API_V2)
783 stlink_usb_init_buffer(handle);
785 h->txbuf[0] = STLINK_DEBUG_COMMAND;
786 h->txbuf[1] = STLINK_DEBUG_FORCEDEBUG;
788 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
797 static int stlink_usb_step(void *handle)
800 struct stlink_usb_handle_s *h;
802 assert(handle != NULL);
804 h = (struct stlink_usb_handle_s *)handle;
806 if (h->jtag_api == STLINK_JTAG_API_V2)
809 stlink_usb_init_buffer(handle);
811 h->txbuf[0] = STLINK_DEBUG_COMMAND;
812 h->txbuf[1] = STLINK_DEBUG_STEPCORE;
814 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
823 static int stlink_usb_read_regs(void *handle)
826 struct stlink_usb_handle_s *h;
828 assert(handle != NULL);
830 h = (struct stlink_usb_handle_s *)handle;
832 stlink_usb_init_buffer(handle);
834 h->txbuf[0] = STLINK_DEBUG_COMMAND;
835 if (h->jtag_api == STLINK_JTAG_API_V1)
836 h->txbuf[1] = STLINK_DEBUG_APIV1_READALLREGS;
838 h->txbuf[1] = STLINK_DEBUG_APIV2_READALLREGS;
840 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 84);
849 static int stlink_usb_read_reg(void *handle, int num, uint32_t *val)
852 struct stlink_usb_handle_s *h;
854 assert(handle != NULL);
856 h = (struct stlink_usb_handle_s *)handle;
858 stlink_usb_init_buffer(handle);
860 h->txbuf[0] = STLINK_DEBUG_COMMAND;
861 if (h->jtag_api == STLINK_JTAG_API_V1)
862 h->txbuf[1] = STLINK_DEBUG_APIV1_READREG;
864 h->txbuf[1] = STLINK_DEBUG_APIV2_READREG;
867 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 4);
872 *val = le_to_h_u32(h->rxbuf);
878 static int stlink_usb_write_reg(void *handle, int num, uint32_t val)
881 struct stlink_usb_handle_s *h;
883 assert(handle != NULL);
885 h = (struct stlink_usb_handle_s *)handle;
887 stlink_usb_init_buffer(handle);
889 h->txbuf[0] = STLINK_DEBUG_COMMAND;
890 if (h->jtag_api == STLINK_JTAG_API_V1)
891 h->txbuf[1] = STLINK_DEBUG_APIV1_WRITEREG;
893 h->txbuf[1] = STLINK_DEBUG_APIV2_WRITEREG;
895 h_u32_to_le(h->txbuf + 3, val);
897 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
906 static int stlink_usb_read_mem8(void *handle, uint32_t addr, uint16_t len,
910 uint16_t read_len = len;
911 struct stlink_usb_handle_s *h;
913 assert(handle != NULL);
915 h = (struct stlink_usb_handle_s *)handle;
917 stlink_usb_init_buffer(handle);
919 h->txbuf[0] = STLINK_DEBUG_COMMAND;
920 h->txbuf[1] = STLINK_DEBUG_READMEM_8BIT;
921 h_u32_to_le(h->txbuf + 2, addr);
922 h_u16_to_le(h->txbuf + 2 + 4, len);
924 /* we need to fix read length for single bytes */
928 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, read_len);
933 memcpy(buffer, h->rxbuf, len);
939 static int stlink_usb_write_mem8(void *handle, uint32_t addr, uint16_t len,
940 const uint8_t *buffer)
943 struct stlink_usb_handle_s *h;
945 assert(handle != NULL);
947 h = (struct stlink_usb_handle_s *)handle;
949 stlink_usb_init_buffer(handle);
951 h->txbuf[0] = STLINK_DEBUG_COMMAND;
952 h->txbuf[1] = STLINK_DEBUG_WRITEMEM_8BIT;
953 h_u32_to_le(h->txbuf + 2, addr);
954 h_u16_to_le(h->txbuf + 2 + 4, len);
956 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, 0, 0);
961 res = stlink_usb_recv(handle, (uint8_t *) buffer, len, 0, 0);
970 static int stlink_usb_read_mem32(void *handle, uint32_t addr, uint16_t len,
974 struct stlink_usb_handle_s *h;
976 assert(handle != NULL);
978 h = (struct stlink_usb_handle_s *)handle;
980 stlink_usb_init_buffer(handle);
984 h->txbuf[0] = STLINK_DEBUG_COMMAND;
985 h->txbuf[1] = STLINK_DEBUG_READMEM_32BIT;
986 h_u32_to_le(h->txbuf + 2, addr);
987 h_u16_to_le(h->txbuf + 2 + 4, len);
989 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, len);
994 memcpy(buffer, h->rxbuf, len);
1000 static int stlink_usb_write_mem32(void *handle, uint32_t addr, uint16_t len,
1001 const uint32_t *buffer)
1004 struct stlink_usb_handle_s *h;
1006 assert(handle != NULL);
1008 h = (struct stlink_usb_handle_s *)handle;
1010 stlink_usb_init_buffer(handle);
1014 h->txbuf[0] = STLINK_DEBUG_COMMAND;
1015 h->txbuf[1] = STLINK_DEBUG_WRITEMEM_32BIT;
1016 h_u32_to_le(h->txbuf + 2, addr);
1017 h_u16_to_le(h->txbuf + 2 + 4, len);
1019 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, 0, 0);
1021 if (res != ERROR_OK)
1024 res = stlink_usb_recv(handle, (uint8_t *) buffer, len, 0, 0);
1026 if (res != ERROR_OK)
1033 static int stlink_usb_open(struct stlink_interface_param_s *param, void **fd)
1036 struct stlink_usb_handle_s *h;
1038 LOG_DEBUG("stlink_usb_open");
1040 h = malloc(sizeof(struct stlink_usb_handle_s));
1043 LOG_DEBUG("malloc failed");
1047 h->transport = param->transport;
1049 const uint16_t vids[] = { param->vid, 0 };
1050 const uint16_t pids[] = { param->pid, 0 };
1052 LOG_DEBUG("transport: %d vid: %04x pid: %04x", param->transport,
1053 param->vid, param->pid);
1055 if (jtag_libusb_open(vids, pids, &h->fd) != ERROR_OK) {
1056 LOG_ERROR("open failed");
1060 jtag_libusb_set_configuration(h->fd, 0);
1062 if (jtag_libusb_claim_interface(h->fd, 0) != ERROR_OK) {
1063 LOG_DEBUG("claim interface failed");
1067 /* wrap version for first read */
1068 switch (param->pid) {
1070 h->version.stlink = 1;
1073 h->version.stlink = 2;
1077 /* get the device version */
1078 err = stlink_usb_version(h);
1080 if (err != ERROR_OK) {
1081 LOG_ERROR("read version failed");
1082 jtag_libusb_close(h->fd);
1087 /* compare usb vid/pid */
1088 if ((param->vid != h->vid) || (param->pid != h->pid))
1089 LOG_INFO("vid/pid are not identical: %04X/%04X %04X/%04X",
1090 param->vid, param->pid,
1093 /* check if mode is supported */
1096 switch (h->transport) {
1097 case STLINK_TRANSPORT_SWD:
1098 case STLINK_TRANSPORT_JTAG:
1099 if (h->version.jtag == 0)
1102 case STLINK_TRANSPORT_SWIM:
1103 if (h->version.swim == 0)
1111 if (err != ERROR_OK) {
1112 LOG_ERROR("mode (transport) not supported by device");
1113 jtag_libusb_close(h->fd);
1118 /* set the used jtag api */
1119 h->jtag_api = STLINK_JTAG_API_V1;
1121 /* initialize the debug hardware */
1122 err = stlink_usb_init_mode(h);
1124 if (err != ERROR_OK) {
1125 LOG_ERROR("init mode failed");
1126 jtag_libusb_close(h->fd);
1137 static int stlink_usb_close(void *fd)
1143 struct stlink_layout_api_s stlink_usb_layout_api = {
1145 .open = stlink_usb_open,
1147 .close = stlink_usb_close,
1149 .idcode = stlink_usb_idcode,
1151 .state = stlink_usb_state,
1153 .reset = stlink_usb_reset,
1155 .run = stlink_usb_run,
1157 .halt = stlink_usb_halt,
1159 .step = stlink_usb_step,
1161 .read_regs = stlink_usb_read_regs,
1163 .read_reg = stlink_usb_read_reg,
1165 .write_reg = stlink_usb_write_reg,
1167 .read_mem8 = stlink_usb_read_mem8,
1169 .write_mem8 = stlink_usb_write_mem8,
1171 .read_mem32 = stlink_usb_read_mem32,
1173 .write_mem32 = stlink_usb_write_mem32,