?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
stlink: increase trace buffer size to maximum allowed on st-link v2 firmware
[openocd.git] / src / jtag / drivers / stlink_usb.c
blob0bdcd316b70df27c2b6b4345e1cdd875e3be659e
1 /***************************************************************************
2 * Copyright (C) 2011-2012 by Mathias Kuester *
3 * Mathias Kuester <kesmtp@freenet.de> *
4 * *
5 * Copyright (C) 2012 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
7 * *
8 * This code is based on https://github.com/texane/stlink *
9 * *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 * This program is distributed in the hope that it will be useful, *
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
18 * GNU General Public License for more details. *
19 * *
20 * You should have received a copy of the GNU General Public License *
21 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
22 ***************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27
28 /* project specific includes */
29 #include <helper/binarybuffer.h>
30 #include <jtag/interface.h>
31 #include <jtag/hla/hla_layout.h>
32 #include <jtag/hla/hla_transport.h>
33 #include <jtag/hla/hla_interface.h>
34 #include <target/target.h>
35
36 #include <target/cortex_m.h>
37
38 #include "libusb_common.h"
39
40 #define ENDPOINT_IN 0x80
41 #define ENDPOINT_OUT 0x00
42
43 #define STLINK_WRITE_TIMEOUT 1000
44 #define STLINK_READ_TIMEOUT 1000
45
46 #define STLINK_NULL_EP 0
47 #define STLINK_RX_EP (1|ENDPOINT_IN)
48 #define STLINK_TX_EP (2|ENDPOINT_OUT)
49 #define STLINK_TRACE_EP (3|ENDPOINT_IN)
50
51 #define STLINK_V2_1_TX_EP (1|ENDPOINT_OUT)
52 #define STLINK_V2_1_TRACE_EP (2|ENDPOINT_IN)
53
54 #define STLINK_SG_SIZE (31)
55 #define STLINK_DATA_SIZE (4096)
56 #define STLINK_CMD_SIZE_V2 (16)
57 #define STLINK_CMD_SIZE_V1 (10)
58
59 #define STLINK_V1_PID (0x3744)
60 #define STLINK_V2_PID (0x3748)
61 #define STLINK_V2_1_PID (0x374B)
62
63 /* the current implementation of the stlink limits
64 * 8bit read/writes to max 64 bytes. */
65 #define STLINK_MAX_RW8 (64)
66
67 /* "WAIT" responses will be retried (with exponential backoff) at
68 * most this many times before failing to caller.
69 */
70 #define MAX_WAIT_RETRIES 8
71
72 enum stlink_jtag_api_version {
73 STLINK_JTAG_API_V1 = 1,
74 STLINK_JTAG_API_V2,
75 };
76
77 /** */
78 struct stlink_usb_version {
79 /** */
80 int stlink;
81 /** */
82 int jtag;
83 /** */
84 int swim;
85 /** highest supported jtag api version */
86 enum stlink_jtag_api_version jtag_api_max;
87 };
88
89 /** */
90 struct stlink_usb_handle_s {
91 /** */
92 struct jtag_libusb_device_handle *fd;
93 /** */
94 struct libusb_transfer *trans;
95 /** */
96 uint8_t rx_ep;
97 /** */
98 uint8_t tx_ep;
99 /** */
100 uint8_t trace_ep;
101 /** */
102 uint8_t cmdbuf[STLINK_SG_SIZE];
103 /** */
104 uint8_t cmdidx;
105 /** */
106 uint8_t direction;
107 /** */
108 uint8_t databuf[STLINK_DATA_SIZE];
109 /** */
110 uint32_t max_mem_packet;
111 /** */
112 enum hl_transports transport;
113 /** */
114 struct stlink_usb_version version;
115 /** */
116 uint16_t vid;
117 /** */
118 uint16_t pid;
119 /** this is the currently used jtag api */
120 enum stlink_jtag_api_version jtag_api;
121 /** */
122 struct {
123 /** whether SWO tracing is enabled or not */
124 bool enabled;
125 /** trace module source clock */
126 uint32_t source_hz;
127 } trace;
128 /** reconnect is needed next time we try to query the
129 * status */
130 bool reconnect_pending;
131 };
132
133 #define STLINK_DEBUG_ERR_OK 0x80
134 #define STLINK_DEBUG_ERR_FAULT 0x81
135 #define STLINK_SWD_AP_WAIT 0x10
136 #define STLINK_SWD_AP_FAULT 0x11
137 #define STLINK_SWD_AP_ERROR 0x12
138 #define STLINK_SWD_AP_PARITY_ERROR 0x13
139 #define STLINK_JTAG_WRITE_ERROR 0x0c
140 #define STLINK_JTAG_WRITE_VERIF_ERROR 0x0d
141 #define STLINK_SWD_DP_WAIT 0x14
142 #define STLINK_SWD_DP_FAULT 0x15
143 #define STLINK_SWD_DP_ERROR 0x16
144 #define STLINK_SWD_DP_PARITY_ERROR 0x17
145
146 #define STLINK_SWD_AP_WDATA_ERROR 0x18
147 #define STLINK_SWD_AP_STICKY_ERROR 0x19
148 #define STLINK_SWD_AP_STICKYORUN_ERROR 0x1a
149
150 #define STLINK_CORE_RUNNING 0x80
151 #define STLINK_CORE_HALTED 0x81
152 #define STLINK_CORE_STAT_UNKNOWN -1
153
154 #define STLINK_GET_VERSION 0xF1
155 #define STLINK_DEBUG_COMMAND 0xF2
156 #define STLINK_DFU_COMMAND 0xF3
157 #define STLINK_SWIM_COMMAND 0xF4
158 #define STLINK_GET_CURRENT_MODE 0xF5
159 #define STLINK_GET_TARGET_VOLTAGE 0xF7
160
161 #define STLINK_DEV_DFU_MODE 0x00
162 #define STLINK_DEV_MASS_MODE 0x01
163 #define STLINK_DEV_DEBUG_MODE 0x02
164 #define STLINK_DEV_SWIM_MODE 0x03
165 #define STLINK_DEV_BOOTLOADER_MODE 0x04
166 #define STLINK_DEV_UNKNOWN_MODE -1
167
168 #define STLINK_DFU_EXIT 0x07
169
170 #define STLINK_SWIM_ENTER 0x00
171 #define STLINK_SWIM_EXIT 0x01
172
173 #define STLINK_DEBUG_ENTER_JTAG 0x00
174 #define STLINK_DEBUG_GETSTATUS 0x01
175 #define STLINK_DEBUG_FORCEDEBUG 0x02
176 #define STLINK_DEBUG_APIV1_RESETSYS 0x03
177 #define STLINK_DEBUG_APIV1_READALLREGS 0x04
178 #define STLINK_DEBUG_APIV1_READREG 0x05
179 #define STLINK_DEBUG_APIV1_WRITEREG 0x06
180 #define STLINK_DEBUG_READMEM_32BIT 0x07
181 #define STLINK_DEBUG_WRITEMEM_32BIT 0x08
182 #define STLINK_DEBUG_RUNCORE 0x09
183 #define STLINK_DEBUG_STEPCORE 0x0a
184 #define STLINK_DEBUG_APIV1_SETFP 0x0b
185 #define STLINK_DEBUG_READMEM_8BIT 0x0c
186 #define STLINK_DEBUG_WRITEMEM_8BIT 0x0d
187 #define STLINK_DEBUG_APIV1_CLEARFP 0x0e
188 #define STLINK_DEBUG_APIV1_WRITEDEBUGREG 0x0f
189 #define STLINK_DEBUG_APIV1_SETWATCHPOINT 0x10
190
191 #define STLINK_DEBUG_ENTER_JTAG 0x00
192 #define STLINK_DEBUG_ENTER_SWD 0xa3
193
194 #define STLINK_DEBUG_APIV1_ENTER 0x20
195 #define STLINK_DEBUG_EXIT 0x21
196 #define STLINK_DEBUG_READCOREID 0x22
197
198 #define STLINK_DEBUG_APIV2_ENTER 0x30
199 #define STLINK_DEBUG_APIV2_READ_IDCODES 0x31
200 #define STLINK_DEBUG_APIV2_RESETSYS 0x32
201 #define STLINK_DEBUG_APIV2_READREG 0x33
202 #define STLINK_DEBUG_APIV2_WRITEREG 0x34
203 #define STLINK_DEBUG_APIV2_WRITEDEBUGREG 0x35
204 #define STLINK_DEBUG_APIV2_READDEBUGREG 0x36
205
206 #define STLINK_DEBUG_APIV2_READALLREGS 0x3A
207 #define STLINK_DEBUG_APIV2_GETLASTRWSTATUS 0x3B
208 #define STLINK_DEBUG_APIV2_DRIVE_NRST 0x3C
209
210 #define STLINK_DEBUG_APIV2_START_TRACE_RX 0x40
211 #define STLINK_DEBUG_APIV2_STOP_TRACE_RX 0x41
212 #define STLINK_DEBUG_APIV2_GET_TRACE_NB 0x42
213 #define STLINK_DEBUG_APIV2_SWD_SET_FREQ 0x43
214
215 #define STLINK_DEBUG_APIV2_DRIVE_NRST_LOW 0x00
216 #define STLINK_DEBUG_APIV2_DRIVE_NRST_HIGH 0x01
217 #define STLINK_DEBUG_APIV2_DRIVE_NRST_PULSE 0x02
218
219 #define STLINK_TRACE_SIZE 4096
220 #define STLINK_TRACE_MAX_HZ 2000000
221 #define STLINK_TRACE_MIN_VERSION 13
222
223 /** */
224 enum stlink_mode {
225 STLINK_MODE_UNKNOWN = 0,
226 STLINK_MODE_DFU,
227 STLINK_MODE_MASS,
228 STLINK_MODE_DEBUG_JTAG,
229 STLINK_MODE_DEBUG_SWD,
230 STLINK_MODE_DEBUG_SWIM
231 };
232
233 #define REQUEST_SENSE 0x03
234 #define REQUEST_SENSE_LENGTH 18
235
236 static const struct {
237 int speed;
238 int speed_divisor;
239 } stlink_khz_to_speed_map[] = {
240 {4000, 0},
241 {1800, 1}, /* default */
242 {1200, 2},
243 {950, 3},
244 {480, 7},
245 {240, 15},
246 {125, 31},
247 {100, 40},
248 {50, 79},
249 {25, 158},
250 {15, 265},
251 {5, 798}
252 };
253
254 static void stlink_usb_init_buffer(void *handle, uint8_t direction, uint32_t size);
255
256 /** */
257 static int stlink_usb_xfer_v1_get_status(void *handle)
258 {
259 struct stlink_usb_handle_s *h = handle;
260
261 assert(handle != NULL);
262
263 /* read status */
264 memset(h->cmdbuf, 0, STLINK_SG_SIZE);
265
266 if (jtag_libusb_bulk_read(h->fd, h->rx_ep, (char *)h->cmdbuf,
267 13, STLINK_READ_TIMEOUT) != 13)
268 return ERROR_FAIL;
269
270 uint32_t t1;
271
272 t1 = buf_get_u32(h->cmdbuf, 0, 32);
273
274 /* check for USBS */
275 if (t1 != 0x53425355)
276 return ERROR_FAIL;
277 /*
278 * CSW status:
279 * 0 success
280 * 1 command failure
281 * 2 phase error
282 */
283 if (h->cmdbuf[12] != 0)
284 return ERROR_FAIL;
285
286 return ERROR_OK;
287 }
288
289 /** */
290 static int stlink_usb_xfer_rw(void *handle, int cmdsize, const uint8_t *buf, int size)
291 {
292 struct stlink_usb_handle_s *h = handle;
293
294 assert(handle != NULL);
295
296 if (jtag_libusb_bulk_write(h->fd, h->tx_ep, (char *)h->cmdbuf, cmdsize,
297 STLINK_WRITE_TIMEOUT) != cmdsize) {
298 return ERROR_FAIL;
299 }
300
301 if (h->direction == h->tx_ep && size) {
302 if (jtag_libusb_bulk_write(h->fd, h->tx_ep, (char *)buf,
303 size, STLINK_WRITE_TIMEOUT) != size) {
304 LOG_DEBUG("bulk write failed");
305 return ERROR_FAIL;
306 }
307 } else if (h->direction == h->rx_ep && size) {
308 if (jtag_libusb_bulk_read(h->fd, h->rx_ep, (char *)buf,
309 size, STLINK_READ_TIMEOUT) != size) {
310 LOG_DEBUG("bulk read failed");
311 return ERROR_FAIL;
312 }
313 }
314
315 return ERROR_OK;
316 }
317
318 /** */
319 static int stlink_usb_xfer_v1_get_sense(void *handle)
320 {
321 int res;
322 struct stlink_usb_handle_s *h = handle;
323
324 assert(handle != NULL);
325
326 stlink_usb_init_buffer(handle, h->rx_ep, 16);
327
328 h->cmdbuf[h->cmdidx++] = REQUEST_SENSE;
329 h->cmdbuf[h->cmdidx++] = 0;
330 h->cmdbuf[h->cmdidx++] = 0;
331 h->cmdbuf[h->cmdidx++] = 0;
332 h->cmdbuf[h->cmdidx++] = REQUEST_SENSE_LENGTH;
333
334 res = stlink_usb_xfer_rw(handle, REQUEST_SENSE_LENGTH, h->databuf, 16);
335
336 if (res != ERROR_OK)
337 return res;
338
339 if (stlink_usb_xfer_v1_get_status(handle) != ERROR_OK)
340 return ERROR_FAIL;
341
342 return ERROR_OK;
343 }
344
345 /** */
346 static int stlink_usb_xfer(void *handle, const uint8_t *buf, int size)
347 {
348 int err, cmdsize = STLINK_CMD_SIZE_V2;
349 struct stlink_usb_handle_s *h = handle;
350
351 assert(handle != NULL);
352
353 if (h->version.stlink == 1)
354 cmdsize = STLINK_SG_SIZE;
355
356 err = stlink_usb_xfer_rw(handle, cmdsize, buf, size);
357
358 if (err != ERROR_OK)
359 return err;
360
361 if (h->version.stlink == 1) {
362 if (stlink_usb_xfer_v1_get_status(handle) != ERROR_OK) {
363 /* check csw status */
364 if (h->cmdbuf[12] == 1) {
365 LOG_DEBUG("get sense");
366 if (stlink_usb_xfer_v1_get_sense(handle) != ERROR_OK)
367 return ERROR_FAIL;
368 }
369 return ERROR_FAIL;
370 }
371 }
372
373 return ERROR_OK;
374 }
375
376
377 /**
378 Converts an STLINK status code held in the first byte of a response
379 to an openocd error, logs any error/wait status as debug output.
380 */
381 static int stlink_usb_error_check(void *handle)
382 {
383 struct stlink_usb_handle_s *h = handle;
384
385 assert(handle != NULL);
386
387 /* TODO: no error checking yet on api V1 */
388 if (h->jtag_api == STLINK_JTAG_API_V1)
389 h->databuf[0] = STLINK_DEBUG_ERR_OK;
390
391 switch (h->databuf[0]) {
392 case STLINK_DEBUG_ERR_OK:
393 return ERROR_OK;
394 case STLINK_DEBUG_ERR_FAULT:
395 LOG_DEBUG("SWD fault response (0x%x)", STLINK_DEBUG_ERR_FAULT);
396 return ERROR_FAIL;
397 case STLINK_SWD_AP_WAIT:
398 LOG_DEBUG("wait status SWD_AP_WAIT (0x%x)", STLINK_SWD_AP_WAIT);
399 return ERROR_WAIT;
400 case STLINK_SWD_DP_WAIT:
401 LOG_DEBUG("wait status SWD_DP_WAIT (0x%x)", STLINK_SWD_DP_WAIT);
402 return ERROR_WAIT;
403 case STLINK_JTAG_WRITE_ERROR:
404 LOG_DEBUG("Write error");
405 return ERROR_FAIL;
406 case STLINK_JTAG_WRITE_VERIF_ERROR:
407 LOG_DEBUG("Verify error");
408 return ERROR_FAIL;
409 case STLINK_SWD_AP_FAULT:
410 /* git://git.ac6.fr/openocd commit 657e3e885b9ee10
411 * returns ERROR_OK with the comment:
412 * Change in error status when reading outside RAM.
413 * This fix allows CDT plugin to visualize memory.
414 */
415 LOG_DEBUG("STLINK_SWD_AP_FAULT");
416 return ERROR_FAIL;
417 case STLINK_SWD_AP_ERROR:
418 LOG_DEBUG("STLINK_SWD_AP_ERROR");
419 return ERROR_FAIL;
420 case STLINK_SWD_AP_PARITY_ERROR:
421 LOG_DEBUG("STLINK_SWD_AP_PARITY_ERROR");
422 return ERROR_FAIL;
423 case STLINK_SWD_DP_FAULT:
424 LOG_DEBUG("STLINK_SWD_DP_FAULT");
425 return ERROR_FAIL;
426 case STLINK_SWD_DP_ERROR:
427 LOG_DEBUG("STLINK_SWD_DP_ERROR");
428 return ERROR_FAIL;
429 case STLINK_SWD_DP_PARITY_ERROR:
430 LOG_DEBUG("STLINK_SWD_DP_PARITY_ERROR");
431 return ERROR_FAIL;
432 case STLINK_SWD_AP_WDATA_ERROR:
433 LOG_DEBUG("STLINK_SWD_AP_WDATA_ERROR");
434 return ERROR_FAIL;
435 case STLINK_SWD_AP_STICKY_ERROR:
436 LOG_DEBUG("STLINK_SWD_AP_STICKY_ERROR");
437 return ERROR_FAIL;
438 case STLINK_SWD_AP_STICKYORUN_ERROR:
439 LOG_DEBUG("STLINK_SWD_AP_STICKYORUN_ERROR");
440 return ERROR_FAIL;
441 default:
442 LOG_DEBUG("unknown/unexpected STLINK status code 0x%x", h->databuf[0]);
443 return ERROR_FAIL;
444 }
445 }
446
447
448 /** Issue an STLINK command via USB transfer, with retries on any wait status responses.
449
450 Works for commands where the STLINK_DEBUG status is returned in the first
451 byte of the response packet.
452
453 Returns an openocd result code.
454 */
455 static int stlink_cmd_allow_retry(void *handle, const uint8_t *buf, int size)
456 {
457 int retries = 0;
458 int res;
459 while (1) {
460 res = stlink_usb_xfer(handle, buf, size);
461 if (res != ERROR_OK)
462 return res;
463 res = stlink_usb_error_check(handle);
464 if (res == ERROR_WAIT && retries < MAX_WAIT_RETRIES) {
465 usleep((1<<retries++) * 1000);
466 continue;
467 }
468 return res;
469 }
470 }
471
472 /** */
473 static int stlink_usb_read_trace(void *handle, const uint8_t *buf, int size)
474 {
475 struct stlink_usb_handle_s *h = handle;
476
477 assert(handle != NULL);
478
479 assert(h->version.stlink >= 2);
480
481 if (jtag_libusb_bulk_read(h->fd, h->trace_ep, (char *)buf,
482 size, STLINK_READ_TIMEOUT) != size) {
483 LOG_ERROR("bulk trace read failed");
484 return ERROR_FAIL;
485 }
486
487 return ERROR_OK;
488 }
489
490 /** */
491 static void stlink_usb_xfer_v1_create_cmd(void *handle, uint8_t direction, uint32_t size)
492 {
493 struct stlink_usb_handle_s *h = handle;
494
495 /* fill the send buffer */
496 strcpy((char *)h->cmdbuf, "USBC");
497 h->cmdidx += 4;
498 /* csw tag not used */
499 h->cmdidx += 4;
500 buf_set_u32(h->cmdbuf+h->cmdidx, 0, 32, size);
501 h->cmdidx += 4;
502 h->cmdbuf[h->cmdidx++] = (direction == h->rx_ep ? ENDPOINT_IN : ENDPOINT_OUT);
503 h->cmdbuf[h->cmdidx++] = 0; /* lun */
504 h->cmdbuf[h->cmdidx++] = STLINK_CMD_SIZE_V1;
505 }
506
507 /** */
508 static void stlink_usb_init_buffer(void *handle, uint8_t direction, uint32_t size)
509 {
510 struct stlink_usb_handle_s *h = handle;
511
512 h->direction = direction;
513
514 h->cmdidx = 0;
515
516 memset(h->cmdbuf, 0, STLINK_SG_SIZE);
517 memset(h->databuf, 0, STLINK_DATA_SIZE);
518
519 if (h->version.stlink == 1)
520 stlink_usb_xfer_v1_create_cmd(handle, direction, size);
521 }
522
523 /** */
524 static int stlink_usb_version(void *handle)
525 {
526 int res;
527 uint16_t v;
528 struct stlink_usb_handle_s *h = handle;
529
530 assert(handle != NULL);
531
532 stlink_usb_init_buffer(handle, h->rx_ep, 6);
533
534 h->cmdbuf[h->cmdidx++] = STLINK_GET_VERSION;
535
536 res = stlink_usb_xfer(handle, h->databuf, 6);
537
538 if (res != ERROR_OK)
539 return res;
540
541 v = (h->databuf[0] << 8) | h->databuf[1];
542
543 h->version.stlink = (v >> 12) & 0x0f;
544 h->version.jtag = (v >> 6) & 0x3f;
545 h->version.swim = v & 0x3f;
546 h->vid = buf_get_u32(h->databuf, 16, 16);
547 h->pid = buf_get_u32(h->databuf, 32, 16);
548
549 /* set the supported jtag api version
550 * API V2 is supported since JTAG V11
551 */
552 if (h->version.jtag >= 11)
553 h->version.jtag_api_max = STLINK_JTAG_API_V2;
554 else
555 h->version.jtag_api_max = STLINK_JTAG_API_V1;
556
557 LOG_INFO("STLINK v%d JTAG v%d API v%d SWIM v%d VID 0x%04X PID 0x%04X",
558 h->version.stlink,
559 h->version.jtag,
560 (h->version.jtag_api_max == STLINK_JTAG_API_V1) ? 1 : 2,
561 h->version.swim,
562 h->vid,
563 h->pid);
564
565 return ERROR_OK;
566 }
567
568 static int stlink_usb_check_voltage(void *handle, float *target_voltage)
569 {
570 struct stlink_usb_handle_s *h = handle;
571 uint32_t adc_results[2];
572
573 /* only supported by stlink/v2 and for firmware >= 13 */
574 if (h->version.stlink == 1 || h->version.jtag < 13)
575 return ERROR_COMMAND_NOTFOUND;
576
577 stlink_usb_init_buffer(handle, h->rx_ep, 8);
578
579 h->cmdbuf[h->cmdidx++] = STLINK_GET_TARGET_VOLTAGE;
580
581 int result = stlink_usb_xfer(handle, h->databuf, 8);
582
583 if (result != ERROR_OK)
584 return result;
585
586 /* convert result */
587 adc_results[0] = le_to_h_u32(h->databuf);
588 adc_results[1] = le_to_h_u32(h->databuf + 4);
589
590 *target_voltage = 0;
591
592 if (adc_results[0])
593 *target_voltage = 2 * ((float)adc_results[1]) * (float)(1.2 / adc_results[0]);
594
595 LOG_INFO("Target voltage: %f", (double)*target_voltage);
596
597 return ERROR_OK;
598 }
599
600 static int stlink_usb_set_swdclk(void *handle, uint16_t clk_divisor)
601 {
602 struct stlink_usb_handle_s *h = handle;
603
604 assert(handle != NULL);
605
606 /* only supported by stlink/v2 and for firmware >= 22 */
607 if (h->version.stlink == 1 || h->version.jtag < 22)
608 return ERROR_COMMAND_NOTFOUND;
609
610 stlink_usb_init_buffer(handle, h->rx_ep, 2);
611
612 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
613 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_SWD_SET_FREQ;
614 h_u16_to_le(h->cmdbuf+h->cmdidx, clk_divisor);
615 h->cmdidx += 2;
616
617 int result = stlink_cmd_allow_retry(handle, h->databuf, 2);
618
619 if (result != ERROR_OK)
620 return result;
621
622 return ERROR_OK;
623 }
624
625 /** */
626 static int stlink_usb_current_mode(void *handle, uint8_t *mode)
627 {
628 int res;
629 struct stlink_usb_handle_s *h = handle;
630
631 assert(handle != NULL);
632
633 stlink_usb_init_buffer(handle, h->rx_ep, 2);
634
635 h->cmdbuf[h->cmdidx++] = STLINK_GET_CURRENT_MODE;
636
637 res = stlink_usb_xfer(handle, h->databuf, 2);
638
639 if (res != ERROR_OK)
640 return res;
641
642 *mode = h->databuf[0];
643
644 return ERROR_OK;
645 }
646
647 /** */
648 static int stlink_usb_mode_enter(void *handle, enum stlink_mode type)
649 {
650 int rx_size = 0;
651 struct stlink_usb_handle_s *h = handle;
652
653 assert(handle != NULL);
654
655 /* on api V2 we are able the read the latest command
656 * status
657 * TODO: we need the test on api V1 too
658 */
659 if (h->jtag_api == STLINK_JTAG_API_V2)
660 rx_size = 2;
661
662 stlink_usb_init_buffer(handle, h->rx_ep, rx_size);
663
664 switch (type) {
665 case STLINK_MODE_DEBUG_JTAG:
666 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
667 if (h->jtag_api == STLINK_JTAG_API_V1)
668 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_ENTER;
669 else
670 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_ENTER;
671 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_ENTER_JTAG;
672 break;
673 case STLINK_MODE_DEBUG_SWD:
674 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
675 if (h->jtag_api == STLINK_JTAG_API_V1)
676 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_ENTER;
677 else
678 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_ENTER;
679 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_ENTER_SWD;
680 break;
681 case STLINK_MODE_DEBUG_SWIM:
682 h->cmdbuf[h->cmdidx++] = STLINK_SWIM_COMMAND;
683 h->cmdbuf[h->cmdidx++] = STLINK_SWIM_ENTER;
684 break;
685 case STLINK_MODE_DFU:
686 case STLINK_MODE_MASS:
687 default:
688 return ERROR_FAIL;
689 }
690
691 return stlink_cmd_allow_retry(handle, h->databuf, rx_size);
692 }
693
694 /** */
695 static int stlink_usb_mode_leave(void *handle, enum stlink_mode type)
696 {
697 int res;
698 struct stlink_usb_handle_s *h = handle;
699
700 assert(handle != NULL);
701
702 stlink_usb_init_buffer(handle, STLINK_NULL_EP, 0);
703
704 switch (type) {
705 case STLINK_MODE_DEBUG_JTAG:
706 case STLINK_MODE_DEBUG_SWD:
707 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
708 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_EXIT;
709 break;
710 case STLINK_MODE_DEBUG_SWIM:
711 h->cmdbuf[h->cmdidx++] = STLINK_SWIM_COMMAND;
712 h->cmdbuf[h->cmdidx++] = STLINK_SWIM_EXIT;
713 break;
714 case STLINK_MODE_DFU:
715 h->cmdbuf[h->cmdidx++] = STLINK_DFU_COMMAND;
716 h->cmdbuf[h->cmdidx++] = STLINK_DFU_EXIT;
717 break;
718 case STLINK_MODE_MASS:
719 default:
720 return ERROR_FAIL;
721 }
722
723 res = stlink_usb_xfer(handle, 0, 0);
724
725 if (res != ERROR_OK)
726 return res;
727
728 return ERROR_OK;
729 }
730
731 static int stlink_usb_assert_srst(void *handle, int srst);
732
733 static enum stlink_mode stlink_get_mode(enum hl_transports t)
734 {
735 switch (t) {
736 case HL_TRANSPORT_SWD:
737 return STLINK_MODE_DEBUG_SWD;
738 case HL_TRANSPORT_JTAG:
739 return STLINK_MODE_DEBUG_JTAG;
740 case HL_TRANSPORT_SWIM:
741 return STLINK_MODE_DEBUG_SWIM;
742 default:
743 return STLINK_MODE_UNKNOWN;
744 }
745 }
746
747 /** */
748 static int stlink_usb_init_mode(void *handle, bool connect_under_reset)
749 {
750 int res;
751 uint8_t mode;
752 enum stlink_mode emode;
753 struct stlink_usb_handle_s *h = handle;
754
755 assert(handle != NULL);
756
757 res = stlink_usb_current_mode(handle, &mode);
758
759 if (res != ERROR_OK)
760 return res;
761
762 LOG_DEBUG("MODE: 0x%02X", mode);
763
764 /* try to exit current mode */
765 switch (mode) {
766 case STLINK_DEV_DFU_MODE:
767 emode = STLINK_MODE_DFU;
768 break;
769 case STLINK_DEV_DEBUG_MODE:
770 emode = STLINK_MODE_DEBUG_SWD;
771 break;
772 case STLINK_DEV_SWIM_MODE:
773 emode = STLINK_MODE_DEBUG_SWIM;
774 break;
775 case STLINK_DEV_BOOTLOADER_MODE:
776 case STLINK_DEV_MASS_MODE:
777 default:
778 emode = STLINK_MODE_UNKNOWN;
779 break;
780 }
781
782 if (emode != STLINK_MODE_UNKNOWN) {
783 res = stlink_usb_mode_leave(handle, emode);
784
785 if (res != ERROR_OK)
786 return res;
787 }
788
789 res = stlink_usb_current_mode(handle, &mode);
790
791 if (res != ERROR_OK)
792 return res;
793
794 /* we check the target voltage here as an aid to debugging connection problems.
795 * the stlink requires the target Vdd to be connected for reliable debugging.
796 * this cmd is supported in all modes except DFU
797 */
798 if (mode != STLINK_DEV_DFU_MODE) {
799
800 float target_voltage;
801
802 /* check target voltage (if supported) */
803 res = stlink_usb_check_voltage(h, &target_voltage);
804
805 if (res != ERROR_OK) {
806 if (res != ERROR_COMMAND_NOTFOUND)
807 LOG_ERROR("voltage check failed");
808 /* attempt to continue as it is not a catastrophic failure */
809 } else {
810 /* check for a sensible target voltage, operating range is 1.65-5.5v
811 * according to datasheet */
812 if (target_voltage < 1.5)
813 LOG_ERROR("target voltage may be too low for reliable debugging");
814 }
815 }
816
817 LOG_DEBUG("MODE: 0x%02X", mode);
818
819 /* set selected mode */
820 emode = stlink_get_mode(h->transport);
821
822 if (emode == STLINK_MODE_UNKNOWN) {
823 LOG_ERROR("selected mode (transport) not supported");
824 return ERROR_FAIL;
825 }
826
827 if (connect_under_reset) {
828 res = stlink_usb_assert_srst(handle, 0);
829 if (res != ERROR_OK)
830 return res;
831 }
832
833 res = stlink_usb_mode_enter(handle, emode);
834
835 if (res != ERROR_OK)
836 return res;
837
838 res = stlink_usb_current_mode(handle, &mode);
839
840 if (res != ERROR_OK)
841 return res;
842
843 LOG_DEBUG("MODE: 0x%02X", mode);
844
845 return ERROR_OK;
846 }
847
848 /** */
849 static int stlink_usb_idcode(void *handle, uint32_t *idcode)
850 {
851 int res;
852 struct stlink_usb_handle_s *h = handle;
853
854 assert(handle != NULL);
855
856 stlink_usb_init_buffer(handle, h->rx_ep, 4);
857
858 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
859 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READCOREID;
860
861 res = stlink_usb_xfer(handle, h->databuf, 4);
862
863 if (res != ERROR_OK)
864 return res;
865
866 *idcode = le_to_h_u32(h->databuf);
867
868 LOG_DEBUG("IDCODE: 0x%08" PRIX32, *idcode);
869
870 return ERROR_OK;
871 }
872
873 static int stlink_usb_v2_read_debug_reg(void *handle, uint32_t addr, uint32_t *val)
874 {
875 struct stlink_usb_handle_s *h = handle;
876 int res;
877
878 assert(handle != NULL);
879
880 stlink_usb_init_buffer(handle, h->rx_ep, 8);
881
882 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
883 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_READDEBUGREG;
884 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
885 h->cmdidx += 4;
886
887 res = stlink_cmd_allow_retry(handle, h->databuf, 8);
888 if (res != ERROR_OK)
889 return res;
890
891 *val = le_to_h_u32(h->databuf + 4);
892 return ERROR_OK;
893 }
894
895 static int stlink_usb_write_debug_reg(void *handle, uint32_t addr, uint32_t val)
896 {
897 struct stlink_usb_handle_s *h = handle;
898
899 assert(handle != NULL);
900
901 stlink_usb_init_buffer(handle, h->rx_ep, 2);
902
903 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
904 if (h->jtag_api == STLINK_JTAG_API_V1)
905 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_WRITEDEBUGREG;
906 else
907 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_WRITEDEBUGREG;
908 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
909 h->cmdidx += 4;
910 h_u32_to_le(h->cmdbuf+h->cmdidx, val);
911 h->cmdidx += 4;
912
913 return stlink_cmd_allow_retry(handle, h->databuf, 2);
914 }
915
916 /** */
917 static int stlink_usb_trace_read(void *handle, uint8_t *buf, size_t *size)
918 {
919 struct stlink_usb_handle_s *h = handle;
920
921 assert(handle != NULL);
922
923 if (h->trace.enabled && h->version.jtag >= STLINK_TRACE_MIN_VERSION) {
924 int res;
925
926 stlink_usb_init_buffer(handle, h->rx_ep, 10);
927
928 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
929 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_GET_TRACE_NB;
930
931 res = stlink_usb_xfer(handle, h->databuf, 2);
932 if (res != ERROR_OK)
933 return res;
934
935 size_t bytes_avail = le_to_h_u16(h->databuf);
936 *size = bytes_avail < *size ? bytes_avail : *size - 1;
937
938 if (*size > 0) {
939 res = stlink_usb_read_trace(handle, buf, *size);
940 if (res != ERROR_OK)
941 return res;
942 return ERROR_OK;
943 }
944 }
945 *size = 0;
946 return ERROR_OK;
947 }
948
949 static enum target_state stlink_usb_v2_get_status(void *handle)
950 {
951 int result;
952 uint32_t status;
953
954 result = stlink_usb_v2_read_debug_reg(handle, DCB_DHCSR, &status);
955 if (result != ERROR_OK)
956 return TARGET_UNKNOWN;
957
958 if (status & S_HALT)
959 return TARGET_HALTED;
960 else if (status & S_RESET_ST)
961 return TARGET_RESET;
962
963 return TARGET_RUNNING;
964 }
965
966 /** */
967 static enum target_state stlink_usb_state(void *handle)
968 {
969 int res;
970 struct stlink_usb_handle_s *h = handle;
971
972 assert(handle != NULL);
973
974 if (h->reconnect_pending) {
975 LOG_INFO("Previous state query failed, trying to reconnect");
976 res = stlink_usb_mode_enter(handle, stlink_get_mode(h->transport));
977
978 if (res != ERROR_OK)
979 return TARGET_UNKNOWN;
980
981 h->reconnect_pending = false;
982 }
983
984 if (h->jtag_api == STLINK_JTAG_API_V2) {
985 res = stlink_usb_v2_get_status(handle);
986 if (res == TARGET_UNKNOWN)
987 h->reconnect_pending = true;
988 return res;
989 }
990
991 stlink_usb_init_buffer(handle, h->rx_ep, 2);
992
993 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
994 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_GETSTATUS;
995
996 res = stlink_usb_xfer(handle, h->databuf, 2);
997
998 if (res != ERROR_OK)
999 return TARGET_UNKNOWN;
1000
1001 if (h->databuf[0] == STLINK_CORE_RUNNING)
1002 return TARGET_RUNNING;
1003 if (h->databuf[0] == STLINK_CORE_HALTED)
1004 return TARGET_HALTED;
1005
1006 h->reconnect_pending = true;
1007
1008 return TARGET_UNKNOWN;
1009 }
1010
1011 static int stlink_usb_assert_srst(void *handle, int srst)
1012 {
1013 struct stlink_usb_handle_s *h = handle;
1014
1015 assert(handle != NULL);
1016
1017 if (h->version.stlink == 1)
1018 return ERROR_COMMAND_NOTFOUND;
1019
1020 stlink_usb_init_buffer(handle, h->rx_ep, 2);
1021
1022 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1023 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_DRIVE_NRST;
1024 h->cmdbuf[h->cmdidx++] = srst;
1025
1026 return stlink_cmd_allow_retry(handle, h->databuf, 2);
1027 }
1028
1029 /** */
1030 static void stlink_usb_trace_disable(void *handle)
1031 {
1032 int res = ERROR_OK;
1033 struct stlink_usb_handle_s *h = handle;
1034
1035 assert(handle != NULL);
1036
1037 assert(h->version.jtag >= STLINK_TRACE_MIN_VERSION);
1038
1039 LOG_DEBUG("Tracing: disable");
1040
1041 stlink_usb_init_buffer(handle, h->rx_ep, 2);
1042 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1043 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_STOP_TRACE_RX;
1044 res = stlink_usb_xfer(handle, h->databuf, 2);
1045
1046 if (res == ERROR_OK)
1047 h->trace.enabled = false;
1048 }
1049
1050
1051 /** */
1052 static int stlink_usb_trace_enable(void *handle)
1053 {
1054 int res;
1055 struct stlink_usb_handle_s *h = handle;
1056
1057 assert(handle != NULL);
1058
1059 if (h->version.jtag >= STLINK_TRACE_MIN_VERSION) {
1060 stlink_usb_init_buffer(handle, h->rx_ep, 10);
1061
1062 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1063 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_START_TRACE_RX;
1064 h_u16_to_le(h->cmdbuf+h->cmdidx, (uint16_t)STLINK_TRACE_SIZE);
1065 h->cmdidx += 2;
1066 h_u32_to_le(h->cmdbuf+h->cmdidx, h->trace.source_hz);
1067 h->cmdidx += 4;
1068
1069 res = stlink_usb_xfer(handle, h->databuf, 2);
1070
1071 if (res == ERROR_OK) {
1072 h->trace.enabled = true;
1073 LOG_DEBUG("Tracing: recording at %" PRIu32 "Hz", h->trace.source_hz);
1074 }
1075 } else {
1076 LOG_ERROR("Tracing is not supported by this version.");
1077 res = ERROR_FAIL;
1078 }
1079
1080 return res;
1081 }
1082
1083 /** */
1084 static int stlink_usb_reset(void *handle)
1085 {
1086 struct stlink_usb_handle_s *h = handle;
1087 int retval;
1088
1089 assert(handle != NULL);
1090
1091 stlink_usb_init_buffer(handle, h->rx_ep, 2);
1092
1093 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1094
1095 if (h->jtag_api == STLINK_JTAG_API_V1)
1096 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_RESETSYS;
1097 else
1098 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_RESETSYS;
1099
1100 retval = stlink_cmd_allow_retry(handle, h->databuf, 2);
1101 if (retval != ERROR_OK)
1102 return retval;
1103
1104 if (h->trace.enabled) {
1105 stlink_usb_trace_disable(h);
1106 return stlink_usb_trace_enable(h);
1107 }
1108
1109 return ERROR_OK;
1110 }
1111
1112 /** */
1113 static int stlink_usb_run(void *handle)
1114 {
1115 int res;
1116 struct stlink_usb_handle_s *h = handle;
1117
1118 assert(handle != NULL);
1119
1120 if (h->jtag_api == STLINK_JTAG_API_V2) {
1121 res = stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_DEBUGEN);
1122
1123 return res;
1124 }
1125
1126 stlink_usb_init_buffer(handle, h->rx_ep, 2);
1127
1128 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1129 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_RUNCORE;
1130
1131 return stlink_cmd_allow_retry(handle, h->databuf, 2);
1132 }
1133
1134 /** */
1135 static int stlink_usb_halt(void *handle)
1136 {
1137 int res;
1138 struct stlink_usb_handle_s *h = handle;
1139
1140 assert(handle != NULL);
1141
1142 if (h->jtag_api == STLINK_JTAG_API_V2) {
1143 res = stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_HALT|C_DEBUGEN);
1144
1145 return res;
1146 }
1147
1148 stlink_usb_init_buffer(handle, h->rx_ep, 2);
1149
1150 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1151 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_FORCEDEBUG;
1152
1153 return stlink_cmd_allow_retry(handle, h->databuf, 2);
1154 }
1155
1156 /** */
1157 static int stlink_usb_step(void *handle)
1158 {
1159 struct stlink_usb_handle_s *h = handle;
1160
1161 assert(handle != NULL);
1162
1163 if (h->jtag_api == STLINK_JTAG_API_V2) {
1164 /* TODO: this emulates the v1 api, it should really use a similar auto mask isr
1165 * that the Cortex-M3 currently does. */
1166 stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_HALT|C_MASKINTS|C_DEBUGEN);
1167 stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_STEP|C_MASKINTS|C_DEBUGEN);
1168 return stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_HALT|C_DEBUGEN);
1169 }
1170
1171 stlink_usb_init_buffer(handle, h->rx_ep, 2);
1172
1173 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1174 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_STEPCORE;
1175
1176 return stlink_cmd_allow_retry(handle, h->databuf, 2);
1177 }
1178
1179 /** */
1180 static int stlink_usb_read_regs(void *handle)
1181 {
1182 int res;
1183 struct stlink_usb_handle_s *h = handle;
1184
1185 assert(handle != NULL);
1186
1187 stlink_usb_init_buffer(handle, h->rx_ep, 84);
1188
1189 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1190 if (h->jtag_api == STLINK_JTAG_API_V1)
1191 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_READALLREGS;
1192 else
1193 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_READALLREGS;
1194
1195 res = stlink_usb_xfer(handle, h->databuf, 84);
1196
1197 if (res != ERROR_OK)
1198 return res;
1199
1200 return ERROR_OK;
1201 }
1202
1203 /** */
1204 static int stlink_usb_read_reg(void *handle, int num, uint32_t *val)
1205 {
1206 int res;
1207 struct stlink_usb_handle_s *h = handle;
1208
1209 assert(handle != NULL);
1210
1211 stlink_usb_init_buffer(handle, h->rx_ep, h->jtag_api == STLINK_JTAG_API_V1 ? 4 : 8);
1212
1213 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1214 if (h->jtag_api == STLINK_JTAG_API_V1)
1215 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_READREG;
1216 else
1217 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_READREG;
1218 h->cmdbuf[h->cmdidx++] = num;
1219
1220 if (h->jtag_api == STLINK_JTAG_API_V1) {
1221 res = stlink_usb_xfer(handle, h->databuf, 4);
1222 if (res != ERROR_OK)
1223 return res;
1224 *val = le_to_h_u32(h->databuf);
1225 return ERROR_OK;
1226 } else {
1227 res = stlink_cmd_allow_retry(handle, h->databuf, 8);
1228 if (res != ERROR_OK)
1229 return res;
1230 *val = le_to_h_u32(h->databuf + 4);
1231 return ERROR_OK;
1232 }
1233 }
1234
1235 /** */
1236 static int stlink_usb_write_reg(void *handle, int num, uint32_t val)
1237 {
1238 struct stlink_usb_handle_s *h = handle;
1239
1240 assert(handle != NULL);
1241
1242 stlink_usb_init_buffer(handle, h->rx_ep, 2);
1243
1244 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1245 if (h->jtag_api == STLINK_JTAG_API_V1)
1246 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_WRITEREG;
1247 else
1248 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_WRITEREG;
1249 h->cmdbuf[h->cmdidx++] = num;
1250 h_u32_to_le(h->cmdbuf+h->cmdidx, val);
1251 h->cmdidx += 4;
1252
1253 return stlink_cmd_allow_retry(handle, h->databuf, 2);
1254 }
1255
1256 static int stlink_usb_get_rw_status(void *handle)
1257 {
1258 int res;
1259 struct stlink_usb_handle_s *h = handle;
1260
1261 assert(handle != NULL);
1262
1263 if (h->jtag_api == STLINK_JTAG_API_V1)
1264 return ERROR_OK;
1265
1266 stlink_usb_init_buffer(handle, h->rx_ep, 2);
1267
1268 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1269 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_GETLASTRWSTATUS;
1270
1271 res = stlink_usb_xfer(handle, h->databuf, 2);
1272
1273 if (res != ERROR_OK)
1274 return res;
1275
1276 return stlink_usb_error_check(h);
1277 }
1278
1279 /** */
1280 static int stlink_usb_read_mem8(void *handle, uint32_t addr, uint16_t len,
1281 uint8_t *buffer)
1282 {
1283 int res;
1284 uint16_t read_len = len;
1285 struct stlink_usb_handle_s *h = handle;
1286
1287 assert(handle != NULL);
1288
1289 /* max 8bit read/write is 64bytes */
1290 if (len > STLINK_MAX_RW8) {
1291 LOG_DEBUG("max buffer length exceeded");
1292 return ERROR_FAIL;
1293 }
1294
1295 stlink_usb_init_buffer(handle, h->rx_ep, read_len);
1296
1297 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1298 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READMEM_8BIT;
1299 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
1300 h->cmdidx += 4;
1301 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
1302 h->cmdidx += 2;
1303
1304 /* we need to fix read length for single bytes */
1305 if (read_len == 1)
1306 read_len++;
1307
1308 res = stlink_usb_xfer(handle, h->databuf, read_len);
1309
1310 if (res != ERROR_OK)
1311 return res;
1312
1313 memcpy(buffer, h->databuf, len);
1314
1315 return stlink_usb_get_rw_status(handle);
1316 }
1317
1318 /** */
1319 static int stlink_usb_write_mem8(void *handle, uint32_t addr, uint16_t len,
1320 const uint8_t *buffer)
1321 {
1322 int res;
1323 struct stlink_usb_handle_s *h = handle;
1324
1325 assert(handle != NULL);
1326
1327 /* max 8bit read/write is 64bytes */
1328 if (len > STLINK_MAX_RW8) {
1329 LOG_DEBUG("max buffer length exceeded");
1330 return ERROR_FAIL;
1331 }
1332
1333 stlink_usb_init_buffer(handle, h->tx_ep, len);
1334
1335 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1336 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_WRITEMEM_8BIT;
1337 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
1338 h->cmdidx += 4;
1339 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
1340 h->cmdidx += 2;
1341
1342 res = stlink_usb_xfer(handle, buffer, len);
1343
1344 if (res != ERROR_OK)
1345 return res;
1346
1347 return stlink_usb_get_rw_status(handle);
1348 }
1349
1350 /** */
1351 static int stlink_usb_read_mem32(void *handle, uint32_t addr, uint16_t len,
1352 uint8_t *buffer)
1353 {
1354 int res;
1355 struct stlink_usb_handle_s *h = handle;
1356
1357 assert(handle != NULL);
1358
1359 /* data must be a multiple of 4 and word aligned */
1360 if (len % 4 || addr % 4) {
1361 LOG_DEBUG("Invalid data alignment");
1362 return ERROR_TARGET_UNALIGNED_ACCESS;
1363 }
1364
1365 stlink_usb_init_buffer(handle, h->rx_ep, len);
1366
1367 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1368 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READMEM_32BIT;
1369 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
1370 h->cmdidx += 4;
1371 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
1372 h->cmdidx += 2;
1373
1374 res = stlink_usb_xfer(handle, h->databuf, len);
1375
1376 if (res != ERROR_OK)
1377 return res;
1378
1379 memcpy(buffer, h->databuf, len);
1380
1381 return stlink_usb_get_rw_status(handle);
1382 }
1383
1384 /** */
1385 static int stlink_usb_write_mem32(void *handle, uint32_t addr, uint16_t len,
1386 const uint8_t *buffer)
1387 {
1388 int res;
1389 struct stlink_usb_handle_s *h = handle;
1390
1391 assert(handle != NULL);
1392
1393 /* data must be a multiple of 4 and word aligned */
1394 if (len % 4 || addr % 4) {
1395 LOG_DEBUG("Invalid data alignment");
1396 return ERROR_TARGET_UNALIGNED_ACCESS;
1397 }
1398
1399 stlink_usb_init_buffer(handle, h->tx_ep, len);
1400
1401 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1402 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_WRITEMEM_32BIT;
1403 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
1404 h->cmdidx += 4;
1405 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
1406 h->cmdidx += 2;
1407
1408 res = stlink_usb_xfer(handle, buffer, len);
1409
1410 if (res != ERROR_OK)
1411 return res;
1412
1413 return stlink_usb_get_rw_status(handle);
1414 }
1415
1416 static uint32_t stlink_max_block_size(uint32_t tar_autoincr_block, uint32_t address)
1417 {
1418 uint32_t max_tar_block = (tar_autoincr_block - ((tar_autoincr_block - 1) & address));
1419 if (max_tar_block == 0)
1420 max_tar_block = 4;
1421 return max_tar_block;
1422 }
1423
1424 static int stlink_usb_read_mem(void *handle, uint32_t addr, uint32_t size,
1425 uint32_t count, uint8_t *buffer)
1426 {
1427 int retval = ERROR_OK;
1428 uint32_t bytes_remaining;
1429 int retries = 0;
1430 struct stlink_usb_handle_s *h = handle;
1431
1432 /* calculate byte count */
1433 count *= size;
1434
1435 while (count) {
1436
1437 bytes_remaining = (size == 4) ? \
1438 stlink_max_block_size(h->max_mem_packet, addr) : STLINK_MAX_RW8;
1439
1440 if (count < bytes_remaining)
1441 bytes_remaining = count;
1442
1443 /* the stlink only supports 8/32bit memory read/writes
1444 * honour 32bit, all others will be handled as 8bit access */
1445 if (size == 4) {
1446
1447 /* When in jtag mode the stlink uses the auto-increment functinality.
1448 * However it expects us to pass the data correctly, this includes
1449 * alignment and any page boundaries. We already do this as part of the
1450 * adi_v5 implementation, but the stlink is a hla adapter and so this
1451 * needs implementiong manually.
1452 * currently this only affects jtag mode, according to ST they do single
1453 * access in SWD mode - but this may change and so we do it for both modes */
1454
1455 /* we first need to check for any unaligned bytes */
1456 if (addr % 4) {
1457
1458 uint32_t head_bytes = 4 - (addr % 4);
1459 retval = stlink_usb_read_mem8(handle, addr, head_bytes, buffer);
1460 if (retval == ERROR_WAIT && retries < MAX_WAIT_RETRIES) {
1461 usleep((1<<retries++) * 1000);
1462 continue;
1463 }
1464 if (retval != ERROR_OK)
1465 return retval;
1466 buffer += head_bytes;
1467 addr += head_bytes;
1468 count -= head_bytes;
1469 bytes_remaining -= head_bytes;
1470 }
1471
1472 if (bytes_remaining % 4)
1473 retval = stlink_usb_read_mem(handle, addr, 1, bytes_remaining, buffer);
1474 else
1475 retval = stlink_usb_read_mem32(handle, addr, bytes_remaining, buffer);
1476 } else
1477 retval = stlink_usb_read_mem8(handle, addr, bytes_remaining, buffer);
1478
1479 if (retval == ERROR_WAIT && retries < MAX_WAIT_RETRIES) {
1480 usleep((1<<retries++) * 1000);
1481 continue;
1482 }
1483 if (retval != ERROR_OK)
1484 return retval;
1485
1486 buffer += bytes_remaining;
1487 addr += bytes_remaining;
1488 count -= bytes_remaining;
1489 }
1490
1491 return retval;
1492 }
1493
1494 static int stlink_usb_write_mem(void *handle, uint32_t addr, uint32_t size,
1495 uint32_t count, const uint8_t *buffer)
1496 {
1497 int retval = ERROR_OK;
1498 uint32_t bytes_remaining;
1499 int retries = 0;
1500 struct stlink_usb_handle_s *h = handle;
1501
1502 /* calculate byte count */
1503 count *= size;
1504
1505 while (count) {
1506
1507 bytes_remaining = (size == 4) ? \
1508 stlink_max_block_size(h->max_mem_packet, addr) : STLINK_MAX_RW8;
1509
1510 if (count < bytes_remaining)
1511 bytes_remaining = count;
1512
1513 /* the stlink only supports 8/32bit memory read/writes
1514 * honour 32bit, all others will be handled as 8bit access */
1515 if (size == 4) {
1516
1517 /* When in jtag mode the stlink uses the auto-increment functinality.
1518 * However it expects us to pass the data correctly, this includes
1519 * alignment and any page boundaries. We already do this as part of the
1520 * adi_v5 implementation, but the stlink is a hla adapter and so this
1521 * needs implementiong manually.
1522 * currently this only affects jtag mode, according to ST they do single
1523 * access in SWD mode - but this may change and so we do it for both modes */
1524
1525 /* we first need to check for any unaligned bytes */
1526 if (addr % 4) {
1527
1528 uint32_t head_bytes = 4 - (addr % 4);
1529 retval = stlink_usb_write_mem8(handle, addr, head_bytes, buffer);
1530 if (retval == ERROR_WAIT && retries < MAX_WAIT_RETRIES) {
1531 usleep((1<<retries++) * 1000);
1532 continue;
1533 }
1534 if (retval != ERROR_OK)
1535 return retval;
1536 buffer += head_bytes;
1537 addr += head_bytes;
1538 count -= head_bytes;
1539 bytes_remaining -= head_bytes;
1540 }
1541
1542 if (bytes_remaining % 4)
1543 retval = stlink_usb_write_mem(handle, addr, 1, bytes_remaining, buffer);
1544 else
1545 retval = stlink_usb_write_mem32(handle, addr, bytes_remaining, buffer);
1546
1547 } else
1548 retval = stlink_usb_write_mem8(handle, addr, bytes_remaining, buffer);
1549 if (retval == ERROR_WAIT && retries < MAX_WAIT_RETRIES) {
1550 usleep((1<<retries++) * 1000);
1551 continue;
1552 }
1553 if (retval != ERROR_OK)
1554 return retval;
1555
1556 buffer += bytes_remaining;
1557 addr += bytes_remaining;
1558 count -= bytes_remaining;
1559 }
1560
1561 return retval;
1562 }
1563
1564 /** */
1565 static int stlink_usb_override_target(const char *targetname)
1566 {
1567 return !strcmp(targetname, "cortex_m");
1568 }
1569
1570 static int stlink_speed(void *handle, int khz, bool query)
1571 {
1572 unsigned i;
1573 int speed_index = -1;
1574 int speed_diff = INT_MAX;
1575 struct stlink_usb_handle_s *h = handle;
1576
1577 /* only supported by stlink/v2 and for firmware >= 22 */
1578 if (h && (h->version.stlink == 1 || h->version.jtag < 22))
1579 return khz;
1580
1581 for (i = 0; i < ARRAY_SIZE(stlink_khz_to_speed_map); i++) {
1582 if (khz == stlink_khz_to_speed_map[i].speed) {
1583 speed_index = i;
1584 break;
1585 } else {
1586 int current_diff = khz - stlink_khz_to_speed_map[i].speed;
1587 /* get abs value for comparison */
1588 current_diff = (current_diff > 0) ? current_diff : -current_diff;
1589 if ((current_diff < speed_diff) && khz >= stlink_khz_to_speed_map[i].speed) {
1590 speed_diff = current_diff;
1591 speed_index = i;
1592 }
1593 }
1594 }
1595
1596 bool match = true;
1597
1598 if (speed_index == -1) {
1599 /* this will only be here if we cannot match the slow speed.
1600 * use the slowest speed we support.*/
1601 speed_index = ARRAY_SIZE(stlink_khz_to_speed_map) - 1;
1602 match = false;
1603 } else if (i == ARRAY_SIZE(stlink_khz_to_speed_map))
1604 match = false;
1605
1606 if (!match && query) {
1607 LOG_INFO("Unable to match requested speed %d kHz, using %d kHz", \
1608 khz, stlink_khz_to_speed_map[speed_index].speed);
1609 }
1610
1611 if (h && !query) {
1612 int result = stlink_usb_set_swdclk(h, stlink_khz_to_speed_map[speed_index].speed_divisor);
1613 if (result != ERROR_OK) {
1614 LOG_ERROR("Unable to set adapter speed");
1615 return khz;
1616 }
1617 }
1618
1619 return stlink_khz_to_speed_map[speed_index].speed;
1620 }
1621
1622 /** */
1623 static int stlink_usb_close(void *handle)
1624 {
1625 struct stlink_usb_handle_s *h = handle;
1626
1627 if (h && h->fd)
1628 jtag_libusb_close(h->fd);
1629
1630 free(h);
1631
1632 return ERROR_OK;
1633 }
1634
1635 /** */
1636 static int stlink_usb_open(struct hl_interface_param_s *param, void **fd)
1637 {
1638 int err, retry_count = 1;
1639 struct stlink_usb_handle_s *h;
1640 enum stlink_jtag_api_version api;
1641
1642 LOG_DEBUG("stlink_usb_open");
1643
1644 h = calloc(1, sizeof(struct stlink_usb_handle_s));
1645
1646 if (h == 0) {
1647 LOG_DEBUG("malloc failed");
1648 return ERROR_FAIL;
1649 }
1650
1651 h->transport = param->transport;
1652
1653 const uint16_t vids[] = { param->vid, 0 };
1654 const uint16_t pids[] = { param->pid, 0 };
1655 const char *serial = param->serial;
1656
1657 LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x serial: %s",
1658 param->transport, param->vid, param->pid,
1659 param->serial ? param->serial : "");
1660
1661 /*
1662 On certain host USB configurations(e.g. MacBook Air)
1663 STLINKv2 dongle seems to have its FW in a funky state if,
1664 after plugging it in, you try to use openocd with it more
1665 then once (by launching and closing openocd). In cases like
1666 that initial attempt to read the FW info via
1667 stlink_usb_version will fail and the device has to be reset
1668 in order to become operational.
1669 */
1670 do {
1671 if (jtag_libusb_open(vids, pids, serial, &h->fd) != ERROR_OK) {
1672 LOG_ERROR("open failed");
1673 goto error_open;
1674 }
1675
1676 jtag_libusb_set_configuration(h->fd, 0);
1677
1678 if (jtag_libusb_claim_interface(h->fd, 0) != ERROR_OK) {
1679 LOG_DEBUG("claim interface failed");
1680 goto error_open;
1681 }
1682
1683 /* RX EP is common for all versions */
1684 h->rx_ep = STLINK_RX_EP;
1685
1686 /* wrap version for first read */
1687 switch (param->pid) {
1688 case STLINK_V1_PID:
1689 h->version.stlink = 1;
1690 h->tx_ep = STLINK_TX_EP;
1691 h->trace_ep = STLINK_TRACE_EP;
1692 break;
1693 case STLINK_V2_1_PID:
1694 h->version.stlink = 2;
1695 h->tx_ep = STLINK_V2_1_TX_EP;
1696 h->trace_ep = STLINK_V2_1_TRACE_EP;
1697 break;
1698 default:
1699 /* fall through - we assume V2 to be the default version*/
1700 case STLINK_V2_PID:
1701 h->version.stlink = 2;
1702 h->tx_ep = STLINK_TX_EP;
1703 h->trace_ep = STLINK_TRACE_EP;
1704 break;
1705 }
1706
1707 /* get the device version */
1708 err = stlink_usb_version(h);
1709
1710 if (err == ERROR_OK) {
1711 break;
1712 } else if (h->version.stlink == 1 ||
1713 retry_count == 0) {
1714 LOG_ERROR("read version failed");
1715 goto error_open;
1716 } else {
1717 err = jtag_libusb_release_interface(h->fd, 0);
1718 if (err != ERROR_OK) {
1719 LOG_ERROR("release interface failed");
1720 goto error_open;
1721 }
1722
1723 err = jtag_libusb_reset_device(h->fd);
1724 if (err != ERROR_OK) {
1725 LOG_ERROR("reset device failed");
1726 goto error_open;
1727 }
1728
1729 jtag_libusb_close(h->fd);
1730 /*
1731 Give the device one second to settle down and
1732 reenumerate.
1733 */
1734 usleep(1 * 1000 * 1000);
1735 retry_count--;
1736 }
1737 } while (1);
1738
1739 /* compare usb vid/pid */
1740 if ((param->vid != h->vid) || (param->pid != h->pid))
1741 LOG_INFO("vid/pid are not identical: 0x%04X/0x%04X 0x%04X/0x%04X",
1742 param->vid, param->pid,
1743 h->vid, h->pid);
1744
1745 /* check if mode is supported */
1746 err = ERROR_OK;
1747
1748 switch (h->transport) {
1749 case HL_TRANSPORT_SWD:
1750 case HL_TRANSPORT_JTAG:
1751 if (h->version.jtag == 0)
1752 err = ERROR_FAIL;
1753 break;
1754 case HL_TRANSPORT_SWIM:
1755 if (h->version.swim == 0)
1756 err = ERROR_FAIL;
1757 break;
1758 default:
1759 err = ERROR_FAIL;
1760 break;
1761 }
1762
1763 if (err != ERROR_OK) {
1764 LOG_ERROR("mode (transport) not supported by device");
1765 goto error_open;
1766 }
1767
1768 api = h->version.jtag_api_max;
1769
1770 LOG_INFO("using stlink api v%d", api);
1771
1772 /* set the used jtag api, this will default to the newest supported version */
1773 h->jtag_api = api;
1774
1775 /* initialize the debug hardware */
1776 err = stlink_usb_init_mode(h, param->connect_under_reset);
1777
1778 if (err != ERROR_OK) {
1779 LOG_ERROR("init mode failed (unable to connect to the target)");
1780 goto error_open;
1781 }
1782
1783 /* clock speed only supported by stlink/v2 and for firmware >= 22 */
1784 if (h->version.stlink >= 2 && h->version.jtag >= 22) {
1785 LOG_DEBUG("Supported clock speeds are:");
1786
1787 for (unsigned i = 0; i < ARRAY_SIZE(stlink_khz_to_speed_map); i++)
1788 LOG_DEBUG("%d kHz", stlink_khz_to_speed_map[i].speed);
1789
1790 stlink_speed(h, param->initial_interface_speed, false);
1791 }
1792
1793 /* get cpuid, so we can determine the max page size
1794 * start with a safe default */
1795 h->max_mem_packet = (1 << 10);
1796
1797 uint8_t buffer[4];
1798 err = stlink_usb_read_mem32(h, CPUID, 4, buffer);
1799 if (err == ERROR_OK) {
1800 uint32_t cpuid = le_to_h_u32(buffer);
1801 int i = (cpuid >> 4) & 0xf;
1802 if (i == 4 || i == 3) {
1803 /* Cortex-M3/M4 has 4096 bytes autoincrement range */
1804 h->max_mem_packet = (1 << 12);
1805 }
1806 }
1807
1808 LOG_DEBUG("Using TAR autoincrement: %" PRIu32, h->max_mem_packet);
1809
1810 *fd = h;
1811
1812 return ERROR_OK;
1813
1814 error_open:
1815 stlink_usb_close(h);
1816
1817 return ERROR_FAIL;
1818 }
1819
1820 int stlink_config_trace(void *handle, bool enabled, enum tpio_pin_protocol pin_protocol,
1821 uint32_t port_size, unsigned int *trace_freq)
1822 {
1823 struct stlink_usb_handle_s *h = handle;
1824
1825 if (enabled && (h->jtag_api < 2 || pin_protocol != ASYNC_UART)) {
1826 LOG_ERROR("The attached ST-LINK version doesn't support this trace mode");
1827 return ERROR_FAIL;
1828 }
1829
1830 if (!enabled) {
1831 stlink_usb_trace_disable(h);
1832 return ERROR_OK;
1833 }
1834
1835 if (*trace_freq > STLINK_TRACE_MAX_HZ) {
1836 LOG_ERROR("ST-LINK doesn't support SWO frequency higher than %u",
1837 STLINK_TRACE_MAX_HZ);
1838 return ERROR_FAIL;
1839 }
1840
1841 stlink_usb_trace_disable(h);
1842
1843 if (!*trace_freq)
1844 *trace_freq = STLINK_TRACE_MAX_HZ;
1845 h->trace.source_hz = *trace_freq;
1846
1847 return stlink_usb_trace_enable(h);
1848 }
1849
1850 /** */
1851 struct hl_layout_api_s stlink_usb_layout_api = {
1852 /** */
1853 .open = stlink_usb_open,
1854 /** */
1855 .close = stlink_usb_close,
1856 /** */
1857 .idcode = stlink_usb_idcode,
1858 /** */
1859 .state = stlink_usb_state,
1860 /** */
1861 .reset = stlink_usb_reset,
1862 /** */
1863 .assert_srst = stlink_usb_assert_srst,
1864 /** */
1865 .run = stlink_usb_run,
1866 /** */
1867 .halt = stlink_usb_halt,
1868 /** */
1869 .step = stlink_usb_step,
1870 /** */
1871 .read_regs = stlink_usb_read_regs,
1872 /** */
1873 .read_reg = stlink_usb_read_reg,
1874 /** */
1875 .write_reg = stlink_usb_write_reg,
1876 /** */
1877 .read_mem = stlink_usb_read_mem,
1878 /** */
1879 .write_mem = stlink_usb_write_mem,
1880 /** */
1881 .write_debug_reg = stlink_usb_write_debug_reg,
1882 /** */
1883 .override_target = stlink_usb_override_target,
1884 /** */
1885 .speed = stlink_speed,
1886 /** */
1887 .config_trace = stlink_config_trace,
1888 /** */
1889 .poll_trace = stlink_usb_trace_read,
1890 };
Official OpenOCD Mirror