Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
adapter: switch from struct jtag_interface to adapter_driver
[openocd.git] / src / jtag / drivers / kitprog.c
1 /***************************************************************************
2 * Copyright (C) 2007 by Juergen Stuber <juergen@jstuber.net> *
3 * based on Dominic Rath's and Benedikt Sauter's usbprog.c *
4 * *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
7 * *
8 * Copyright (C) 2011 by Jean-Christophe PLAGNIOL-VIILARD *
9 * plagnioj@jcrosoft.com *
10 * *
11 * Copyright (C) 2015 by Marc Schink *
12 * openocd-dev@marcschink.de *
13 * *
14 * Copyright (C) 2015 by Paul Fertser *
15 * fercerpav@gmail.com *
16 * *
17 * Copyright (C) 2015-2017 by Forest Crossman *
18 * cyrozap@gmail.com *
19 * *
20 * This program is free software; you can redistribute it and/or modify *
21 * it under the terms of the GNU General Public License as published by *
22 * the Free Software Foundation; either version 2 of the License, or *
23 * (at your option) any later version. *
24 * *
25 * This program is distributed in the hope that it will be useful, *
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
28 * GNU General Public License for more details. *
29 * *
30 * You should have received a copy of the GNU General Public License *
31 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
32 ***************************************************************************/
33
34 #ifdef HAVE_CONFIG_H
35 #include "config.h"
36 #endif
37
38 #include <stdint.h>
39
40 #include <hidapi.h>
41
42 #include <jtag/interface.h>
43 #include <jtag/swd.h>
44 #include <jtag/commands.h>
45
46 #include "libusb_common.h"
47
48 #define VID 0x04b4
49 #define PID 0xf139
50
51 #define BULK_EP_IN 1
52 #define BULK_EP_OUT 2
53
54 #define CONTROL_TYPE_READ 0x01
55 #define CONTROL_TYPE_WRITE 0x02
56
57 #define CONTROL_COMMAND_PROGRAM 0x07
58
59 #define CONTROL_MODE_POLL_PROGRAMMER_STATUS 0x01
60 #define CONTROL_MODE_RESET_TARGET 0x04
61 #define CONTROL_MODE_SET_PROGRAMMER_PROTOCOL 0x40
62 #define CONTROL_MODE_SYNCHRONIZE_TRANSFER 0x41
63 #define CONTROL_MODE_ACQUIRE_SWD_TARGET 0x42
64 #define CONTROL_MODE_SEND_SWD_SEQUENCE 0x43
65
66 #define PROTOCOL_JTAG 0x00
67 #define PROTOCOL_SWD 0x01
68
69 #define DEVICE_PSOC4 0x00
70 #define DEVICE_PSOC3 0x01
71 #define DEVICE_UNKNOWN 0x02
72 #define DEVICE_PSOC5 0x03
73
74 #define ACQUIRE_MODE_RESET 0x00
75 #define ACQUIRE_MODE_POWER_CYCLE 0x01
76
77 #define SEQUENCE_LINE_RESET 0x00
78 #define SEQUENCE_JTAG_TO_SWD 0x01
79
80 #define PROGRAMMER_NOK_NACK 0x00
81 #define PROGRAMMER_OK_ACK 0x01
82
83 #define HID_TYPE_WRITE 0x00
84 #define HID_TYPE_READ 0x01
85 #define HID_TYPE_START 0x02
86
87 #define HID_COMMAND_POWER 0x80
88 #define HID_COMMAND_VERSION 0x81
89 #define HID_COMMAND_RESET 0x82
90 #define HID_COMMAND_CONFIGURE 0x8f
91 #define HID_COMMAND_BOOTLOADER 0xa0
92
93 /* 512 bytes seems to work reliably */
94 #define SWD_MAX_BUFFER_LENGTH 512
95
96 struct kitprog {
97 hid_device *hid_handle;
98 struct jtag_libusb_device_handle *usb_handle;
99 uint16_t packet_size;
100 uint16_t packet_index;
101 uint8_t *packet_buffer;
102 char *serial;
103 uint8_t hardware_version;
104 uint8_t minor_version;
105 uint8_t major_version;
106 uint16_t millivolts;
107
108 bool supports_jtag_to_swd;
109 };
110
111 struct pending_transfer_result {
112 uint8_t cmd;
113 uint32_t data;
114 void *buffer;
115 };
116
117 static char *kitprog_serial;
118 static bool kitprog_init_acquire_psoc;
119
120 static int pending_transfer_count, pending_queue_len;
121 static struct pending_transfer_result *pending_transfers;
122
123 static int queued_retval;
124
125 static struct kitprog *kitprog_handle;
126
127 static int kitprog_usb_open(void);
128 static void kitprog_usb_close(void);
129
130 static int kitprog_hid_command(uint8_t *command, size_t command_length,
131 uint8_t *data, size_t data_length);
132 static int kitprog_get_version(void);
133 static int kitprog_get_millivolts(void);
134 static int kitprog_get_info(void);
135 static int kitprog_set_protocol(uint8_t protocol);
136 static int kitprog_get_status(void);
137 static int kitprog_set_unknown(void);
138 static int kitprog_acquire_psoc(uint8_t psoc_type, uint8_t acquire_mode,
139 uint8_t max_attempts);
140 static int kitprog_reset_target(void);
141 static int kitprog_swd_sync(void);
142 static int kitprog_swd_seq(uint8_t seq_type);
143
144 static int kitprog_generic_acquire(void);
145
146 static int kitprog_swd_run_queue(void);
147 static void kitprog_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data);
148 static int kitprog_swd_switch_seq(enum swd_special_seq seq);
149
150
151 static inline int mm_to_version(uint8_t major, uint8_t minor)
152 {
153 return (major << 8) | minor;
154 }
155
156 static int kitprog_init(void)
157 {
158 int retval;
159
160 kitprog_handle = malloc(sizeof(struct kitprog));
161 if (kitprog_handle == NULL) {
162 LOG_ERROR("Failed to allocate memory");
163 return ERROR_FAIL;
164 }
165
166 if (kitprog_usb_open() != ERROR_OK) {
167 LOG_ERROR("Can't find a KitProg device! Please check device connections and permissions.");
168 return ERROR_JTAG_INIT_FAILED;
169 }
170
171 /* Get the current KitProg version and target voltage */
172 if (kitprog_get_info() != ERROR_OK)
173 return ERROR_FAIL;
174
175 /* Compatibility check */
176 kitprog_handle->supports_jtag_to_swd = true;
177 int kitprog_version = mm_to_version(kitprog_handle->major_version, kitprog_handle->minor_version);
178 if (kitprog_version < mm_to_version(2, 14)) {
179 LOG_WARNING("KitProg firmware versions below v2.14 do not support sending JTAG to SWD sequences. These sequences will be substituted with SWD line resets.");
180 kitprog_handle->supports_jtag_to_swd = false;
181 }
182
183 /* I have no idea what this does */
184 if (kitprog_set_unknown() != ERROR_OK)
185 return ERROR_FAIL;
186
187 /* SWD won't work unless we do this */
188 if (kitprog_swd_sync() != ERROR_OK)
189 return ERROR_FAIL;
190
191 /* Set the protocol to SWD */
192 if (kitprog_set_protocol(PROTOCOL_SWD) != ERROR_OK)
193 return ERROR_FAIL;
194
195 /* Reset the SWD bus */
196 if (kitprog_swd_seq(SEQUENCE_LINE_RESET) != ERROR_OK)
197 return ERROR_FAIL;
198
199 if (kitprog_init_acquire_psoc) {
200 /* Try to acquire any device that will respond */
201 retval = kitprog_generic_acquire();
202 if (retval != ERROR_OK) {
203 LOG_ERROR("No PSoC devices found");
204 return retval;
205 }
206 }
207
208 /* Allocate packet buffers and queues */
209 kitprog_handle->packet_size = SWD_MAX_BUFFER_LENGTH;
210 kitprog_handle->packet_buffer = malloc(SWD_MAX_BUFFER_LENGTH);
211 if (kitprog_handle->packet_buffer == NULL) {
212 LOG_ERROR("Failed to allocate memory for the packet buffer");
213 return ERROR_FAIL;
214 }
215
216 pending_queue_len = SWD_MAX_BUFFER_LENGTH / 5;
217 pending_transfers = malloc(pending_queue_len * sizeof(*pending_transfers));
218 if (pending_transfers == NULL) {
219 LOG_ERROR("Failed to allocate memory for the SWD transfer queue");
220 return ERROR_FAIL;
221 }
222
223 return ERROR_OK;
224 }
225
226 static int kitprog_quit(void)
227 {
228 kitprog_usb_close();
229
230 if (kitprog_handle->packet_buffer != NULL)
231 free(kitprog_handle->packet_buffer);
232 if (kitprog_handle->serial != NULL)
233 free(kitprog_handle->serial);
234 if (kitprog_handle != NULL)
235 free(kitprog_handle);
236
237 if (kitprog_serial != NULL)
238 free(kitprog_serial);
239
240 if (pending_transfers != NULL)
241 free(pending_transfers);
242
243 return ERROR_OK;
244 }
245
246 /*************** kitprog usb functions *********************/
247
248 static int kitprog_get_usb_serial(void)
249 {
250 int retval;
251 const uint8_t str_index = 128; /* This seems to be a constant */
252 char desc_string[256+1]; /* Max size of string descriptor */
253
254 retval = libusb_get_string_descriptor_ascii(kitprog_handle->usb_handle,
255 str_index, (unsigned char *)desc_string, sizeof(desc_string)-1);
256 if (retval < 0) {
257 LOG_ERROR("libusb_get_string_descriptor_ascii() failed with %d", retval);
258 return ERROR_FAIL;
259 }
260
261 /* Null terminate descriptor string */
262 desc_string[retval] = '\0';
263
264 /* Allocate memory for the serial number */
265 kitprog_handle->serial = calloc(retval + 1, sizeof(char));
266 if (kitprog_handle->serial == NULL) {
267 LOG_ERROR("Failed to allocate memory for the serial number");
268 return ERROR_FAIL;
269 }
270
271 /* Store the serial number */
272 strncpy(kitprog_handle->serial, desc_string, retval + 1);
273
274 return ERROR_OK;
275 }
276
277 static int kitprog_usb_open(void)
278 {
279 const uint16_t vids[] = { VID, 0 };
280 const uint16_t pids[] = { PID, 0 };
281
282 if (jtag_libusb_open(vids, pids, kitprog_serial,
283 &kitprog_handle->usb_handle) != ERROR_OK) {
284 LOG_ERROR("Failed to open or find the device");
285 return ERROR_FAIL;
286 }
287
288 /* Get the serial number for the device */
289 if (kitprog_get_usb_serial() != ERROR_OK)
290 LOG_WARNING("Failed to get KitProg serial number");
291
292 /* Convert the ASCII serial number into a (wchar_t *) */
293 size_t len = strlen(kitprog_handle->serial);
294 wchar_t *hid_serial = calloc(len + 1, sizeof(wchar_t));
295 if (hid_serial == NULL) {
296 LOG_ERROR("Failed to allocate memory for the serial number");
297 return ERROR_FAIL;
298 }
299 if (mbstowcs(hid_serial, kitprog_handle->serial, len + 1) == (size_t)-1) {
300 free(hid_serial);
301 LOG_ERROR("Failed to convert serial number");
302 return ERROR_FAIL;
303 }
304
305 /* Use HID for the KitBridge interface */
306 kitprog_handle->hid_handle = hid_open(VID, PID, hid_serial);
307 free(hid_serial);
308 if (kitprog_handle->hid_handle == NULL) {
309 LOG_ERROR("Failed to open KitBridge (HID) interface");
310 return ERROR_FAIL;
311 }
312
313 /* Claim the KitProg Programmer (bulk transfer) interface */
314 if (jtag_libusb_claim_interface(kitprog_handle->usb_handle, 1) != ERROR_OK) {
315 LOG_ERROR("Failed to claim KitProg Programmer (bulk transfer) interface");
316 return ERROR_FAIL;
317 }
318
319 return ERROR_OK;
320 }
321
322 static void kitprog_usb_close(void)
323 {
324 if (kitprog_handle->hid_handle != NULL) {
325 hid_close(kitprog_handle->hid_handle);
326 hid_exit();
327 }
328
329 jtag_libusb_close(kitprog_handle->usb_handle);
330 }
331
332 /*************** kitprog lowlevel functions *********************/
333
334 static int kitprog_hid_command(uint8_t *command, size_t command_length,
335 uint8_t *data, size_t data_length)
336 {
337 int ret;
338
339 ret = hid_write(kitprog_handle->hid_handle, command, command_length);
340 if (ret < 0) {
341 LOG_DEBUG("HID write returned %i", ret);
342 return ERROR_FAIL;
343 }
344
345 ret = hid_read(kitprog_handle->hid_handle, data, data_length);
346 if (ret < 0) {
347 LOG_DEBUG("HID read returned %i", ret);
348 return ERROR_FAIL;
349 }
350
351 return ERROR_OK;
352 }
353
354 static int kitprog_get_version(void)
355 {
356 int ret;
357
358 unsigned char command[3] = {HID_TYPE_START | HID_TYPE_WRITE, 0x00, HID_COMMAND_VERSION};
359 unsigned char data[64];
360
361 ret = kitprog_hid_command(command, sizeof command, data, sizeof data);
362 if (ret != ERROR_OK)
363 return ret;
364
365 kitprog_handle->hardware_version = data[1];
366 kitprog_handle->minor_version = data[2];
367 kitprog_handle->major_version = data[3];
368
369 return ERROR_OK;
370 }
371
372 static int kitprog_get_millivolts(void)
373 {
374 int ret;
375
376 unsigned char command[3] = {HID_TYPE_START | HID_TYPE_READ, 0x00, HID_COMMAND_POWER};
377 unsigned char data[64];
378
379 ret = kitprog_hid_command(command, sizeof command, data, sizeof data);
380 if (ret != ERROR_OK)
381 return ret;
382
383 kitprog_handle->millivolts = (data[4] << 8) | data[3];
384
385 return ERROR_OK;
386 }
387
388 static int kitprog_get_info(void)
389 {
390 /* Get the device version information */
391 if (kitprog_get_version() == ERROR_OK) {
392 LOG_INFO("KitProg v%u.%02u",
393 kitprog_handle->major_version, kitprog_handle->minor_version);
394 LOG_INFO("Hardware version: %u",
395 kitprog_handle->hardware_version);
396 } else {
397 LOG_ERROR("Failed to get KitProg version");
398 return ERROR_FAIL;
399 }
400
401 /* Get the current reported target voltage */
402 if (kitprog_get_millivolts() == ERROR_OK) {
403 LOG_INFO("VTARG = %u.%03u V",
404 kitprog_handle->millivolts / 1000, kitprog_handle->millivolts % 1000);
405 } else {
406 LOG_ERROR("Failed to get target voltage");
407 return ERROR_FAIL;
408 }
409
410 return ERROR_OK;
411 }
412
413 static int kitprog_set_protocol(uint8_t protocol)
414 {
415 int transferred;
416 char status = PROGRAMMER_NOK_NACK;
417
418 transferred = jtag_libusb_control_transfer(kitprog_handle->usb_handle,
419 LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
420 CONTROL_TYPE_WRITE,
421 (CONTROL_MODE_SET_PROGRAMMER_PROTOCOL << 8) | CONTROL_COMMAND_PROGRAM,
422 protocol, &status, 1, 0);
423
424 if (transferred == 0) {
425 LOG_DEBUG("Zero bytes transferred");
426 return ERROR_FAIL;
427 }
428
429 if (status != PROGRAMMER_OK_ACK) {
430 LOG_DEBUG("Programmer did not respond OK");
431 return ERROR_FAIL;
432 }
433
434 return ERROR_OK;
435 }
436
437 static int kitprog_get_status(void)
438 {
439 int transferred = 0;
440 char status = PROGRAMMER_NOK_NACK;
441
442 /* Try a maximum of three times */
443 for (int i = 0; (i < 3) && (transferred == 0); i++) {
444 transferred = jtag_libusb_control_transfer(kitprog_handle->usb_handle,
445 LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
446 CONTROL_TYPE_READ,
447 (CONTROL_MODE_POLL_PROGRAMMER_STATUS << 8) | CONTROL_COMMAND_PROGRAM,
448 0, &status, 1, 0);
449 jtag_sleep(1000);
450 }
451
452 if (transferred == 0) {
453 LOG_DEBUG("Zero bytes transferred");
454 return ERROR_FAIL;
455 }
456
457 if (status != PROGRAMMER_OK_ACK) {
458 LOG_DEBUG("Programmer did not respond OK");
459 return ERROR_FAIL;
460 }
461
462 return ERROR_OK;
463 }
464
465 static int kitprog_set_unknown(void)
466 {
467 int transferred;
468 char status = PROGRAMMER_NOK_NACK;
469
470 transferred = jtag_libusb_control_transfer(kitprog_handle->usb_handle,
471 LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
472 CONTROL_TYPE_WRITE,
473 (0x03 << 8) | 0x04,
474 0, &status, 1, 0);
475
476 if (transferred == 0) {
477 LOG_DEBUG("Zero bytes transferred");
478 return ERROR_FAIL;
479 }
480
481 if (status != PROGRAMMER_OK_ACK) {
482 LOG_DEBUG("Programmer did not respond OK");
483 return ERROR_FAIL;
484 }
485
486 return ERROR_OK;
487 }
488
489 static int kitprog_acquire_psoc(uint8_t psoc_type, uint8_t acquire_mode,
490 uint8_t max_attempts)
491 {
492 int transferred;
493 char status = PROGRAMMER_NOK_NACK;
494
495 transferred = jtag_libusb_control_transfer(kitprog_handle->usb_handle,
496 LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
497 CONTROL_TYPE_WRITE,
498 (CONTROL_MODE_ACQUIRE_SWD_TARGET << 8) | CONTROL_COMMAND_PROGRAM,
499 (max_attempts << 8) | (acquire_mode << 4) | psoc_type, &status, 1, 0);
500
501 if (transferred == 0) {
502 LOG_DEBUG("Zero bytes transferred");
503 return ERROR_FAIL;
504 }
505
506 if (status != PROGRAMMER_OK_ACK) {
507 LOG_DEBUG("Programmer did not respond OK");
508 return ERROR_FAIL;
509 }
510
511 return ERROR_OK;
512 }
513
514 static int kitprog_reset_target(void)
515 {
516 int transferred;
517 char status = PROGRAMMER_NOK_NACK;
518
519 transferred = jtag_libusb_control_transfer(kitprog_handle->usb_handle,
520 LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
521 CONTROL_TYPE_WRITE,
522 (CONTROL_MODE_RESET_TARGET << 8) | CONTROL_COMMAND_PROGRAM,
523 0, &status, 1, 0);
524
525 if (transferred == 0) {
526 LOG_DEBUG("Zero bytes transferred");
527 return ERROR_FAIL;
528 }
529
530 if (status != PROGRAMMER_OK_ACK) {
531 LOG_DEBUG("Programmer did not respond OK");
532 return ERROR_FAIL;
533 }
534
535 return ERROR_OK;
536 }
537
538 static int kitprog_swd_sync(void)
539 {
540 int transferred;
541 char status = PROGRAMMER_NOK_NACK;
542
543 transferred = jtag_libusb_control_transfer(kitprog_handle->usb_handle,
544 LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
545 CONTROL_TYPE_WRITE,
546 (CONTROL_MODE_SYNCHRONIZE_TRANSFER << 8) | CONTROL_COMMAND_PROGRAM,
547 0, &status, 1, 0);
548
549 if (transferred == 0) {
550 LOG_DEBUG("Zero bytes transferred");
551 return ERROR_FAIL;
552 }
553
554 if (status != PROGRAMMER_OK_ACK) {
555 LOG_DEBUG("Programmer did not respond OK");
556 return ERROR_FAIL;
557 }
558
559 return ERROR_OK;
560 }
561
562 static int kitprog_swd_seq(uint8_t seq_type)
563 {
564 int transferred;
565 char status = PROGRAMMER_NOK_NACK;
566
567 transferred = jtag_libusb_control_transfer(kitprog_handle->usb_handle,
568 LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
569 CONTROL_TYPE_WRITE,
570 (CONTROL_MODE_SEND_SWD_SEQUENCE << 8) | CONTROL_COMMAND_PROGRAM,
571 seq_type, &status, 1, 0);
572
573 if (transferred == 0) {
574 LOG_DEBUG("Zero bytes transferred");
575 return ERROR_FAIL;
576 }
577
578 if (status != PROGRAMMER_OK_ACK) {
579 LOG_DEBUG("Programmer did not respond OK");
580 return ERROR_FAIL;
581 }
582
583 return ERROR_OK;
584 }
585
586 static int kitprog_generic_acquire(void)
587 {
588 const uint8_t devices[] = {DEVICE_PSOC4, DEVICE_PSOC3, DEVICE_PSOC5};
589
590 int retval;
591 int acquire_count = 0;
592
593 /* Due to the way the SWD port is shared between the Test Controller (TC)
594 * and the Cortex-M3 DAP on the PSoC 5LP, the TC is the default SWD target
595 * after power is applied. To access the DAP, the PSoC 5LP requires at least
596 * one acquisition sequence to be run (which switches the SWD mux from the
597 * TC to the DAP). However, after the mux is switched, the Cortex-M3 will be
598 * held in reset until a series of registers are written to (see section 5.2
599 * of the PSoC 5LP Device Programming Specifications for details).
600 *
601 * Instead of writing the registers in this function, we just do what the
602 * Cypress tools do and run the acquisition sequence a second time. This
603 * will take the Cortex-M3 out of reset and enable debugging.
604 */
605 for (int i = 0; i < 2; i++) {
606 for (uint8_t j = 0; j < sizeof devices && acquire_count == i; j++) {
607 retval = kitprog_acquire_psoc(devices[j], ACQUIRE_MODE_RESET, 3);
608 if (retval != ERROR_OK) {
609 LOG_DEBUG("Aquisition function failed for device 0x%02x.", devices[j]);
610 return retval;
611 }
612
613 if (kitprog_get_status() == ERROR_OK)
614 acquire_count++;
615 }
616
617 jtag_sleep(10);
618 }
619
620 if (acquire_count < 2)
621 return ERROR_FAIL;
622
623 return ERROR_OK;
624 }
625
626 /*************** swd wrapper functions *********************/
627
628 static int kitprog_swd_init(void)
629 {
630 return ERROR_OK;
631 }
632
633 static void kitprog_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
634 {
635 assert(!(cmd & SWD_CMD_RnW));
636 kitprog_swd_queue_cmd(cmd, NULL, value);
637 }
638
639 static void kitprog_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
640 {
641 assert(cmd & SWD_CMD_RnW);
642 kitprog_swd_queue_cmd(cmd, value, 0);
643 }
644
645 /*************** swd lowlevel functions ********************/
646
647 static int kitprog_swd_switch_seq(enum swd_special_seq seq)
648 {
649 switch (seq) {
650 case JTAG_TO_SWD:
651 if (kitprog_handle->supports_jtag_to_swd) {
652 LOG_DEBUG("JTAG to SWD");
653 if (kitprog_swd_seq(SEQUENCE_JTAG_TO_SWD) != ERROR_OK)
654 return ERROR_FAIL;
655 break;
656 } else {
657 LOG_DEBUG("JTAG to SWD not supported");
658 /* Fall through to fix target reset issue */
659 }
660 /* fallthrough */
661 case LINE_RESET:
662 LOG_DEBUG("SWD line reset");
663 if (kitprog_swd_seq(SEQUENCE_LINE_RESET) != ERROR_OK)
664 return ERROR_FAIL;
665 break;
666 default:
667 LOG_ERROR("Sequence %d not supported.", seq);
668 return ERROR_FAIL;
669 }
670
671 return ERROR_OK;
672 }
673
674 static int kitprog_swd_run_queue(void)
675 {
676 int ret;
677
678 size_t read_count = 0;
679 size_t read_index = 0;
680 size_t write_count = 0;
681 uint8_t *buffer = kitprog_handle->packet_buffer;
682
683 do {
684 LOG_DEBUG_IO("Executing %d queued transactions", pending_transfer_count);
685
686 if (queued_retval != ERROR_OK) {
687 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval);
688 break;
689 }
690
691 if (!pending_transfer_count)
692 break;
693
694 for (int i = 0; i < pending_transfer_count; i++) {
695 uint8_t cmd = pending_transfers[i].cmd;
696 uint32_t data = pending_transfers[i].data;
697
698 /* When proper WAIT handling is implemented in the
699 * common SWD framework, this kludge can be
700 * removed. However, this might lead to minor
701 * performance degradation as the adapter wouldn't be
702 * able to automatically retry anything (because ARM
703 * has forgotten to implement sticky error flags
704 * clearing). See also comments regarding
705 * cmsis_dap_cmd_DAP_TFER_Configure() and
706 * cmsis_dap_cmd_DAP_SWD_Configure() in
707 * cmsis_dap_init().
708 */
709 if (!(cmd & SWD_CMD_RnW) &&
710 !(cmd & SWD_CMD_APnDP) &&
711 (cmd & SWD_CMD_A32) >> 1 == DP_CTRL_STAT &&
712 (data & CORUNDETECT)) {
713 LOG_DEBUG("refusing to enable sticky overrun detection");
714 data &= ~CORUNDETECT;
715 }
716
717 LOG_DEBUG_IO("%s %s reg %x %"PRIx32,
718 cmd & SWD_CMD_APnDP ? "AP" : "DP",
719 cmd & SWD_CMD_RnW ? "read" : "write",
720 (cmd & SWD_CMD_A32) >> 1, data);
721
722 buffer[write_count++] = (cmd | SWD_CMD_START | SWD_CMD_PARK) & ~SWD_CMD_STOP;
723 read_count++;
724 if (!(cmd & SWD_CMD_RnW)) {
725 buffer[write_count++] = (data) & 0xff;
726 buffer[write_count++] = (data >> 8) & 0xff;
727 buffer[write_count++] = (data >> 16) & 0xff;
728 buffer[write_count++] = (data >> 24) & 0xff;
729 } else {
730 read_count += 4;
731 }
732 }
733
734 ret = jtag_libusb_bulk_write(kitprog_handle->usb_handle,
735 BULK_EP_OUT, (char *)buffer, write_count, 0);
736 if (ret > 0) {
737 queued_retval = ERROR_OK;
738 } else {
739 LOG_ERROR("Bulk write failed");
740 queued_retval = ERROR_FAIL;
741 break;
742 }
743
744 /* KitProg firmware does not send a zero length packet
745 * after the bulk-in transmission of a length divisible by bulk packet
746 * size (64 bytes) as required by the USB specification.
747 * Therefore libusb would wait for continuation of transmission.
748 * Workaround: Limit bulk read size to expected number of bytes
749 * for problematic tranfer sizes. Otherwise use the maximum buffer
750 * size here because the KitProg sometimes doesn't like bulk reads
751 * of fewer than 62 bytes. (?!?!)
752 */
753 size_t read_count_workaround = SWD_MAX_BUFFER_LENGTH;
754 if (read_count % 64 == 0)
755 read_count_workaround = read_count;
756
757 ret = jtag_libusb_bulk_read(kitprog_handle->usb_handle,
758 BULK_EP_IN | LIBUSB_ENDPOINT_IN, (char *)buffer,
759 read_count_workaround, 1000);
760 if (ret > 0) {
761 /* Handle garbage data by offsetting the initial read index */
762 if ((unsigned int)ret > read_count)
763 read_index = ret - read_count;
764 queued_retval = ERROR_OK;
765 } else {
766 LOG_ERROR("Bulk read failed");
767 queued_retval = ERROR_FAIL;
768 break;
769 }
770
771 for (int i = 0; i < pending_transfer_count; i++) {
772 if (pending_transfers[i].cmd & SWD_CMD_RnW) {
773 uint32_t data = le_to_h_u32(&buffer[read_index]);
774
775 LOG_DEBUG_IO("Read result: %"PRIx32, data);
776
777 if (pending_transfers[i].buffer)
778 *(uint32_t *)pending_transfers[i].buffer = data;
779
780 read_index += 4;
781 }
782
783 uint8_t ack = buffer[read_index] & 0x07;
784 if (ack != SWD_ACK_OK || (buffer[read_index] & 0x08)) {
785 LOG_DEBUG("SWD ack not OK: %d %s", i,
786 ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK");
787 queued_retval = ack == SWD_ACK_WAIT ? ERROR_WAIT : ERROR_FAIL;
788 break;
789 }
790 read_index++;
791 }
792 } while (0);
793
794 pending_transfer_count = 0;
795 int retval = queued_retval;
796 queued_retval = ERROR_OK;
797
798 return retval;
799 }
800
801 static void kitprog_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data)
802 {
803 if (pending_transfer_count == pending_queue_len) {
804 /* Not enough room in the queue. Run the queue. */
805 queued_retval = kitprog_swd_run_queue();
806 }
807
808 if (queued_retval != ERROR_OK)
809 return;
810
811 pending_transfers[pending_transfer_count].data = data;
812 pending_transfers[pending_transfer_count].cmd = cmd;
813 if (cmd & SWD_CMD_RnW) {
814 /* Queue a read transaction */
815 pending_transfers[pending_transfer_count].buffer = dst;
816 }
817 pending_transfer_count++;
818 }
819
820 /*************** jtag lowlevel functions ********************/
821
822 static int kitprog_reset(int trst, int srst)
823 {
824 int retval = ERROR_OK;
825
826 if (trst == 1) {
827 LOG_ERROR("KitProg: Interface has no TRST");
828 return ERROR_FAIL;
829 }
830
831 if (srst == 1) {
832 retval = kitprog_reset_target();
833 /* Since the previous command also disables SWCLK output, we need to send an
834 * SWD bus reset command to re-enable it. For some reason, running
835 * kitprog_swd_seq() immediately after kitprog_reset_target() won't
836 * actually fix this. Instead, kitprog_swd_seq() will be run once OpenOCD
837 * tries to send a JTAG-to-SWD sequence, which should happen during
838 * swd_check_reconnect (see the JTAG_TO_SWD case in kitprog_swd_switch_seq).
839 */
840 }
841
842 if (retval != ERROR_OK)
843 LOG_ERROR("KitProg: Interface reset failed");
844 return retval;
845 }
846
847 COMMAND_HANDLER(kitprog_handle_info_command)
848 {
849 int retval = kitprog_get_info();
850
851 return retval;
852 }
853
854
855 COMMAND_HANDLER(kitprog_handle_acquire_psoc_command)
856 {
857 int retval = kitprog_generic_acquire();
858
859 return retval;
860 }
861
862 COMMAND_HANDLER(kitprog_handle_serial_command)
863 {
864 if (CMD_ARGC == 1) {
865 kitprog_serial = strdup(CMD_ARGV[0]);
866 if (kitprog_serial == NULL) {
867 LOG_ERROR("Failed to allocate memory for the serial number");
868 return ERROR_FAIL;
869 }
870 } else {
871 LOG_ERROR("expected exactly one argument to kitprog_serial <serial-number>");
872 return ERROR_FAIL;
873 }
874
875 return ERROR_OK;
876 }
877
878 COMMAND_HANDLER(kitprog_handle_init_acquire_psoc_command)
879 {
880 kitprog_init_acquire_psoc = true;
881
882 return ERROR_OK;
883 }
884
885 static const struct command_registration kitprog_subcommand_handlers[] = {
886 {
887 .name = "info",
888 .handler = &kitprog_handle_info_command,
889 .mode = COMMAND_EXEC,
890 .usage = "",
891 .help = "show KitProg info",
892 },
893 {
894 .name = "acquire_psoc",
895 .handler = &kitprog_handle_acquire_psoc_command,
896 .mode = COMMAND_EXEC,
897 .usage = "",
898 .help = "try to acquire a PSoC",
899 },
900 COMMAND_REGISTRATION_DONE
901 };
902
903 static const struct command_registration kitprog_command_handlers[] = {
904 {
905 .name = "kitprog",
906 .mode = COMMAND_ANY,
907 .help = "perform KitProg management",
908 .usage = "<cmd>",
909 .chain = kitprog_subcommand_handlers,
910 },
911 {
912 .name = "kitprog_serial",
913 .handler = &kitprog_handle_serial_command,
914 .mode = COMMAND_CONFIG,
915 .help = "set the serial number of the adapter",
916 .usage = "serial_string",
917 },
918 {
919 .name = "kitprog_init_acquire_psoc",
920 .handler = &kitprog_handle_init_acquire_psoc_command,
921 .mode = COMMAND_CONFIG,
922 .help = "try to acquire a PSoC during init",
923 .usage = "",
924 },
925 COMMAND_REGISTRATION_DONE
926 };
927
928 static const struct swd_driver kitprog_swd = {
929 .init = kitprog_swd_init,
930 .switch_seq = kitprog_swd_switch_seq,
931 .read_reg = kitprog_swd_read_reg,
932 .write_reg = kitprog_swd_write_reg,
933 .run = kitprog_swd_run_queue,
934 };
935
936 static const char * const kitprog_transports[] = { "swd", NULL };
937
938 struct adapter_driver kitprog_adapter_driver = {
939 .name = "kitprog",
940 .transports = kitprog_transports,
941 .commands = kitprog_command_handlers,
942
943 .init = kitprog_init,
944 .quit = kitprog_quit,
945 .reset = kitprog_reset,
946
947 .swd_ops = &kitprog_swd,
948 };
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)