1 // SPDX-License-Identifier: GPL-2.0-or-later
3 /***************************************************************************
4 * Copyright (C) 2007 by Juergen Stuber <juergen@jstuber.net> *
5 * based on Dominic Rath's and Benedikt Sauter's usbprog.c *
7 * Copyright (C) 2008 by Spencer Oliver *
8 * spen@spen-soft.co.uk *
10 * Copyright (C) 2011 by Jean-Christophe PLAGNIOL-VIILARD *
11 * plagnioj@jcrosoft.com *
13 * Copyright (C) 2015 by Marc Schink *
14 * openocd-dev@marcschink.de *
16 * Copyright (C) 2015 by Paul Fertser *
17 * fercerpav@gmail.com *
19 * Copyright (C) 2015-2017 by Forest Crossman *
21 ***************************************************************************/
31 #include <jtag/interface.h>
33 #include <jtag/commands.h>
35 #include "libusb_helper.h"
43 #define CONTROL_TYPE_READ 0x01
44 #define CONTROL_TYPE_WRITE 0x02
46 #define CONTROL_COMMAND_PROGRAM 0x07
48 #define CONTROL_MODE_POLL_PROGRAMMER_STATUS 0x01
49 #define CONTROL_MODE_RESET_TARGET 0x04
50 #define CONTROL_MODE_SET_PROGRAMMER_PROTOCOL 0x40
51 #define CONTROL_MODE_SYNCHRONIZE_TRANSFER 0x41
52 #define CONTROL_MODE_ACQUIRE_SWD_TARGET 0x42
53 #define CONTROL_MODE_SEND_SWD_SEQUENCE 0x43
55 #define PROTOCOL_JTAG 0x00
56 #define PROTOCOL_SWD 0x01
58 #define DEVICE_PSOC4 0x00
59 #define DEVICE_PSOC3 0x01
60 #define DEVICE_UNKNOWN 0x02
61 #define DEVICE_PSOC5 0x03
63 #define ACQUIRE_MODE_RESET 0x00
64 #define ACQUIRE_MODE_POWER_CYCLE 0x01
66 #define SEQUENCE_LINE_RESET 0x00
67 #define SEQUENCE_JTAG_TO_SWD 0x01
69 #define PROGRAMMER_NOK_NACK 0x00
70 #define PROGRAMMER_OK_ACK 0x01
72 #define HID_TYPE_WRITE 0x00
73 #define HID_TYPE_READ 0x01
74 #define HID_TYPE_START 0x02
76 #define HID_COMMAND_POWER 0x80
77 #define HID_COMMAND_VERSION 0x81
78 #define HID_COMMAND_RESET 0x82
79 #define HID_COMMAND_CONFIGURE 0x8f
80 #define HID_COMMAND_BOOTLOADER 0xa0
82 /* 512 bytes seemed to work reliably.
83 * It works with both full queue of mostly reads or mostly writes.
85 * Unfortunately the commit 88f429ead019fd6df96ec15f0d897385f3cef0d0
86 * 5321: target/cortex_m: faster reading of all CPU registers
87 * revealed a serious Kitprog firmware problem:
88 * If the queue contains more than 63 transactions in the repeated pattern
89 * one write, two reads, the firmware fails badly.
90 * Sending 64 transactions makes the adapter to loose the connection with the
91 * device. Sending 65 or more transactions causes the adapter to stop
92 * receiving USB HID commands, next kitprog_hid_command() stops in hid_write().
94 * The problem was detected with KitProg v2.12 and v2.16.
95 * We can guess the problem is something like a buffer or stack overflow.
97 * Use shorter buffer as a workaround. 300 bytes (= 60 transactions) works.
99 #define SWD_MAX_BUFFER_LENGTH 300
102 hid_device
*hid_handle
;
103 struct libusb_device_handle
*usb_handle
;
104 uint16_t packet_size
;
105 uint16_t packet_index
;
106 uint8_t *packet_buffer
;
108 uint8_t hardware_version
;
109 uint8_t minor_version
;
110 uint8_t major_version
;
113 bool supports_jtag_to_swd
;
116 struct pending_transfer_result
{
122 static bool kitprog_init_acquire_psoc
;
124 static int pending_transfer_count
, pending_queue_len
;
125 static struct pending_transfer_result
*pending_transfers
;
127 static int queued_retval
;
129 static struct kitprog
*kitprog_handle
;
131 static int kitprog_usb_open(void);
132 static void kitprog_usb_close(void);
134 static int kitprog_hid_command(uint8_t *command
, size_t command_length
,
135 uint8_t *data
, size_t data_length
);
136 static int kitprog_get_version(void);
137 static int kitprog_get_millivolts(void);
138 static int kitprog_get_info(void);
139 static int kitprog_set_protocol(uint8_t protocol
);
140 static int kitprog_get_status(void);
141 static int kitprog_set_unknown(void);
142 static int kitprog_acquire_psoc(uint8_t psoc_type
, uint8_t acquire_mode
,
143 uint8_t max_attempts
);
144 static int kitprog_reset_target(void);
145 static int kitprog_swd_sync(void);
146 static int kitprog_swd_seq(uint8_t seq_type
);
148 static int kitprog_generic_acquire(void);
150 static int kitprog_swd_run_queue(void);
151 static void kitprog_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
);
152 static int kitprog_swd_switch_seq(enum swd_special_seq seq
);
155 static inline int mm_to_version(uint8_t major
, uint8_t minor
)
157 return (major
<< 8) | minor
;
160 static int kitprog_init(void)
164 kitprog_handle
= malloc(sizeof(struct kitprog
));
165 if (!kitprog_handle
) {
166 LOG_ERROR("Failed to allocate memory");
170 if (kitprog_usb_open() != ERROR_OK
) {
171 LOG_ERROR("Can't find a KitProg device! Please check device connections and permissions.");
172 return ERROR_JTAG_INIT_FAILED
;
175 /* Get the current KitProg version and target voltage */
176 if (kitprog_get_info() != ERROR_OK
)
179 /* Compatibility check */
180 kitprog_handle
->supports_jtag_to_swd
= true;
181 int kitprog_version
= mm_to_version(kitprog_handle
->major_version
, kitprog_handle
->minor_version
);
182 if (kitprog_version
< mm_to_version(2, 14)) {
183 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.");
184 kitprog_handle
->supports_jtag_to_swd
= false;
187 /* I have no idea what this does */
188 if (kitprog_set_unknown() != ERROR_OK
)
191 /* SWD won't work unless we do this */
192 if (kitprog_swd_sync() != ERROR_OK
)
195 /* Set the protocol to SWD */
196 if (kitprog_set_protocol(PROTOCOL_SWD
) != ERROR_OK
)
199 /* Reset the SWD bus */
200 if (kitprog_swd_seq(SEQUENCE_LINE_RESET
) != ERROR_OK
)
203 if (kitprog_init_acquire_psoc
) {
204 /* Try to acquire any device that will respond */
205 retval
= kitprog_generic_acquire();
206 if (retval
!= ERROR_OK
) {
207 LOG_ERROR("No PSoC devices found");
212 /* Allocate packet buffers and queues */
213 kitprog_handle
->packet_size
= SWD_MAX_BUFFER_LENGTH
;
214 kitprog_handle
->packet_buffer
= malloc(SWD_MAX_BUFFER_LENGTH
);
215 if (!kitprog_handle
->packet_buffer
) {
216 LOG_ERROR("Failed to allocate memory for the packet buffer");
220 pending_queue_len
= SWD_MAX_BUFFER_LENGTH
/ 5;
221 pending_transfers
= malloc(pending_queue_len
* sizeof(*pending_transfers
));
222 if (!pending_transfers
) {
223 LOG_ERROR("Failed to allocate memory for the SWD transfer queue");
230 static int kitprog_quit(void)
234 free(kitprog_handle
->packet_buffer
);
235 free(kitprog_handle
->serial
);
236 free(kitprog_handle
);
237 free(pending_transfers
);
242 /*************** kitprog usb functions *********************/
244 static int kitprog_get_usb_serial(void)
247 const uint8_t str_index
= 128; /* This seems to be a constant */
248 char desc_string
[256+1]; /* Max size of string descriptor */
250 retval
= libusb_get_string_descriptor_ascii(kitprog_handle
->usb_handle
,
251 str_index
, (unsigned char *)desc_string
, sizeof(desc_string
)-1);
253 LOG_ERROR("libusb_get_string_descriptor_ascii() failed with %d", retval
);
257 /* Null terminate descriptor string */
258 desc_string
[retval
] = '\0';
260 /* Allocate memory for the serial number */
261 kitprog_handle
->serial
= calloc(retval
+ 1, sizeof(char));
262 if (!kitprog_handle
->serial
) {
263 LOG_ERROR("Failed to allocate memory for the serial number");
267 /* Store the serial number */
268 strncpy(kitprog_handle
->serial
, desc_string
, retval
+ 1);
273 static int kitprog_usb_open(void)
275 const uint16_t vids
[] = { VID
, 0 };
276 const uint16_t pids
[] = { PID
, 0 };
278 if (jtag_libusb_open(vids
, pids
, NULL
, &kitprog_handle
->usb_handle
, NULL
) != ERROR_OK
) {
279 LOG_ERROR("Failed to open or find the device");
283 /* Get the serial number for the device */
284 if (kitprog_get_usb_serial() != ERROR_OK
)
285 LOG_WARNING("Failed to get KitProg serial number");
287 /* Convert the ASCII serial number into a (wchar_t *) */
288 size_t len
= strlen(kitprog_handle
->serial
);
289 wchar_t *hid_serial
= calloc(len
+ 1, sizeof(wchar_t));
291 LOG_ERROR("Failed to allocate memory for the serial number");
294 if (mbstowcs(hid_serial
, kitprog_handle
->serial
, len
+ 1) == (size_t)-1) {
296 LOG_ERROR("Failed to convert serial number");
300 /* Use HID for the KitBridge interface */
301 kitprog_handle
->hid_handle
= hid_open(VID
, PID
, hid_serial
);
303 if (!kitprog_handle
->hid_handle
) {
304 LOG_ERROR("Failed to open KitBridge (HID) interface");
308 /* Claim the KitProg Programmer (bulk transfer) interface */
309 if (libusb_claim_interface(kitprog_handle
->usb_handle
, 1) != ERROR_OK
) {
310 LOG_ERROR("Failed to claim KitProg Programmer (bulk transfer) interface");
317 static void kitprog_usb_close(void)
319 if (kitprog_handle
->hid_handle
) {
320 hid_close(kitprog_handle
->hid_handle
);
324 jtag_libusb_close(kitprog_handle
->usb_handle
);
327 /*************** kitprog lowlevel functions *********************/
329 static int kitprog_hid_command(uint8_t *command
, size_t command_length
,
330 uint8_t *data
, size_t data_length
)
334 ret
= hid_write(kitprog_handle
->hid_handle
, command
, command_length
);
336 LOG_DEBUG("HID write returned %i", ret
);
340 ret
= hid_read_timeout(kitprog_handle
->hid_handle
,
341 data
, data_length
, LIBUSB_TIMEOUT_MS
);
343 LOG_ERROR("HID read timed out");
344 return ERROR_TIMEOUT_REACHED
;
345 } else if (ret
< 0) {
346 LOG_ERROR("HID read error %ls", hid_error(kitprog_handle
->hid_handle
));
353 static int kitprog_get_version(void)
357 unsigned char command
[3] = {HID_TYPE_START
| HID_TYPE_WRITE
, 0x00, HID_COMMAND_VERSION
};
358 unsigned char data
[64];
360 ret
= kitprog_hid_command(command
, sizeof(command
), data
, sizeof(data
));
364 kitprog_handle
->hardware_version
= data
[1];
365 kitprog_handle
->minor_version
= data
[2];
366 kitprog_handle
->major_version
= data
[3];
371 static int kitprog_get_millivolts(void)
375 unsigned char command
[3] = {HID_TYPE_START
| HID_TYPE_READ
, 0x00, HID_COMMAND_POWER
};
376 unsigned char data
[64];
378 ret
= kitprog_hid_command(command
, sizeof(command
), data
, sizeof(data
));
382 kitprog_handle
->millivolts
= (data
[4] << 8) | data
[3];
387 static int kitprog_get_info(void)
389 /* Get the device version information */
390 if (kitprog_get_version() == ERROR_OK
) {
391 LOG_INFO("KitProg v%u.%02u",
392 kitprog_handle
->major_version
, kitprog_handle
->minor_version
);
393 LOG_INFO("Hardware version: %u",
394 kitprog_handle
->hardware_version
);
396 LOG_ERROR("Failed to get KitProg version");
400 /* Get the current reported target voltage */
401 if (kitprog_get_millivolts() == ERROR_OK
) {
402 LOG_INFO("VTARG = %u.%03u V",
403 kitprog_handle
->millivolts
/ 1000, kitprog_handle
->millivolts
% 1000);
405 LOG_ERROR("Failed to get target voltage");
412 static int kitprog_set_protocol(uint8_t protocol
)
415 char status
= PROGRAMMER_NOK_NACK
;
417 int retval
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
418 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
420 (CONTROL_MODE_SET_PROGRAMMER_PROTOCOL
<< 8) | CONTROL_COMMAND_PROGRAM
,
421 protocol
, &status
, 1, 0, &transferred
);
423 if (retval
!= ERROR_OK
|| transferred
== 0) {
424 LOG_DEBUG("Zero bytes transferred");
428 if (status
!= PROGRAMMER_OK_ACK
) {
429 LOG_DEBUG("Programmer did not respond OK");
436 static int kitprog_get_status(void)
439 char status
= PROGRAMMER_NOK_NACK
;
441 /* Try a maximum of three times */
442 for (int i
= 0; (i
< 3) && (transferred
== 0); i
++) {
443 jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
444 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
446 (CONTROL_MODE_POLL_PROGRAMMER_STATUS
<< 8) | CONTROL_COMMAND_PROGRAM
,
447 0, &status
, 1, 0, &transferred
);
451 if (transferred
== 0) {
452 LOG_DEBUG("Zero bytes transferred");
456 if (status
!= PROGRAMMER_OK_ACK
) {
457 LOG_DEBUG("Programmer did not respond OK");
464 static int kitprog_set_unknown(void)
467 char status
= PROGRAMMER_NOK_NACK
;
469 int retval
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
470 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
473 0, &status
, 1, 0, &transferred
);
475 if (retval
!= ERROR_OK
|| transferred
== 0) {
476 LOG_DEBUG("Zero bytes transferred");
480 if (status
!= PROGRAMMER_OK_ACK
) {
481 LOG_DEBUG("Programmer did not respond OK");
488 static int kitprog_acquire_psoc(uint8_t psoc_type
, uint8_t acquire_mode
,
489 uint8_t max_attempts
)
492 char status
= PROGRAMMER_NOK_NACK
;
494 int retval
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
495 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
497 (CONTROL_MODE_ACQUIRE_SWD_TARGET
<< 8) | CONTROL_COMMAND_PROGRAM
,
498 (max_attempts
<< 8) | (acquire_mode
<< 4) | psoc_type
, &status
, 1, 0, &transferred
);
500 if (retval
!= ERROR_OK
|| transferred
== 0) {
501 LOG_DEBUG("Zero bytes transferred");
505 if (status
!= PROGRAMMER_OK_ACK
) {
506 LOG_DEBUG("Programmer did not respond OK");
513 static int kitprog_reset_target(void)
516 char status
= PROGRAMMER_NOK_NACK
;
518 int retval
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
519 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
521 (CONTROL_MODE_RESET_TARGET
<< 8) | CONTROL_COMMAND_PROGRAM
,
522 0, &status
, 1, 0, &transferred
);
524 if (retval
!= ERROR_OK
|| transferred
== 0) {
525 LOG_DEBUG("Zero bytes transferred");
529 if (status
!= PROGRAMMER_OK_ACK
) {
530 LOG_DEBUG("Programmer did not respond OK");
537 static int kitprog_swd_sync(void)
540 char status
= PROGRAMMER_NOK_NACK
;
542 int retval
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
543 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
545 (CONTROL_MODE_SYNCHRONIZE_TRANSFER
<< 8) | CONTROL_COMMAND_PROGRAM
,
546 0, &status
, 1, 0, &transferred
);
548 if (retval
!= ERROR_OK
|| transferred
== 0) {
549 LOG_DEBUG("Zero bytes transferred");
553 if (status
!= PROGRAMMER_OK_ACK
) {
554 LOG_DEBUG("Programmer did not respond OK");
561 static int kitprog_swd_seq(uint8_t seq_type
)
564 char status
= PROGRAMMER_NOK_NACK
;
566 int retval
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
567 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
569 (CONTROL_MODE_SEND_SWD_SEQUENCE
<< 8) | CONTROL_COMMAND_PROGRAM
,
570 seq_type
, &status
, 1, 0, &transferred
);
572 if (retval
!= ERROR_OK
|| transferred
== 0) {
573 LOG_DEBUG("Zero bytes transferred");
577 if (status
!= PROGRAMMER_OK_ACK
) {
578 LOG_DEBUG("Programmer did not respond OK");
585 static int kitprog_generic_acquire(void)
587 const uint8_t devices
[] = {DEVICE_PSOC4
, DEVICE_PSOC3
, DEVICE_PSOC5
};
590 int acquire_count
= 0;
592 /* Due to the way the SWD port is shared between the Test Controller (TC)
593 * and the Cortex-M3 DAP on the PSoC 5LP, the TC is the default SWD target
594 * after power is applied. To access the DAP, the PSoC 5LP requires at least
595 * one acquisition sequence to be run (which switches the SWD mux from the
596 * TC to the DAP). However, after the mux is switched, the Cortex-M3 will be
597 * held in reset until a series of registers are written to (see section 5.2
598 * of the PSoC 5LP Device Programming Specifications for details).
600 * Instead of writing the registers in this function, we just do what the
601 * Cypress tools do and run the acquisition sequence a second time. This
602 * will take the Cortex-M3 out of reset and enable debugging.
604 for (int i
= 0; i
< 2; i
++) {
605 for (uint8_t j
= 0; j
< sizeof(devices
) && acquire_count
== i
; j
++) {
606 retval
= kitprog_acquire_psoc(devices
[j
], ACQUIRE_MODE_RESET
, 3);
607 if (retval
!= ERROR_OK
) {
608 LOG_DEBUG("Acquisition function failed for device 0x%02x.", devices
[j
]);
612 if (kitprog_get_status() == ERROR_OK
)
619 if (acquire_count
< 2)
625 /*************** swd wrapper functions *********************/
627 static int kitprog_swd_init(void)
632 static void kitprog_swd_write_reg(uint8_t cmd
, uint32_t value
, uint32_t ap_delay_clk
)
634 assert(!(cmd
& SWD_CMD_RNW
));
635 kitprog_swd_queue_cmd(cmd
, NULL
, value
);
638 static void kitprog_swd_read_reg(uint8_t cmd
, uint32_t *value
, uint32_t ap_delay_clk
)
640 assert(cmd
& SWD_CMD_RNW
);
641 kitprog_swd_queue_cmd(cmd
, value
, 0);
644 /*************** swd lowlevel functions ********************/
646 static int kitprog_swd_switch_seq(enum swd_special_seq seq
)
650 if (kitprog_handle
->supports_jtag_to_swd
) {
651 LOG_DEBUG("JTAG to SWD");
652 if (kitprog_swd_seq(SEQUENCE_JTAG_TO_SWD
) != ERROR_OK
)
656 LOG_DEBUG("JTAG to SWD not supported");
657 /* Fall through to fix target reset issue */
661 LOG_DEBUG("SWD line reset");
662 if (kitprog_swd_seq(SEQUENCE_LINE_RESET
) != ERROR_OK
)
666 LOG_ERROR("Sequence %d not supported.", seq
);
673 static int kitprog_swd_run_queue(void)
677 size_t read_count
= 0;
678 size_t read_index
= 0;
679 size_t write_count
= 0;
680 uint8_t *buffer
= kitprog_handle
->packet_buffer
;
683 LOG_DEBUG_IO("Executing %d queued transactions", pending_transfer_count
);
685 if (queued_retval
!= ERROR_OK
) {
686 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval
);
690 if (!pending_transfer_count
)
693 for (int i
= 0; i
< pending_transfer_count
; i
++) {
694 uint8_t cmd
= pending_transfers
[i
].cmd
;
695 uint32_t data
= pending_transfers
[i
].data
;
697 /* When proper WAIT handling is implemented in the
698 * common SWD framework, this kludge can be
699 * removed. However, this might lead to minor
700 * performance degradation as the adapter wouldn't be
701 * able to automatically retry anything (because ARM
702 * has forgotten to implement sticky error flags
703 * clearing). See also comments regarding
704 * cmsis_dap_cmd_DAP_TFER_Configure() and
705 * cmsis_dap_cmd_DAP_SWD_Configure() in
708 if (!(cmd
& SWD_CMD_RNW
) &&
709 !(cmd
& SWD_CMD_APNDP
) &&
710 (cmd
& SWD_CMD_A32
) >> 1 == DP_CTRL_STAT
&&
711 (data
& CORUNDETECT
)) {
712 LOG_DEBUG("refusing to enable sticky overrun detection");
713 data
&= ~CORUNDETECT
;
716 LOG_DEBUG_IO("%s %s reg %x %"PRIx32
,
717 cmd
& SWD_CMD_APNDP
? "AP" : "DP",
718 cmd
& SWD_CMD_RNW
? "read" : "write",
719 (cmd
& SWD_CMD_A32
) >> 1, data
);
721 buffer
[write_count
++] = (cmd
| SWD_CMD_START
| SWD_CMD_PARK
) & ~SWD_CMD_STOP
;
723 if (!(cmd
& SWD_CMD_RNW
)) {
724 buffer
[write_count
++] = (data
) & 0xff;
725 buffer
[write_count
++] = (data
>> 8) & 0xff;
726 buffer
[write_count
++] = (data
>> 16) & 0xff;
727 buffer
[write_count
++] = (data
>> 24) & 0xff;
733 if (jtag_libusb_bulk_write(kitprog_handle
->usb_handle
,
734 BULK_EP_OUT
, (char *)buffer
,
735 write_count
, 0, &ret
)) {
736 LOG_ERROR("Bulk write failed");
737 queued_retval
= ERROR_FAIL
;
740 queued_retval
= ERROR_OK
;
743 /* KitProg firmware does not send a zero length packet
744 * after the bulk-in transmission of a length divisible by bulk packet
745 * size (64 bytes) as required by the USB specification.
746 * Therefore libusb would wait for continuation of transmission.
747 * Workaround: Limit bulk read size to expected number of bytes
748 * for problematic transfer sizes. Otherwise use the maximum buffer
749 * size here because the KitProg sometimes doesn't like bulk reads
750 * of fewer than 62 bytes. (?!?!)
752 size_t read_count_workaround
= SWD_MAX_BUFFER_LENGTH
;
753 if (read_count
% 64 == 0)
754 read_count_workaround
= read_count
;
756 if (jtag_libusb_bulk_read(kitprog_handle
->usb_handle
,
757 BULK_EP_IN
| LIBUSB_ENDPOINT_IN
, (char *)buffer
,
758 read_count_workaround
, 1000, &ret
)) {
759 LOG_ERROR("Bulk read failed");
760 queued_retval
= ERROR_FAIL
;
763 /* Handle garbage data by offsetting the initial read index */
764 if ((unsigned int)ret
> read_count
)
765 read_index
= ret
- read_count
;
766 queued_retval
= ERROR_OK
;
769 for (int i
= 0; i
< pending_transfer_count
; i
++) {
770 if (pending_transfers
[i
].cmd
& SWD_CMD_RNW
) {
771 uint32_t data
= le_to_h_u32(&buffer
[read_index
]);
773 LOG_DEBUG_IO("Read result: %"PRIx32
, data
);
775 if (pending_transfers
[i
].buffer
)
776 *(uint32_t *)pending_transfers
[i
].buffer
= data
;
781 uint8_t ack
= buffer
[read_index
] & 0x07;
782 if (ack
!= SWD_ACK_OK
|| (buffer
[read_index
] & 0x08)) {
783 LOG_DEBUG("SWD ack not OK: %d %s", i
,
784 ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK");
785 queued_retval
= swd_ack_to_error_code(ack
);
792 pending_transfer_count
= 0;
793 int retval
= queued_retval
;
794 queued_retval
= ERROR_OK
;
799 static void kitprog_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
)
801 if (pending_transfer_count
== pending_queue_len
) {
802 /* Not enough room in the queue. Run the queue. */
803 queued_retval
= kitprog_swd_run_queue();
806 if (queued_retval
!= ERROR_OK
)
809 pending_transfers
[pending_transfer_count
].data
= data
;
810 pending_transfers
[pending_transfer_count
].cmd
= cmd
;
811 if (cmd
& SWD_CMD_RNW
) {
812 /* Queue a read transaction */
813 pending_transfers
[pending_transfer_count
].buffer
= dst
;
815 pending_transfer_count
++;
818 /*************** jtag lowlevel functions ********************/
820 static int kitprog_reset(int trst
, int srst
)
822 int retval
= ERROR_OK
;
825 LOG_ERROR("KitProg: Interface has no TRST");
830 retval
= kitprog_reset_target();
831 /* Since the previous command also disables SWCLK output, we need to send an
832 * SWD bus reset command to re-enable it. For some reason, running
833 * kitprog_swd_seq() immediately after kitprog_reset_target() won't
834 * actually fix this. Instead, kitprog_swd_seq() will be run once OpenOCD
835 * tries to send a JTAG-to-SWD sequence, which should happen during
836 * swd_check_reconnect (see the JTAG_TO_SWD case in kitprog_swd_switch_seq).
840 if (retval
!= ERROR_OK
)
841 LOG_ERROR("KitProg: Interface reset failed");
845 COMMAND_HANDLER(kitprog_handle_info_command
)
847 int retval
= kitprog_get_info();
853 COMMAND_HANDLER(kitprog_handle_acquire_psoc_command
)
855 int retval
= kitprog_generic_acquire();
860 COMMAND_HANDLER(kitprog_handle_init_acquire_psoc_command
)
862 kitprog_init_acquire_psoc
= true;
867 static const struct command_registration kitprog_subcommand_handlers
[] = {
870 .handler
= &kitprog_handle_info_command
,
871 .mode
= COMMAND_EXEC
,
873 .help
= "show KitProg info",
876 .name
= "acquire_psoc",
877 .handler
= &kitprog_handle_acquire_psoc_command
,
878 .mode
= COMMAND_EXEC
,
880 .help
= "try to acquire a PSoC",
883 .name
= "init_acquire_psoc",
884 .handler
= &kitprog_handle_init_acquire_psoc_command
,
885 .mode
= COMMAND_CONFIG
,
886 .help
= "try to acquire a PSoC during init",
889 COMMAND_REGISTRATION_DONE
892 static const struct command_registration kitprog_command_handlers
[] = {
896 .help
= "perform KitProg management",
898 .chain
= kitprog_subcommand_handlers
,
900 COMMAND_REGISTRATION_DONE
903 static const struct swd_driver kitprog_swd
= {
904 .init
= kitprog_swd_init
,
905 .switch_seq
= kitprog_swd_switch_seq
,
906 .read_reg
= kitprog_swd_read_reg
,
907 .write_reg
= kitprog_swd_write_reg
,
908 .run
= kitprog_swd_run_queue
,
911 static const char * const kitprog_transports
[] = { "swd", NULL
};
913 struct adapter_driver kitprog_adapter_driver
= {
915 .transports
= kitprog_transports
,
916 .commands
= kitprog_command_handlers
,
918 .init
= kitprog_init
,
919 .quit
= kitprog_quit
,
920 .reset
= kitprog_reset
,
922 .swd_ops
= &kitprog_swd
,
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)