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 int stlink_usb_send(void *handle, const uint8_t *cmd, int cmdsize, uint8_t *txbuf,
357 return stlink_usb_xfer(handle, cmd, cmdsize, STLINK_TX_EP, txbuf, txsize);
361 static void stlink_usb_init_buffer(void *handle)
363 struct stlink_usb_handle_s *h;
365 assert(handle != NULL);
367 h = (struct stlink_usb_handle_s *)handle;
369 memset(h->txbuf, 0, STLINK_TX_SIZE);
370 memset(h->rxbuf, 0, STLINK_RX_SIZE);
373 static const char * const stlink_usb_error_msg[] = {
378 static int stlink_usb_error_check(void *handle)
381 const char *err_msg = 0;
382 struct stlink_usb_handle_s *h;
384 assert(handle != NULL);
386 h = (struct stlink_usb_handle_s *)handle;
388 /* TODO: no error checking yet on api V1 */
389 if (h->jtag_api == STLINK_JTAG_API_V1)
390 h->rxbuf[0] = STLINK_DEBUG_ERR_OK;
392 switch (h->rxbuf[0]) {
393 case STLINK_DEBUG_ERR_OK:
396 case STLINK_DEBUG_ERR_FAULT:
398 err_msg = stlink_usb_error_msg[0];
404 LOG_DEBUG("status error: %d ('%s')", h->rxbuf[0], err_msg);
410 static int stlink_usb_version(void *handle)
414 struct stlink_usb_handle_s *h;
416 assert(handle != NULL);
418 h = (struct stlink_usb_handle_s *)handle;
420 stlink_usb_init_buffer(handle);
422 h->txbuf[0] = STLINK_GET_VERSION;
424 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 6);
429 v = (h->rxbuf[0] << 8) | h->rxbuf[1];
431 h->version.stlink = (v >> 12) & 0x0f;
432 h->version.jtag = (v >> 6) & 0x3f;
433 h->version.swim = v & 0x3f;
434 h->vid = buf_get_u32(h->rxbuf, 16, 16);
435 h->pid = buf_get_u32(h->rxbuf, 32, 16);
437 /* set the supported jtag api version
438 * V1 doesn't support API V2 at all
439 * V2 support API V2 since JTAG V13
441 if ((h->version.stlink == 2) && (h->version.jtag > 12))
442 h->version.jtag_api_max = STLINK_JTAG_API_V2;
444 h->version.jtag_api_max = STLINK_JTAG_API_V1;
446 LOG_DEBUG("STLINK v%d JTAG v%d API v%d SWIM v%d VID %04X PID %04X",
449 (h->version.jtag_api_max == STLINK_JTAG_API_V1) ? 1 : 2,
458 static int stlink_usb_current_mode(void *handle, uint8_t *mode)
461 struct stlink_usb_handle_s *h;
463 assert(handle != NULL);
465 h = (struct stlink_usb_handle_s *)handle;
467 stlink_usb_init_buffer(handle);
469 h->txbuf[0] = STLINK_GET_CURRENT_MODE;
471 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
482 static int stlink_usb_mode_enter(void *handle, enum stlink_mode type)
486 struct stlink_usb_handle_s *h;
488 assert(handle != NULL);
490 h = (struct stlink_usb_handle_s *)handle;
492 stlink_usb_init_buffer(handle);
495 case STLINK_MODE_DEBUG_JTAG:
496 h->txbuf[0] = STLINK_DEBUG_COMMAND;
497 if (h->jtag_api == STLINK_JTAG_API_V1)
498 h->txbuf[1] = STLINK_DEBUG_APIV1_ENTER;
500 h->txbuf[1] = STLINK_DEBUG_APIV2_ENTER;
501 h->txbuf[2] = STLINK_DEBUG_ENTER_JTAG;
503 case STLINK_MODE_DEBUG_SWD:
504 h->txbuf[0] = STLINK_DEBUG_COMMAND;
505 if (h->jtag_api == STLINK_JTAG_API_V1)
506 h->txbuf[1] = STLINK_DEBUG_APIV1_ENTER;
508 h->txbuf[1] = STLINK_DEBUG_APIV2_ENTER;
509 h->txbuf[2] = STLINK_DEBUG_ENTER_SWD;
511 case STLINK_MODE_DEBUG_SWIM:
512 h->txbuf[0] = STLINK_SWIM_COMMAND;
513 h->txbuf[1] = STLINK_SWIM_ENTER;
515 case STLINK_MODE_DFU:
516 case STLINK_MODE_MASS:
521 /* on api V2 we are able the read the latest command
523 * TODO: we need the test on api V1 too
525 if (h->jtag_api == STLINK_JTAG_API_V2)
528 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, rx_size);
533 res = stlink_usb_error_check(h);
539 static int stlink_usb_mode_leave(void *handle, enum stlink_mode type)
542 struct stlink_usb_handle_s *h;
544 assert(handle != NULL);
546 h = (struct stlink_usb_handle_s *)handle;
548 stlink_usb_init_buffer(handle);
551 case STLINK_MODE_DEBUG_JTAG:
552 case STLINK_MODE_DEBUG_SWD:
553 h->txbuf[0] = STLINK_DEBUG_COMMAND;
554 h->txbuf[1] = STLINK_DEBUG_EXIT;
556 case STLINK_MODE_DEBUG_SWIM:
557 h->txbuf[0] = STLINK_SWIM_COMMAND;
558 h->txbuf[1] = STLINK_SWIM_EXIT;
560 case STLINK_MODE_DFU:
561 h->txbuf[0] = STLINK_DFU_COMMAND;
562 h->txbuf[1] = STLINK_DFU_EXIT;
564 case STLINK_MODE_MASS:
569 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, 0, 0);
578 static int stlink_usb_init_mode(void *handle)
582 enum stlink_mode emode;
583 struct stlink_usb_handle_s *h;
585 assert(handle != NULL);
587 h = (struct stlink_usb_handle_s *)handle;
589 res = stlink_usb_current_mode(handle, &mode);
594 LOG_DEBUG("MODE: %02X", mode);
596 /* try to exit current mode */
598 case STLINK_DEV_DFU_MODE:
599 emode = STLINK_MODE_DFU;
601 case STLINK_DEV_DEBUG_MODE:
602 emode = STLINK_MODE_DEBUG_SWD;
604 case STLINK_DEV_SWIM_MODE:
605 emode = STLINK_MODE_DEBUG_SWIM;
607 case STLINK_DEV_BOOTLOADER_MODE:
608 case STLINK_DEV_MASS_MODE:
610 emode = STLINK_MODE_UNKNOWN;
614 if (emode != STLINK_MODE_UNKNOWN) {
615 res = stlink_usb_mode_leave(handle, emode);
621 res = stlink_usb_current_mode(handle, &mode);
626 LOG_DEBUG("MODE: %02X", mode);
628 /* set selected mode */
629 switch (h->transport) {
630 case STLINK_TRANSPORT_SWD:
631 emode = STLINK_MODE_DEBUG_SWD;
633 case STLINK_TRANSPORT_JTAG:
634 emode = STLINK_MODE_DEBUG_JTAG;
636 case STLINK_TRANSPORT_SWIM:
637 emode = STLINK_MODE_DEBUG_SWIM;
640 emode = STLINK_MODE_UNKNOWN;
644 if (emode == STLINK_MODE_UNKNOWN) {
645 LOG_ERROR("selected mode (transport) not supported");
649 res = stlink_usb_mode_enter(handle, emode);
654 res = stlink_usb_current_mode(handle, &mode);
659 LOG_DEBUG("MODE: %02X", mode);
665 static int stlink_usb_idcode(void *handle, uint32_t *idcode)
668 struct stlink_usb_handle_s *h;
670 assert(handle != NULL);
672 h = (struct stlink_usb_handle_s *)handle;
674 stlink_usb_init_buffer(handle);
676 h->txbuf[0] = STLINK_DEBUG_COMMAND;
677 h->txbuf[1] = STLINK_DEBUG_READCOREID;
679 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 4);
684 *idcode = le_to_h_u32(h->rxbuf);
686 LOG_DEBUG("IDCODE: %08X", *idcode);
692 static enum target_state stlink_usb_state(void *handle)
695 struct stlink_usb_handle_s *h;
697 assert(handle != NULL);
699 h = (struct stlink_usb_handle_s *)handle;
701 if (h->jtag_api == STLINK_JTAG_API_V2)
702 return TARGET_UNKNOWN;
704 stlink_usb_init_buffer(handle);
706 h->txbuf[0] = STLINK_DEBUG_COMMAND;
707 h->txbuf[1] = STLINK_DEBUG_GETSTATUS;
709 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
712 return TARGET_UNKNOWN;
714 if (h->rxbuf[0] == STLINK_CORE_RUNNING)
715 return TARGET_RUNNING;
716 if (h->rxbuf[0] == STLINK_CORE_HALTED)
717 return TARGET_HALTED;
719 return TARGET_UNKNOWN;
723 static int stlink_usb_reset(void *handle)
726 struct stlink_usb_handle_s *h;
728 assert(handle != NULL);
730 h = (struct stlink_usb_handle_s *)handle;
732 stlink_usb_init_buffer(handle);
734 h->txbuf[0] = STLINK_DEBUG_COMMAND;
736 if (h->jtag_api == STLINK_JTAG_API_V1)
737 h->txbuf[1] = STLINK_DEBUG_APIV1_RESETSYS;
739 h->txbuf[1] = STLINK_DEBUG_APIV2_RESETSYS;
741 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
746 LOG_DEBUG("RESET: %08X", h->rxbuf[0]);
752 static int stlink_usb_run(void *handle)
755 struct stlink_usb_handle_s *h;
757 assert(handle != NULL);
759 h = (struct stlink_usb_handle_s *)handle;
761 if (h->jtag_api == STLINK_JTAG_API_V2)
764 stlink_usb_init_buffer(handle);
766 h->txbuf[0] = STLINK_DEBUG_COMMAND;
767 h->txbuf[1] = STLINK_DEBUG_RUNCORE;
769 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
778 static int stlink_usb_halt(void *handle)
781 struct stlink_usb_handle_s *h;
783 assert(handle != NULL);
785 h = (struct stlink_usb_handle_s *)handle;
787 if (h->jtag_api == STLINK_JTAG_API_V2)
790 stlink_usb_init_buffer(handle);
792 h->txbuf[0] = STLINK_DEBUG_COMMAND;
793 h->txbuf[1] = STLINK_DEBUG_FORCEDEBUG;
795 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
804 static int stlink_usb_step(void *handle)
807 struct stlink_usb_handle_s *h;
809 assert(handle != NULL);
811 h = (struct stlink_usb_handle_s *)handle;
813 if (h->jtag_api == STLINK_JTAG_API_V2)
816 stlink_usb_init_buffer(handle);
818 h->txbuf[0] = STLINK_DEBUG_COMMAND;
819 h->txbuf[1] = STLINK_DEBUG_STEPCORE;
821 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
830 static int stlink_usb_read_regs(void *handle)
833 struct stlink_usb_handle_s *h;
835 assert(handle != NULL);
837 h = (struct stlink_usb_handle_s *)handle;
839 stlink_usb_init_buffer(handle);
841 h->txbuf[0] = STLINK_DEBUG_COMMAND;
842 if (h->jtag_api == STLINK_JTAG_API_V1)
843 h->txbuf[1] = STLINK_DEBUG_APIV1_READALLREGS;
845 h->txbuf[1] = STLINK_DEBUG_APIV2_READALLREGS;
847 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 84);
856 static int stlink_usb_read_reg(void *handle, int num, uint32_t *val)
859 struct stlink_usb_handle_s *h;
861 assert(handle != NULL);
863 h = (struct stlink_usb_handle_s *)handle;
865 stlink_usb_init_buffer(handle);
867 h->txbuf[0] = STLINK_DEBUG_COMMAND;
868 if (h->jtag_api == STLINK_JTAG_API_V1)
869 h->txbuf[1] = STLINK_DEBUG_APIV1_READREG;
871 h->txbuf[1] = STLINK_DEBUG_APIV2_READREG;
874 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 4);
879 *val = le_to_h_u32(h->rxbuf);
885 static int stlink_usb_write_reg(void *handle, int num, uint32_t val)
888 struct stlink_usb_handle_s *h;
890 assert(handle != NULL);
892 h = (struct stlink_usb_handle_s *)handle;
894 stlink_usb_init_buffer(handle);
896 h->txbuf[0] = STLINK_DEBUG_COMMAND;
897 if (h->jtag_api == STLINK_JTAG_API_V1)
898 h->txbuf[1] = STLINK_DEBUG_APIV1_WRITEREG;
900 h->txbuf[1] = STLINK_DEBUG_APIV2_WRITEREG;
902 h_u32_to_le(h->txbuf + 3, val);
904 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
913 static int stlink_usb_read_mem8(void *handle, uint32_t addr, uint16_t len,
917 uint16_t read_len = len;
918 struct stlink_usb_handle_s *h;
920 assert(handle != NULL);
922 h = (struct stlink_usb_handle_s *)handle;
924 stlink_usb_init_buffer(handle);
926 h->txbuf[0] = STLINK_DEBUG_COMMAND;
927 h->txbuf[1] = STLINK_DEBUG_READMEM_8BIT;
928 h_u32_to_le(h->txbuf + 2, addr);
929 h_u16_to_le(h->txbuf + 2 + 4, len);
931 /* we need to fix read length for single bytes */
935 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, read_len);
940 memcpy(buffer, h->rxbuf, len);
946 static int stlink_usb_write_mem8(void *handle, uint32_t addr, uint16_t len,
947 const uint8_t *buffer)
950 struct stlink_usb_handle_s *h;
952 assert(handle != NULL);
954 h = (struct stlink_usb_handle_s *)handle;
956 stlink_usb_init_buffer(handle);
958 h->txbuf[0] = STLINK_DEBUG_COMMAND;
959 h->txbuf[1] = STLINK_DEBUG_WRITEMEM_8BIT;
960 h_u32_to_le(h->txbuf + 2, addr);
961 h_u16_to_le(h->txbuf + 2 + 4, len);
963 res = stlink_usb_send(handle, h->txbuf, STLINK_CMD_SIZE, (uint8_t *) buffer, len);
972 static int stlink_usb_read_mem32(void *handle, uint32_t addr, uint16_t len,
976 struct stlink_usb_handle_s *h;
978 assert(handle != NULL);
980 h = (struct stlink_usb_handle_s *)handle;
982 stlink_usb_init_buffer(handle);
986 h->txbuf[0] = STLINK_DEBUG_COMMAND;
987 h->txbuf[1] = STLINK_DEBUG_READMEM_32BIT;
988 h_u32_to_le(h->txbuf + 2, addr);
989 h_u16_to_le(h->txbuf + 2 + 4, len);
991 res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, len);
996 memcpy(buffer, h->rxbuf, len);
1002 static int stlink_usb_write_mem32(void *handle, uint32_t addr, uint16_t len,
1003 const uint32_t *buffer)
1006 struct stlink_usb_handle_s *h;
1008 assert(handle != NULL);
1010 h = (struct stlink_usb_handle_s *)handle;
1012 stlink_usb_init_buffer(handle);
1016 h->txbuf[0] = STLINK_DEBUG_COMMAND;
1017 h->txbuf[1] = STLINK_DEBUG_WRITEMEM_32BIT;
1018 h_u32_to_le(h->txbuf + 2, addr);
1019 h_u16_to_le(h->txbuf + 2 + 4, len);
1021 res = stlink_usb_send(handle, h->txbuf, STLINK_CMD_SIZE, (uint8_t *) buffer, len);
1023 if (res != ERROR_OK)
1030 static int stlink_usb_open(struct stlink_interface_param_s *param, void **fd)
1033 struct stlink_usb_handle_s *h;
1035 LOG_DEBUG("stlink_usb_open");
1037 h = malloc(sizeof(struct stlink_usb_handle_s));
1040 LOG_DEBUG("malloc failed");
1044 h->transport = param->transport;
1046 const uint16_t vids[] = { param->vid, 0 };
1047 const uint16_t pids[] = { param->pid, 0 };
1049 LOG_DEBUG("transport: %d vid: %04x pid: %04x", param->transport,
1050 param->vid, param->pid);
1052 if (jtag_libusb_open(vids, pids, &h->fd) != ERROR_OK) {
1053 LOG_ERROR("open failed");
1057 jtag_libusb_set_configuration(h->fd, 0);
1059 if (jtag_libusb_claim_interface(h->fd, 0) != ERROR_OK) {
1060 LOG_DEBUG("claim interface failed");
1064 /* wrap version for first read */
1065 switch (param->pid) {
1067 h->version.stlink = 1;
1070 h->version.stlink = 2;
1074 /* get the device version */
1075 err = stlink_usb_version(h);
1077 if (err != ERROR_OK) {
1078 LOG_ERROR("read version failed");
1079 jtag_libusb_close(h->fd);
1084 /* compare usb vid/pid */
1085 if ((param->vid != h->vid) || (param->pid != h->pid))
1086 LOG_INFO("vid/pid are not identical: %04X/%04X %04X/%04X",
1087 param->vid, param->pid,
1090 /* check if mode is supported */
1093 switch (h->transport) {
1094 case STLINK_TRANSPORT_SWD:
1095 case STLINK_TRANSPORT_JTAG:
1096 if (h->version.jtag == 0)
1099 case STLINK_TRANSPORT_SWIM:
1100 if (h->version.swim == 0)
1108 if (err != ERROR_OK) {
1109 LOG_ERROR("mode (transport) not supported by device");
1110 jtag_libusb_close(h->fd);
1115 /* set the used jtag api */
1116 h->jtag_api = STLINK_JTAG_API_V1;
1118 /* initialize the debug hardware */
1119 err = stlink_usb_init_mode(h);
1121 if (err != ERROR_OK) {
1122 LOG_ERROR("init mode failed");
1123 jtag_libusb_close(h->fd);
1134 static int stlink_usb_close(void *fd)
1140 struct stlink_layout_api_s stlink_usb_layout_api = {
1142 .open = stlink_usb_open,
1144 .close = stlink_usb_close,
1146 .idcode = stlink_usb_idcode,
1148 .state = stlink_usb_state,
1150 .reset = stlink_usb_reset,
1152 .run = stlink_usb_run,
1154 .halt = stlink_usb_halt,
1156 .step = stlink_usb_step,
1158 .read_regs = stlink_usb_read_regs,
1160 .read_reg = stlink_usb_read_reg,
1162 .write_reg = stlink_usb_write_reg,
1164 .read_mem8 = stlink_usb_read_mem8,
1166 .write_mem8 = stlink_usb_write_mem8,
1168 .read_mem32 = stlink_usb_read_mem32,
1170 .write_mem32 = stlink_usb_write_mem32,