?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
stlink: support stlink api result
[openocd/jflash.git] / src / jtag / drivers / stlink_usb.c
blobe373a27a19e7d5a5d6777ec01f92a7ab2ed5b01c
1 /***************************************************************************
2 * Copyright (C) 2011-2012 by Mathias Kuester *
3 * Mathias Kuester <kesmtp@freenet.de> *
4 * *
5 * This code is based on https://github.com/texane/stlink *
6 * *
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. *
11 * *
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. *
16 * *
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 ***************************************************************************/
22
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
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>
34
35 #include "libusb_common.h"
36
37 #define ENDPOINT_IN 0x80
38 #define ENDPOINT_OUT 0x00
39
40 #define STLINK_NULL_EP 0
41 #define STLINK_RX_EP (1|ENDPOINT_IN)
42 #define STLINK_TX_EP (2|ENDPOINT_OUT)
43 #define STLINK_SG_SIZE (31)
44 #define STLINK_DATA_SIZE (4*128)
45 #define STLINK_CMD_SIZE_V2 (16)
46 #define STLINK_CMD_SIZE_V1 (10)
47
48 enum stlink_jtag_api_version {
49 STLINK_JTAG_API_V1 = 0,
50 STLINK_JTAG_API_V2,
51 };
52
53 /** */
54 struct stlink_usb_version {
55 /** */
56 int stlink;
57 /** */
58 int jtag;
59 /** */
60 int swim;
61 /** highest supported jtag api version */
62 enum stlink_jtag_api_version jtag_api_max;
63 };
64
65 /** */
66 struct stlink_usb_handle_s {
67 /** */
68 struct jtag_libusb_device_handle *fd;
69 /** */
70 struct libusb_transfer *trans;
71 /** */
72 uint8_t cmdbuf[STLINK_SG_SIZE];
73 /** */
74 uint8_t cmdidx;
75 /** */
76 uint8_t direction;
77 /** */
78 uint8_t databuf[STLINK_DATA_SIZE];
79 /** */
80 enum stlink_transports transport;
81 /** */
82 struct stlink_usb_version version;
83 /** */
84 uint16_t vid;
85 /** */
86 uint16_t pid;
87 /** this is the currently used jtag api */
88 enum stlink_jtag_api_version jtag_api;
89 };
90
91 #define STLINK_DEBUG_ERR_OK 0x80
92 #define STLINK_DEBUG_ERR_FAULT 0x81
93 #define STLINK_CORE_RUNNING 0x80
94 #define STLINK_CORE_HALTED 0x81
95 #define STLINK_CORE_STAT_UNKNOWN -1
96
97 #define STLINK_GET_VERSION 0xF1
98 #define STLINK_DEBUG_COMMAND 0xF2
99 #define STLINK_DFU_COMMAND 0xF3
100 #define STLINK_SWIM_COMMAND 0xF4
101 #define STLINK_GET_CURRENT_MODE 0xF5
102
103 #define STLINK_DEV_DFU_MODE 0x00
104 #define STLINK_DEV_MASS_MODE 0x01
105 #define STLINK_DEV_DEBUG_MODE 0x02
106 #define STLINK_DEV_SWIM_MODE 0x03
107 #define STLINK_DEV_BOOTLOADER_MODE 0x04
108 #define STLINK_DEV_UNKNOWN_MODE -1
109
110 #define STLINK_DFU_EXIT 0x07
111
112 #define STLINK_SWIM_ENTER 0x00
113 #define STLINK_SWIM_EXIT 0x01
114
115 #define STLINK_DEBUG_ENTER_JTAG 0x00
116 #define STLINK_DEBUG_GETSTATUS 0x01
117 #define STLINK_DEBUG_FORCEDEBUG 0x02
118 #define STLINK_DEBUG_APIV1_RESETSYS 0x03
119 #define STLINK_DEBUG_APIV1_READALLREGS 0x04
120 #define STLINK_DEBUG_APIV1_READREG 0x05
121 #define STLINK_DEBUG_APIV1_WRITEREG 0x06
122 #define STLINK_DEBUG_READMEM_32BIT 0x07
123 #define STLINK_DEBUG_WRITEMEM_32BIT 0x08
124 #define STLINK_DEBUG_RUNCORE 0x09
125 #define STLINK_DEBUG_STEPCORE 0x0a
126 #define STLINK_DEBUG_APIV1_SETFP 0x0b
127 #define STLINK_DEBUG_READMEM_8BIT 0x0c
128 #define STLINK_DEBUG_WRITEMEM_8BIT 0x0d
129 #define STLINK_DEBUG_APIV1_CLEARFP 0x0e
130 #define STLINK_DEBUG_APIV1_WRITEDEBUGREG 0x0f
131 #define STLINK_DEBUG_APIV1_SETWATCHPOINT 0x10
132
133 #define STLINK_DEBUG_ENTER_JTAG 0x00
134 #define STLINK_DEBUG_ENTER_SWD 0xa3
135
136 #define STLINK_DEBUG_APIV1_ENTER 0x20
137 #define STLINK_DEBUG_EXIT 0x21
138 #define STLINK_DEBUG_READCOREID 0x22
139
140 #define STLINK_DEBUG_APIV2_ENTER 0x30
141 #define STLINK_DEBUG_APIV2_READ_IDCODES 0x31
142 #define STLINK_DEBUG_APIV2_RESETSYS 0x32
143 #define STLINK_DEBUG_APIV2_READREG 0x33
144 #define STLINK_DEBUG_APIV2_WRITEREG 0x34
145
146 #define STLINK_DEBUG_APIV2_READALLREGS 0x3A
147
148 #define STLINK_DEBUG_APIV2_DRIVE_NRST 0x3C
149
150 #define STLINK_DEBUG_APIV2_DRIVE_NRST_LOW 0x00
151 #define STLINK_DEBUG_APIV2_DRIVE_NRST_HIGH 0x01
152 #define STLINK_DEBUG_APIV2_DRIVE_NRST_PULSE 0x02
153
154 /** */
155 enum stlink_mode {
156 STLINK_MODE_UNKNOWN = 0,
157 STLINK_MODE_DFU,
158 STLINK_MODE_MASS,
159 STLINK_MODE_DEBUG_JTAG,
160 STLINK_MODE_DEBUG_SWD,
161 STLINK_MODE_DEBUG_SWIM
162 };
163
164 #define REQUEST_SENSE 0x03
165 #define REQUEST_SENSE_LENGTH 18
166
167 static void stlink_usb_init_buffer(void *handle, uint8_t direction, uint32_t size);
168
169 /** */
170 static int stlink_usb_xfer_v1_get_status(void *handle)
171 {
172 struct stlink_usb_handle_s *h;
173
174 assert(handle != NULL);
175
176 h = (struct stlink_usb_handle_s *)handle;
177
178 /* read status */
179 memset(h->cmdbuf, 0, STLINK_SG_SIZE);
180
181 if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)h->cmdbuf,
182 13, 1000) != 13)
183 return ERROR_FAIL;
184
185 uint32_t t1;
186
187 t1 = buf_get_u32(h->cmdbuf, 0, 32);
188
189 /* check for USBS */
190 if (t1 != 0x53425355)
191 return ERROR_FAIL;
192 /*
193 * CSW status:
194 * 0 success
195 * 1 command failure
196 * 2 phase error
197 */
198 if (h->cmdbuf[12] != 0)
199 return ERROR_FAIL;
200
201 return ERROR_OK;
202 }
203
204 /** */
205 static int stlink_usb_xfer_rw(void *handle, int cmdsize, const uint8_t *buf, int size)
206 {
207 struct stlink_usb_handle_s *h;
208
209 assert(handle != NULL);
210
211 h = (struct stlink_usb_handle_s *)handle;
212
213 if (jtag_libusb_bulk_write(h->fd, STLINK_TX_EP, (char *)h->cmdbuf, cmdsize,
214 1000) != cmdsize) {
215 return ERROR_FAIL;
216 }
217
218 if (h->direction == STLINK_TX_EP && size) {
219 if (jtag_libusb_bulk_write(h->fd, STLINK_TX_EP, (char *)buf,
220 size, 1000) != size) {
221 LOG_DEBUG("bulk write failed");
222 return ERROR_FAIL;
223 }
224 } else if (h->direction == STLINK_RX_EP && size) {
225 if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)buf,
226 size, 1000) != size) {
227 LOG_DEBUG("bulk read failed");
228 return ERROR_FAIL;
229 }
230 }
231
232 return ERROR_OK;
233 }
234
235 /** */
236 static int stlink_usb_xfer_v1_get_sense(void *handle)
237 {
238 int res;
239 struct stlink_usb_handle_s *h;
240
241 assert(handle != NULL);
242
243 h = (struct stlink_usb_handle_s *)handle;
244
245 stlink_usb_init_buffer(handle, STLINK_RX_EP, 16);
246
247 h->cmdbuf[h->cmdidx++] = REQUEST_SENSE;
248 h->cmdbuf[h->cmdidx++] = 0;
249 h->cmdbuf[h->cmdidx++] = 0;
250 h->cmdbuf[h->cmdidx++] = 0;
251 h->cmdbuf[h->cmdidx++] = REQUEST_SENSE_LENGTH;
252
253 res = stlink_usb_xfer_rw(handle, REQUEST_SENSE_LENGTH, h->databuf, 16);
254
255 if (res != ERROR_OK)
256 return res;
257
258 if (stlink_usb_xfer_v1_get_status(handle) != ERROR_OK)
259 return ERROR_FAIL;
260
261 return ERROR_OK;
262 }
263
264 /** */
265 static int stlink_usb_xfer(void *handle, const uint8_t *buf, int size)
266 {
267 int err, cmdsize = STLINK_CMD_SIZE_V2;
268 struct stlink_usb_handle_s *h;
269
270 assert(handle != NULL);
271
272 h = (struct stlink_usb_handle_s *)handle;
273
274 if (h->version.stlink == 1)
275 cmdsize = STLINK_SG_SIZE;
276
277 err = stlink_usb_xfer_rw(handle, cmdsize, buf, size);
278
279 if (err != ERROR_OK)
280 return err;
281
282 if (h->version.stlink == 1) {
283 if (stlink_usb_xfer_v1_get_status(handle) != ERROR_OK) {
284 /* check csw status */
285 if (h->cmdbuf[12] == 1) {
286 LOG_DEBUG("get sense");
287 if (stlink_usb_xfer_v1_get_sense(handle) != ERROR_OK)
288 return ERROR_FAIL;
289 }
290 return ERROR_FAIL;
291 }
292 }
293
294 return ERROR_OK;
295 }
296
297 /** */
298 static void stlink_usb_xfer_v1_create_cmd(void *handle, uint8_t direction, uint32_t size)
299 {
300 struct stlink_usb_handle_s *h;
301
302 h = (struct stlink_usb_handle_s *)handle;
303
304 /* fill the send buffer */
305 strcpy((char *)h->cmdbuf, "USBC");
306 h->cmdidx += 4;
307 /* csw tag not used */
308 h->cmdidx += 4;
309 buf_set_u32(h->cmdbuf+h->cmdidx, 0, 32, size);
310 h->cmdidx += 4;
311 h->cmdbuf[h->cmdidx++] = (direction == STLINK_RX_EP ? ENDPOINT_IN : ENDPOINT_OUT);
312 h->cmdbuf[h->cmdidx++] = 0; /* lun */
313 h->cmdbuf[h->cmdidx++] = STLINK_CMD_SIZE_V1;
314 }
315
316 /** */
317 static void stlink_usb_init_buffer(void *handle, uint8_t direction, uint32_t size)
318 {
319 struct stlink_usb_handle_s *h;
320
321 h = (struct stlink_usb_handle_s *)handle;
322
323 h->direction = direction;
324
325 h->cmdidx = 0;
326
327 memset(h->cmdbuf, 0, STLINK_SG_SIZE);
328 memset(h->databuf, 0, STLINK_DATA_SIZE);
329
330 if (h->version.stlink == 1)
331 stlink_usb_xfer_v1_create_cmd(handle, direction, size);
332 }
333
334 static const char * const stlink_usb_error_msg[] = {
335 "unknown"
336 };
337
338 /** */
339 static int stlink_usb_error_check(void *handle)
340 {
341 int res;
342 const char *err_msg = 0;
343 struct stlink_usb_handle_s *h;
344
345 assert(handle != NULL);
346
347 h = (struct stlink_usb_handle_s *)handle;
348
349 /* TODO: no error checking yet on api V1 */
350 if (h->jtag_api == STLINK_JTAG_API_V1)
351 h->databuf[0] = STLINK_DEBUG_ERR_OK;
352
353 switch (h->databuf[0]) {
354 case STLINK_DEBUG_ERR_OK:
355 res = ERROR_OK;
356 break;
357 case STLINK_DEBUG_ERR_FAULT:
358 default:
359 err_msg = stlink_usb_error_msg[0];
360 res = ERROR_FAIL;
361 break;
362 }
363
364 if (res != ERROR_OK)
365 LOG_DEBUG("status error: %d ('%s')", h->databuf[0], err_msg);
366
367 return res;
368 }
369
370 /** */
371 static int stlink_usb_version(void *handle)
372 {
373 int res;
374 uint16_t v;
375 struct stlink_usb_handle_s *h;
376
377 assert(handle != NULL);
378
379 h = (struct stlink_usb_handle_s *)handle;
380
381 stlink_usb_init_buffer(handle, STLINK_RX_EP, 6);
382
383 h->cmdbuf[h->cmdidx++] = STLINK_GET_VERSION;
384
385 res = stlink_usb_xfer(handle, h->databuf, 6);
386
387 if (res != ERROR_OK)
388 return res;
389
390 v = (h->databuf[0] << 8) | h->databuf[1];
391
392 h->version.stlink = (v >> 12) & 0x0f;
393 h->version.jtag = (v >> 6) & 0x3f;
394 h->version.swim = v & 0x3f;
395 h->vid = buf_get_u32(h->databuf, 16, 16);
396 h->pid = buf_get_u32(h->databuf, 32, 16);
397
398 /* set the supported jtag api version
399 * V1 doesn't support API V2 at all
400 * V2 support API V2 since JTAG V13
401 */
402 if ((h->version.stlink == 2) && (h->version.jtag > 12))
403 h->version.jtag_api_max = STLINK_JTAG_API_V2;
404 else
405 h->version.jtag_api_max = STLINK_JTAG_API_V1;
406
407 LOG_DEBUG("STLINK v%d JTAG v%d API v%d SWIM v%d VID 0x%04X PID 0x%04X",
408 h->version.stlink,
409 h->version.jtag,
410 (h->version.jtag_api_max == STLINK_JTAG_API_V1) ? 1 : 2,
411 h->version.swim,
412 h->vid,
413 h->pid);
414
415 return ERROR_OK;
416 }
417
418 /** */
419 static int stlink_usb_current_mode(void *handle, uint8_t *mode)
420 {
421 int res;
422 struct stlink_usb_handle_s *h;
423
424 assert(handle != NULL);
425
426 h = (struct stlink_usb_handle_s *)handle;
427
428 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
429
430 h->cmdbuf[h->cmdidx++] = STLINK_GET_CURRENT_MODE;
431
432 res = stlink_usb_xfer(handle, h->databuf, 2);
433
434 if (res != ERROR_OK)
435 return res;
436
437 *mode = h->databuf[0];
438
439 return ERROR_OK;
440 }
441
442 /** */
443 static int stlink_usb_mode_enter(void *handle, enum stlink_mode type)
444 {
445 int res;
446 int rx_size = 0;
447 struct stlink_usb_handle_s *h;
448
449 assert(handle != NULL);
450
451 h = (struct stlink_usb_handle_s *)handle;
452
453 /* on api V2 we are able the read the latest command
454 * status
455 * TODO: we need the test on api V1 too
456 */
457 if (h->jtag_api == STLINK_JTAG_API_V2)
458 rx_size = 2;
459
460 stlink_usb_init_buffer(handle, STLINK_RX_EP, rx_size);
461
462 switch (type) {
463 case STLINK_MODE_DEBUG_JTAG:
464 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
465 if (h->jtag_api == STLINK_JTAG_API_V1)
466 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_ENTER;
467 else
468 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_ENTER;
469 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_ENTER_JTAG;
470 break;
471 case STLINK_MODE_DEBUG_SWD:
472 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
473 if (h->jtag_api == STLINK_JTAG_API_V1)
474 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_ENTER;
475 else
476 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_ENTER;
477 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_ENTER_SWD;
478 break;
479 case STLINK_MODE_DEBUG_SWIM:
480 h->cmdbuf[h->cmdidx++] = STLINK_SWIM_COMMAND;
481 h->cmdbuf[h->cmdidx++] = STLINK_SWIM_ENTER;
482 break;
483 case STLINK_MODE_DFU:
484 case STLINK_MODE_MASS:
485 default:
486 return ERROR_FAIL;
487 }
488
489 res = stlink_usb_xfer(handle, h->databuf, rx_size);
490
491 if (res != ERROR_OK)
492 return res;
493
494 res = stlink_usb_error_check(h);
495
496 return res;
497 }
498
499 /** */
500 static int stlink_usb_mode_leave(void *handle, enum stlink_mode type)
501 {
502 int res;
503 struct stlink_usb_handle_s *h;
504
505 assert(handle != NULL);
506
507 h = (struct stlink_usb_handle_s *)handle;
508
509 stlink_usb_init_buffer(handle, STLINK_NULL_EP, 0);
510
511 switch (type) {
512 case STLINK_MODE_DEBUG_JTAG:
513 case STLINK_MODE_DEBUG_SWD:
514 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
515 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_EXIT;
516 break;
517 case STLINK_MODE_DEBUG_SWIM:
518 h->cmdbuf[h->cmdidx++] = STLINK_SWIM_COMMAND;
519 h->cmdbuf[h->cmdidx++] = STLINK_SWIM_EXIT;
520 break;
521 case STLINK_MODE_DFU:
522 h->cmdbuf[h->cmdidx++] = STLINK_DFU_COMMAND;
523 h->cmdbuf[h->cmdidx++] = STLINK_DFU_EXIT;
524 break;
525 case STLINK_MODE_MASS:
526 default:
527 return ERROR_FAIL;
528 }
529
530 res = stlink_usb_xfer(handle, 0, 0);
531
532 if (res != ERROR_OK)
533 return res;
534
535 return ERROR_OK;
536 }
537
538 /** */
539 static int stlink_usb_init_mode(void *handle)
540 {
541 int res;
542 uint8_t mode;
543 enum stlink_mode emode;
544 struct stlink_usb_handle_s *h;
545
546 assert(handle != NULL);
547
548 h = (struct stlink_usb_handle_s *)handle;
549
550 res = stlink_usb_current_mode(handle, &mode);
551
552 if (res != ERROR_OK)
553 return res;
554
555 LOG_DEBUG("MODE: 0x%02X", mode);
556
557 /* try to exit current mode */
558 switch (mode) {
559 case STLINK_DEV_DFU_MODE:
560 emode = STLINK_MODE_DFU;
561 break;
562 case STLINK_DEV_DEBUG_MODE:
563 emode = STLINK_MODE_DEBUG_SWD;
564 break;
565 case STLINK_DEV_SWIM_MODE:
566 emode = STLINK_MODE_DEBUG_SWIM;
567 break;
568 case STLINK_DEV_BOOTLOADER_MODE:
569 case STLINK_DEV_MASS_MODE:
570 default:
571 emode = STLINK_MODE_UNKNOWN;
572 break;
573 }
574
575 if (emode != STLINK_MODE_UNKNOWN) {
576 res = stlink_usb_mode_leave(handle, emode);
577
578 if (res != ERROR_OK)
579 return res;
580 }
581
582 res = stlink_usb_current_mode(handle, &mode);
583
584 if (res != ERROR_OK)
585 return res;
586
587 LOG_DEBUG("MODE: 0x%02X", mode);
588
589 /* set selected mode */
590 switch (h->transport) {
591 case STLINK_TRANSPORT_SWD:
592 emode = STLINK_MODE_DEBUG_SWD;
593 break;
594 case STLINK_TRANSPORT_JTAG:
595 emode = STLINK_MODE_DEBUG_JTAG;
596 break;
597 case STLINK_TRANSPORT_SWIM:
598 emode = STLINK_MODE_DEBUG_SWIM;
599 break;
600 default:
601 emode = STLINK_MODE_UNKNOWN;
602 break;
603 }
604
605 if (emode == STLINK_MODE_UNKNOWN) {
606 LOG_ERROR("selected mode (transport) not supported");
607 return ERROR_FAIL;
608 }
609
610 res = stlink_usb_mode_enter(handle, emode);
611
612 if (res != ERROR_OK)
613 return res;
614
615 res = stlink_usb_current_mode(handle, &mode);
616
617 if (res != ERROR_OK)
618 return res;
619
620 LOG_DEBUG("MODE: 0x%02X", mode);
621
622 return ERROR_OK;
623 }
624
625 /** */
626 static int stlink_usb_idcode(void *handle, uint32_t *idcode)
627 {
628 int res;
629 struct stlink_usb_handle_s *h;
630
631 assert(handle != NULL);
632
633 h = (struct stlink_usb_handle_s *)handle;
634
635 stlink_usb_init_buffer(handle, STLINK_RX_EP, 4);
636
637 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
638 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READCOREID;
639
640 res = stlink_usb_xfer(handle, h->databuf, 4);
641
642 if (res != ERROR_OK)
643 return res;
644
645 *idcode = le_to_h_u32(h->databuf);
646
647 LOG_DEBUG("IDCODE: 0x%08X", *idcode);
648
649 return ERROR_OK;
650 }
651
652 /** */
653 static enum target_state stlink_usb_state(void *handle)
654 {
655 int res;
656 struct stlink_usb_handle_s *h;
657
658 assert(handle != NULL);
659
660 h = (struct stlink_usb_handle_s *)handle;
661
662 if (h->jtag_api == STLINK_JTAG_API_V2)
663 return TARGET_UNKNOWN;
664
665 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
666
667 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
668 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_GETSTATUS;
669
670 res = stlink_usb_xfer(handle, h->databuf, 2);
671
672 if (res != ERROR_OK)
673 return TARGET_UNKNOWN;
674
675 if (h->databuf[0] == STLINK_CORE_RUNNING)
676 return TARGET_RUNNING;
677 if (h->databuf[0] == STLINK_CORE_HALTED)
678 return TARGET_HALTED;
679
680 return TARGET_UNKNOWN;
681 }
682
683 /** */
684 static int stlink_usb_reset(void *handle)
685 {
686 int res;
687 struct stlink_usb_handle_s *h;
688
689 assert(handle != NULL);
690
691 h = (struct stlink_usb_handle_s *)handle;
692
693 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
694
695 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
696
697 if (h->jtag_api == STLINK_JTAG_API_V1)
698 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_RESETSYS;
699 else
700 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_RESETSYS;
701
702 res = stlink_usb_xfer(handle, h->databuf, 2);
703
704 if (res != ERROR_OK)
705 return res;
706
707 LOG_DEBUG("RESET: 0x%08X", h->databuf[0]);
708
709 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
710 }
711
712 /** */
713 static int stlink_usb_run(void *handle)
714 {
715 int res;
716 struct stlink_usb_handle_s *h;
717
718 assert(handle != NULL);
719
720 h = (struct stlink_usb_handle_s *)handle;
721
722 if (h->jtag_api == STLINK_JTAG_API_V2)
723 return ERROR_FAIL;
724
725 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
726
727 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
728 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_RUNCORE;
729
730 res = stlink_usb_xfer(handle, h->databuf, 2);
731
732 if (res != ERROR_OK)
733 return res;
734
735 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
736 }
737
738 /** */
739 static int stlink_usb_halt(void *handle)
740 {
741 int res;
742 struct stlink_usb_handle_s *h;
743
744 assert(handle != NULL);
745
746 h = (struct stlink_usb_handle_s *)handle;
747
748 if (h->jtag_api == STLINK_JTAG_API_V2)
749 return ERROR_FAIL;
750
751 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
752
753 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
754 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_FORCEDEBUG;
755
756 res = stlink_usb_xfer(handle, h->databuf, 2);
757
758 if (res != ERROR_OK)
759 return res;
760
761 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
762 }
763
764 /** */
765 static int stlink_usb_step(void *handle)
766 {
767 int res;
768 struct stlink_usb_handle_s *h;
769
770 assert(handle != NULL);
771
772 h = (struct stlink_usb_handle_s *)handle;
773
774 if (h->jtag_api == STLINK_JTAG_API_V2)
775 return ERROR_FAIL;
776
777 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
778
779 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
780 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_STEPCORE;
781
782 res = stlink_usb_xfer(handle, h->databuf, 2);
783
784 if (res != ERROR_OK)
785 return res;
786
787 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
788 }
789
790 /** */
791 static int stlink_usb_read_regs(void *handle)
792 {
793 int res;
794 struct stlink_usb_handle_s *h;
795
796 assert(handle != NULL);
797
798 h = (struct stlink_usb_handle_s *)handle;
799
800 stlink_usb_init_buffer(handle, STLINK_RX_EP, 84);
801
802 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
803 if (h->jtag_api == STLINK_JTAG_API_V1)
804 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_READALLREGS;
805 else
806 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_READALLREGS;
807
808 res = stlink_usb_xfer(handle, h->databuf, 84);
809
810 if (res != ERROR_OK)
811 return res;
812
813 return ERROR_OK;
814 }
815
816 /** */
817 static int stlink_usb_read_reg(void *handle, int num, uint32_t *val)
818 {
819 int res;
820 struct stlink_usb_handle_s *h;
821
822 assert(handle != NULL);
823
824 h = (struct stlink_usb_handle_s *)handle;
825
826 stlink_usb_init_buffer(handle, STLINK_RX_EP, 4);
827
828 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
829 if (h->jtag_api == STLINK_JTAG_API_V1)
830 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_READREG;
831 else
832 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_READREG;
833 h->cmdbuf[h->cmdidx++] = num;
834
835 res = stlink_usb_xfer(handle, h->databuf, 4);
836
837 if (res != ERROR_OK)
838 return res;
839
840 *val = le_to_h_u32(h->databuf);
841
842 return ERROR_OK;
843 }
844
845 /** */
846 static int stlink_usb_write_reg(void *handle, int num, uint32_t val)
847 {
848 int res;
849 struct stlink_usb_handle_s *h;
850
851 assert(handle != NULL);
852
853 h = (struct stlink_usb_handle_s *)handle;
854
855 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
856
857 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
858 if (h->jtag_api == STLINK_JTAG_API_V1)
859 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_WRITEREG;
860 else
861 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_WRITEREG;
862 h->cmdbuf[h->cmdidx++] = num;
863 h_u32_to_le(h->cmdbuf+h->cmdidx, val);
864 h->cmdidx += 4;
865
866 res = stlink_usb_xfer(handle, h->databuf, 2);
867
868 if (res != ERROR_OK)
869 return res;
870
871 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
872 }
873
874 /** */
875 static int stlink_usb_read_mem8(void *handle, uint32_t addr, uint16_t len,
876 uint8_t *buffer)
877 {
878 int res;
879 uint16_t read_len = len;
880 struct stlink_usb_handle_s *h;
881
882 assert(handle != NULL);
883
884 h = (struct stlink_usb_handle_s *)handle;
885
886 stlink_usb_init_buffer(handle, STLINK_RX_EP, read_len);
887
888 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
889 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READMEM_8BIT;
890 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
891 h->cmdidx += 4;
892 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
893 h->cmdidx += 2;
894
895 /* we need to fix read length for single bytes */
896 if (read_len == 1)
897 read_len++;
898
899 res = stlink_usb_xfer(handle, h->databuf, read_len);
900
901 if (res != ERROR_OK)
902 return res;
903
904 memcpy(buffer, h->databuf, len);
905
906 return ERROR_OK;
907 }
908
909 /** */
910 static int stlink_usb_write_mem8(void *handle, uint32_t addr, uint16_t len,
911 const uint8_t *buffer)
912 {
913 int res;
914 struct stlink_usb_handle_s *h;
915
916 assert(handle != NULL);
917
918 h = (struct stlink_usb_handle_s *)handle;
919
920 stlink_usb_init_buffer(handle, STLINK_TX_EP, len);
921
922 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
923 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_WRITEMEM_8BIT;
924 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
925 h->cmdidx += 4;
926 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
927 h->cmdidx += 2;
928
929 res = stlink_usb_xfer(handle, buffer, len);
930
931 if (res != ERROR_OK)
932 return res;
933
934 return ERROR_OK;
935 }
936
937 /** */
938 static int stlink_usb_read_mem32(void *handle, uint32_t addr, uint16_t len,
939 uint8_t *buffer)
940 {
941 int res;
942 struct stlink_usb_handle_s *h;
943
944 assert(handle != NULL);
945
946 h = (struct stlink_usb_handle_s *)handle;
947
948 len *= 4;
949
950 stlink_usb_init_buffer(handle, STLINK_RX_EP, len);
951
952 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
953 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READMEM_32BIT;
954 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
955 h->cmdidx += 4;
956 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
957 h->cmdidx += 2;
958
959 res = stlink_usb_xfer(handle, h->databuf, len);
960
961 if (res != ERROR_OK)
962 return res;
963
964 memcpy(buffer, h->databuf, len);
965
966 return ERROR_OK;
967 }
968
969 /** */
970 static int stlink_usb_write_mem32(void *handle, uint32_t addr, uint16_t len,
971 const uint8_t *buffer)
972 {
973 int res;
974 struct stlink_usb_handle_s *h;
975
976 assert(handle != NULL);
977
978 h = (struct stlink_usb_handle_s *)handle;
979
980 len *= 4;
981
982 stlink_usb_init_buffer(handle, STLINK_TX_EP, len);
983
984 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
985 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_WRITEMEM_32BIT;
986 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
987 h->cmdidx += 4;
988 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
989 h->cmdidx += 2;
990
991 res = stlink_usb_xfer(handle, buffer, len);
992
993 if (res != ERROR_OK)
994 return res;
995
996 return ERROR_OK;
997 }
998
999 /** */
1000 static int stlink_usb_open(struct stlink_interface_param_s *param, void **fd)
1001 {
1002 int err;
1003 struct stlink_usb_handle_s *h;
1004
1005 LOG_DEBUG("stlink_usb_open");
1006
1007 h = malloc(sizeof(struct stlink_usb_handle_s));
1008
1009 if (h == 0) {
1010 LOG_DEBUG("malloc failed");
1011 return ERROR_FAIL;
1012 }
1013
1014 h->transport = param->transport;
1015
1016 const uint16_t vids[] = { param->vid, 0 };
1017 const uint16_t pids[] = { param->pid, 0 };
1018
1019 LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x", param->transport,
1020 param->vid, param->pid);
1021
1022 if (jtag_libusb_open(vids, pids, &h->fd) != ERROR_OK) {
1023 LOG_ERROR("open failed");
1024 return ERROR_FAIL;
1025 }
1026
1027 jtag_libusb_set_configuration(h->fd, 0);
1028
1029 if (jtag_libusb_claim_interface(h->fd, 0) != ERROR_OK) {
1030 LOG_DEBUG("claim interface failed");
1031 return ERROR_FAIL;
1032 }
1033
1034 /* wrap version for first read */
1035 switch (param->pid) {
1036 case 0x3744:
1037 h->version.stlink = 1;
1038 break;
1039 default:
1040 h->version.stlink = 2;
1041 break;
1042 }
1043
1044 /* get the device version */
1045 err = stlink_usb_version(h);
1046
1047 if (err != ERROR_OK) {
1048 LOG_ERROR("read version failed");
1049 jtag_libusb_close(h->fd);
1050 free(h);
1051 return err;
1052 }
1053
1054 /* compare usb vid/pid */
1055 if ((param->vid != h->vid) || (param->pid != h->pid))
1056 LOG_INFO("vid/pid are not identical: 0x%04X/0x%04X 0x%04X/0x%04X",
1057 param->vid, param->pid,
1058 h->vid, h->pid);
1059
1060 /* check if mode is supported */
1061 err = ERROR_OK;
1062
1063 switch (h->transport) {
1064 case STLINK_TRANSPORT_SWD:
1065 case STLINK_TRANSPORT_JTAG:
1066 if (h->version.jtag == 0)
1067 err = ERROR_FAIL;
1068 break;
1069 case STLINK_TRANSPORT_SWIM:
1070 if (h->version.swim == 0)
1071 err = ERROR_FAIL;
1072 break;
1073 default:
1074 err = ERROR_FAIL;
1075 break;
1076 }
1077
1078 if (err != ERROR_OK) {
1079 LOG_ERROR("mode (transport) not supported by device");
1080 jtag_libusb_close(h->fd);
1081 free(h);
1082 return err;
1083 }
1084
1085 /* set the used jtag api */
1086 h->jtag_api = STLINK_JTAG_API_V1;
1087
1088 /* initialize the debug hardware */
1089 err = stlink_usb_init_mode(h);
1090
1091 if (err != ERROR_OK) {
1092 LOG_ERROR("init mode failed");
1093 jtag_libusb_close(h->fd);
1094 free(h);
1095 return err;
1096 }
1097
1098 *fd = h;
1099
1100 return ERROR_OK;
1101 }
1102
1103 /** */
1104 static int stlink_usb_close(void *fd)
1105 {
1106 return ERROR_OK;
1107 }
1108
1109 /** */
1110 struct stlink_layout_api_s stlink_usb_layout_api = {
1111 /** */
1112 .open = stlink_usb_open,
1113 /** */
1114 .close = stlink_usb_close,
1115 /** */
1116 .idcode = stlink_usb_idcode,
1117 /** */
1118 .state = stlink_usb_state,
1119 /** */
1120 .reset = stlink_usb_reset,
1121 /** */
1122 .run = stlink_usb_run,
1123 /** */
1124 .halt = stlink_usb_halt,
1125 /** */
1126 .step = stlink_usb_step,
1127 /** */
1128 .read_regs = stlink_usb_read_regs,
1129 /** */
1130 .read_reg = stlink_usb_read_reg,
1131 /** */
1132 .write_reg = stlink_usb_write_reg,
1133 /** */
1134 .read_mem8 = stlink_usb_read_mem8,
1135 /** */
1136 .write_mem8 = stlink_usb_write_mem8,
1137 /** */
1138 .read_mem32 = stlink_usb_read_mem32,
1139 /** */
1140 .write_mem32 = stlink_usb_write_mem32,
1141 };
add intel's jflashmm functionality to openocd