1 /***************************************************************************
2 * Copyright (C) 2007 by Juergen Stuber <juergen@jstuber.net> *
3 * based on Dominic Rath's and Benedikt Sauter's usbprog.c *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
8 * Copyright (C) 2011 by Jean-Christophe PLAGNIOL-VIILARD *
9 * plagnioj@jcrosoft.com *
11 * Copyright (C) 2015 by Marc Schink *
12 * openocd-dev@marcschink.de *
14 * Copyright (C) 2015 by Paul Fertser *
15 * fercerpav@gmail.com *
17 * Copyright (C) 2015-2017 by Forest Crossman *
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. *
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. *
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 ***************************************************************************/
42 #include <jtag/adapter.h>
43 #include <jtag/interface.h>
45 #include <jtag/commands.h>
47 #include "libusb_helper.h"
55 #define CONTROL_TYPE_READ 0x01
56 #define CONTROL_TYPE_WRITE 0x02
58 #define CONTROL_COMMAND_PROGRAM 0x07
60 #define CONTROL_MODE_POLL_PROGRAMMER_STATUS 0x01
61 #define CONTROL_MODE_RESET_TARGET 0x04
62 #define CONTROL_MODE_SET_PROGRAMMER_PROTOCOL 0x40
63 #define CONTROL_MODE_SYNCHRONIZE_TRANSFER 0x41
64 #define CONTROL_MODE_ACQUIRE_SWD_TARGET 0x42
65 #define CONTROL_MODE_SEND_SWD_SEQUENCE 0x43
67 #define PROTOCOL_JTAG 0x00
68 #define PROTOCOL_SWD 0x01
70 #define DEVICE_PSOC4 0x00
71 #define DEVICE_PSOC3 0x01
72 #define DEVICE_UNKNOWN 0x02
73 #define DEVICE_PSOC5 0x03
75 #define ACQUIRE_MODE_RESET 0x00
76 #define ACQUIRE_MODE_POWER_CYCLE 0x01
78 #define SEQUENCE_LINE_RESET 0x00
79 #define SEQUENCE_JTAG_TO_SWD 0x01
81 #define PROGRAMMER_NOK_NACK 0x00
82 #define PROGRAMMER_OK_ACK 0x01
84 #define HID_TYPE_WRITE 0x00
85 #define HID_TYPE_READ 0x01
86 #define HID_TYPE_START 0x02
88 #define HID_COMMAND_POWER 0x80
89 #define HID_COMMAND_VERSION 0x81
90 #define HID_COMMAND_RESET 0x82
91 #define HID_COMMAND_CONFIGURE 0x8f
92 #define HID_COMMAND_BOOTLOADER 0xa0
94 /* 512 bytes seems to work reliably */
95 #define SWD_MAX_BUFFER_LENGTH 512
98 hid_device
*hid_handle
;
99 struct libusb_device_handle
*usb_handle
;
100 uint16_t packet_size
;
101 uint16_t packet_index
;
102 uint8_t *packet_buffer
;
104 uint8_t hardware_version
;
105 uint8_t minor_version
;
106 uint8_t major_version
;
109 bool supports_jtag_to_swd
;
112 struct pending_transfer_result
{
118 static bool kitprog_init_acquire_psoc
;
120 static int pending_transfer_count
, pending_queue_len
;
121 static struct pending_transfer_result
*pending_transfers
;
123 static int queued_retval
;
125 static struct kitprog
*kitprog_handle
;
127 static int kitprog_usb_open(void);
128 static void kitprog_usb_close(void);
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
);
144 static int kitprog_generic_acquire(void);
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
);
151 static inline int mm_to_version(uint8_t major
, uint8_t minor
)
153 return (major
<< 8) | minor
;
156 static int kitprog_init(void)
160 kitprog_handle
= malloc(sizeof(struct kitprog
));
161 if (!kitprog_handle
) {
162 LOG_ERROR("Failed to allocate memory");
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
;
171 /* Get the current KitProg version and target voltage */
172 if (kitprog_get_info() != ERROR_OK
)
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;
183 /* I have no idea what this does */
184 if (kitprog_set_unknown() != ERROR_OK
)
187 /* SWD won't work unless we do this */
188 if (kitprog_swd_sync() != ERROR_OK
)
191 /* Set the protocol to SWD */
192 if (kitprog_set_protocol(PROTOCOL_SWD
) != ERROR_OK
)
195 /* Reset the SWD bus */
196 if (kitprog_swd_seq(SEQUENCE_LINE_RESET
) != ERROR_OK
)
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");
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
) {
212 LOG_ERROR("Failed to allocate memory for the packet buffer");
216 pending_queue_len
= SWD_MAX_BUFFER_LENGTH
/ 5;
217 pending_transfers
= malloc(pending_queue_len
* sizeof(*pending_transfers
));
218 if (!pending_transfers
) {
219 LOG_ERROR("Failed to allocate memory for the SWD transfer queue");
226 static int kitprog_quit(void)
230 free(kitprog_handle
->packet_buffer
);
231 free(kitprog_handle
->serial
);
232 free(kitprog_handle
);
233 free(pending_transfers
);
238 /*************** kitprog usb functions *********************/
240 static int kitprog_get_usb_serial(void)
243 const uint8_t str_index
= 128; /* This seems to be a constant */
244 char desc_string
[256+1]; /* Max size of string descriptor */
246 retval
= libusb_get_string_descriptor_ascii(kitprog_handle
->usb_handle
,
247 str_index
, (unsigned char *)desc_string
, sizeof(desc_string
)-1);
249 LOG_ERROR("libusb_get_string_descriptor_ascii() failed with %d", retval
);
253 /* Null terminate descriptor string */
254 desc_string
[retval
] = '\0';
256 /* Allocate memory for the serial number */
257 kitprog_handle
->serial
= calloc(retval
+ 1, sizeof(char));
258 if (!kitprog_handle
->serial
) {
259 LOG_ERROR("Failed to allocate memory for the serial number");
263 /* Store the serial number */
264 strncpy(kitprog_handle
->serial
, desc_string
, retval
+ 1);
269 static int kitprog_usb_open(void)
271 const uint16_t vids
[] = { VID
, 0 };
272 const uint16_t pids
[] = { PID
, 0 };
274 if (jtag_libusb_open(vids
, pids
, adapter_get_required_serial(),
275 &kitprog_handle
->usb_handle
, NULL
) != ERROR_OK
) {
276 LOG_ERROR("Failed to open or find the device");
280 /* Get the serial number for the device */
281 if (kitprog_get_usb_serial() != ERROR_OK
)
282 LOG_WARNING("Failed to get KitProg serial number");
284 /* Convert the ASCII serial number into a (wchar_t *) */
285 size_t len
= strlen(kitprog_handle
->serial
);
286 wchar_t *hid_serial
= calloc(len
+ 1, sizeof(wchar_t));
288 LOG_ERROR("Failed to allocate memory for the serial number");
291 if (mbstowcs(hid_serial
, kitprog_handle
->serial
, len
+ 1) == (size_t)-1) {
293 LOG_ERROR("Failed to convert serial number");
297 /* Use HID for the KitBridge interface */
298 kitprog_handle
->hid_handle
= hid_open(VID
, PID
, hid_serial
);
300 if (!kitprog_handle
->hid_handle
) {
301 LOG_ERROR("Failed to open KitBridge (HID) interface");
305 /* Claim the KitProg Programmer (bulk transfer) interface */
306 if (libusb_claim_interface(kitprog_handle
->usb_handle
, 1) != ERROR_OK
) {
307 LOG_ERROR("Failed to claim KitProg Programmer (bulk transfer) interface");
314 static void kitprog_usb_close(void)
316 if (kitprog_handle
->hid_handle
) {
317 hid_close(kitprog_handle
->hid_handle
);
321 jtag_libusb_close(kitprog_handle
->usb_handle
);
324 /*************** kitprog lowlevel functions *********************/
326 static int kitprog_hid_command(uint8_t *command
, size_t command_length
,
327 uint8_t *data
, size_t data_length
)
331 ret
= hid_write(kitprog_handle
->hid_handle
, command
, command_length
);
333 LOG_DEBUG("HID write returned %i", ret
);
337 ret
= hid_read(kitprog_handle
->hid_handle
, data
, data_length
);
339 LOG_DEBUG("HID read returned %i", ret
);
346 static int kitprog_get_version(void)
350 unsigned char command
[3] = {HID_TYPE_START
| HID_TYPE_WRITE
, 0x00, HID_COMMAND_VERSION
};
351 unsigned char data
[64];
353 ret
= kitprog_hid_command(command
, sizeof(command
), data
, sizeof(data
));
357 kitprog_handle
->hardware_version
= data
[1];
358 kitprog_handle
->minor_version
= data
[2];
359 kitprog_handle
->major_version
= data
[3];
364 static int kitprog_get_millivolts(void)
368 unsigned char command
[3] = {HID_TYPE_START
| HID_TYPE_READ
, 0x00, HID_COMMAND_POWER
};
369 unsigned char data
[64];
371 ret
= kitprog_hid_command(command
, sizeof(command
), data
, sizeof(data
));
375 kitprog_handle
->millivolts
= (data
[4] << 8) | data
[3];
380 static int kitprog_get_info(void)
382 /* Get the device version information */
383 if (kitprog_get_version() == ERROR_OK
) {
384 LOG_INFO("KitProg v%u.%02u",
385 kitprog_handle
->major_version
, kitprog_handle
->minor_version
);
386 LOG_INFO("Hardware version: %u",
387 kitprog_handle
->hardware_version
);
389 LOG_ERROR("Failed to get KitProg version");
393 /* Get the current reported target voltage */
394 if (kitprog_get_millivolts() == ERROR_OK
) {
395 LOG_INFO("VTARG = %u.%03u V",
396 kitprog_handle
->millivolts
/ 1000, kitprog_handle
->millivolts
% 1000);
398 LOG_ERROR("Failed to get target voltage");
405 static int kitprog_set_protocol(uint8_t protocol
)
408 char status
= PROGRAMMER_NOK_NACK
;
410 transferred
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
411 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
413 (CONTROL_MODE_SET_PROGRAMMER_PROTOCOL
<< 8) | CONTROL_COMMAND_PROGRAM
,
414 protocol
, &status
, 1, 0);
416 if (transferred
== 0) {
417 LOG_DEBUG("Zero bytes transferred");
421 if (status
!= PROGRAMMER_OK_ACK
) {
422 LOG_DEBUG("Programmer did not respond OK");
429 static int kitprog_get_status(void)
432 char status
= PROGRAMMER_NOK_NACK
;
434 /* Try a maximum of three times */
435 for (int i
= 0; (i
< 3) && (transferred
== 0); i
++) {
436 transferred
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
437 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
439 (CONTROL_MODE_POLL_PROGRAMMER_STATUS
<< 8) | CONTROL_COMMAND_PROGRAM
,
444 if (transferred
== 0) {
445 LOG_DEBUG("Zero bytes transferred");
449 if (status
!= PROGRAMMER_OK_ACK
) {
450 LOG_DEBUG("Programmer did not respond OK");
457 static int kitprog_set_unknown(void)
460 char status
= PROGRAMMER_NOK_NACK
;
462 transferred
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
463 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
468 if (transferred
== 0) {
469 LOG_DEBUG("Zero bytes transferred");
473 if (status
!= PROGRAMMER_OK_ACK
) {
474 LOG_DEBUG("Programmer did not respond OK");
481 static int kitprog_acquire_psoc(uint8_t psoc_type
, uint8_t acquire_mode
,
482 uint8_t max_attempts
)
485 char status
= PROGRAMMER_NOK_NACK
;
487 transferred
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
488 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
490 (CONTROL_MODE_ACQUIRE_SWD_TARGET
<< 8) | CONTROL_COMMAND_PROGRAM
,
491 (max_attempts
<< 8) | (acquire_mode
<< 4) | psoc_type
, &status
, 1, 0);
493 if (transferred
== 0) {
494 LOG_DEBUG("Zero bytes transferred");
498 if (status
!= PROGRAMMER_OK_ACK
) {
499 LOG_DEBUG("Programmer did not respond OK");
506 static int kitprog_reset_target(void)
509 char status
= PROGRAMMER_NOK_NACK
;
511 transferred
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
512 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
514 (CONTROL_MODE_RESET_TARGET
<< 8) | CONTROL_COMMAND_PROGRAM
,
517 if (transferred
== 0) {
518 LOG_DEBUG("Zero bytes transferred");
522 if (status
!= PROGRAMMER_OK_ACK
) {
523 LOG_DEBUG("Programmer did not respond OK");
530 static int kitprog_swd_sync(void)
533 char status
= PROGRAMMER_NOK_NACK
;
535 transferred
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
536 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
538 (CONTROL_MODE_SYNCHRONIZE_TRANSFER
<< 8) | CONTROL_COMMAND_PROGRAM
,
541 if (transferred
== 0) {
542 LOG_DEBUG("Zero bytes transferred");
546 if (status
!= PROGRAMMER_OK_ACK
) {
547 LOG_DEBUG("Programmer did not respond OK");
554 static int kitprog_swd_seq(uint8_t seq_type
)
557 char status
= PROGRAMMER_NOK_NACK
;
559 transferred
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
560 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
562 (CONTROL_MODE_SEND_SWD_SEQUENCE
<< 8) | CONTROL_COMMAND_PROGRAM
,
563 seq_type
, &status
, 1, 0);
565 if (transferred
== 0) {
566 LOG_DEBUG("Zero bytes transferred");
570 if (status
!= PROGRAMMER_OK_ACK
) {
571 LOG_DEBUG("Programmer did not respond OK");
578 static int kitprog_generic_acquire(void)
580 const uint8_t devices
[] = {DEVICE_PSOC4
, DEVICE_PSOC3
, DEVICE_PSOC5
};
583 int acquire_count
= 0;
585 /* Due to the way the SWD port is shared between the Test Controller (TC)
586 * and the Cortex-M3 DAP on the PSoC 5LP, the TC is the default SWD target
587 * after power is applied. To access the DAP, the PSoC 5LP requires at least
588 * one acquisition sequence to be run (which switches the SWD mux from the
589 * TC to the DAP). However, after the mux is switched, the Cortex-M3 will be
590 * held in reset until a series of registers are written to (see section 5.2
591 * of the PSoC 5LP Device Programming Specifications for details).
593 * Instead of writing the registers in this function, we just do what the
594 * Cypress tools do and run the acquisition sequence a second time. This
595 * will take the Cortex-M3 out of reset and enable debugging.
597 for (int i
= 0; i
< 2; i
++) {
598 for (uint8_t j
= 0; j
< sizeof(devices
) && acquire_count
== i
; j
++) {
599 retval
= kitprog_acquire_psoc(devices
[j
], ACQUIRE_MODE_RESET
, 3);
600 if (retval
!= ERROR_OK
) {
601 LOG_DEBUG("Acquisition function failed for device 0x%02x.", devices
[j
]);
605 if (kitprog_get_status() == ERROR_OK
)
612 if (acquire_count
< 2)
618 /*************** swd wrapper functions *********************/
620 static int kitprog_swd_init(void)
625 static void kitprog_swd_write_reg(uint8_t cmd
, uint32_t value
, uint32_t ap_delay_clk
)
627 assert(!(cmd
& SWD_CMD_RNW
));
628 kitprog_swd_queue_cmd(cmd
, NULL
, value
);
631 static void kitprog_swd_read_reg(uint8_t cmd
, uint32_t *value
, uint32_t ap_delay_clk
)
633 assert(cmd
& SWD_CMD_RNW
);
634 kitprog_swd_queue_cmd(cmd
, value
, 0);
637 /*************** swd lowlevel functions ********************/
639 static int kitprog_swd_switch_seq(enum swd_special_seq seq
)
643 if (kitprog_handle
->supports_jtag_to_swd
) {
644 LOG_DEBUG("JTAG to SWD");
645 if (kitprog_swd_seq(SEQUENCE_JTAG_TO_SWD
) != ERROR_OK
)
649 LOG_DEBUG("JTAG to SWD not supported");
650 /* Fall through to fix target reset issue */
654 LOG_DEBUG("SWD line reset");
655 if (kitprog_swd_seq(SEQUENCE_LINE_RESET
) != ERROR_OK
)
659 LOG_ERROR("Sequence %d not supported.", seq
);
666 static int kitprog_swd_run_queue(void)
670 size_t read_count
= 0;
671 size_t read_index
= 0;
672 size_t write_count
= 0;
673 uint8_t *buffer
= kitprog_handle
->packet_buffer
;
676 LOG_DEBUG_IO("Executing %d queued transactions", pending_transfer_count
);
678 if (queued_retval
!= ERROR_OK
) {
679 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval
);
683 if (!pending_transfer_count
)
686 for (int i
= 0; i
< pending_transfer_count
; i
++) {
687 uint8_t cmd
= pending_transfers
[i
].cmd
;
688 uint32_t data
= pending_transfers
[i
].data
;
690 /* When proper WAIT handling is implemented in the
691 * common SWD framework, this kludge can be
692 * removed. However, this might lead to minor
693 * performance degradation as the adapter wouldn't be
694 * able to automatically retry anything (because ARM
695 * has forgotten to implement sticky error flags
696 * clearing). See also comments regarding
697 * cmsis_dap_cmd_DAP_TFER_Configure() and
698 * cmsis_dap_cmd_DAP_SWD_Configure() in
701 if (!(cmd
& SWD_CMD_RNW
) &&
702 !(cmd
& SWD_CMD_APNDP
) &&
703 (cmd
& SWD_CMD_A32
) >> 1 == DP_CTRL_STAT
&&
704 (data
& CORUNDETECT
)) {
705 LOG_DEBUG("refusing to enable sticky overrun detection");
706 data
&= ~CORUNDETECT
;
709 LOG_DEBUG_IO("%s %s reg %x %"PRIx32
,
710 cmd
& SWD_CMD_APNDP
? "AP" : "DP",
711 cmd
& SWD_CMD_RNW
? "read" : "write",
712 (cmd
& SWD_CMD_A32
) >> 1, data
);
714 buffer
[write_count
++] = (cmd
| SWD_CMD_START
| SWD_CMD_PARK
) & ~SWD_CMD_STOP
;
716 if (!(cmd
& SWD_CMD_RNW
)) {
717 buffer
[write_count
++] = (data
) & 0xff;
718 buffer
[write_count
++] = (data
>> 8) & 0xff;
719 buffer
[write_count
++] = (data
>> 16) & 0xff;
720 buffer
[write_count
++] = (data
>> 24) & 0xff;
726 if (jtag_libusb_bulk_write(kitprog_handle
->usb_handle
,
727 BULK_EP_OUT
, (char *)buffer
,
728 write_count
, 0, &ret
)) {
729 LOG_ERROR("Bulk write failed");
730 queued_retval
= ERROR_FAIL
;
733 queued_retval
= ERROR_OK
;
736 /* KitProg firmware does not send a zero length packet
737 * after the bulk-in transmission of a length divisible by bulk packet
738 * size (64 bytes) as required by the USB specification.
739 * Therefore libusb would wait for continuation of transmission.
740 * Workaround: Limit bulk read size to expected number of bytes
741 * for problematic transfer sizes. Otherwise use the maximum buffer
742 * size here because the KitProg sometimes doesn't like bulk reads
743 * of fewer than 62 bytes. (?!?!)
745 size_t read_count_workaround
= SWD_MAX_BUFFER_LENGTH
;
746 if (read_count
% 64 == 0)
747 read_count_workaround
= read_count
;
749 if (jtag_libusb_bulk_read(kitprog_handle
->usb_handle
,
750 BULK_EP_IN
| LIBUSB_ENDPOINT_IN
, (char *)buffer
,
751 read_count_workaround
, 1000, &ret
)) {
752 LOG_ERROR("Bulk read failed");
753 queued_retval
= ERROR_FAIL
;
756 /* Handle garbage data by offsetting the initial read index */
757 if ((unsigned int)ret
> read_count
)
758 read_index
= ret
- read_count
;
759 queued_retval
= ERROR_OK
;
762 for (int i
= 0; i
< pending_transfer_count
; i
++) {
763 if (pending_transfers
[i
].cmd
& SWD_CMD_RNW
) {
764 uint32_t data
= le_to_h_u32(&buffer
[read_index
]);
766 LOG_DEBUG_IO("Read result: %"PRIx32
, data
);
768 if (pending_transfers
[i
].buffer
)
769 *(uint32_t *)pending_transfers
[i
].buffer
= data
;
774 uint8_t ack
= buffer
[read_index
] & 0x07;
775 if (ack
!= SWD_ACK_OK
|| (buffer
[read_index
] & 0x08)) {
776 LOG_DEBUG("SWD ack not OK: %d %s", i
,
777 ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK");
778 queued_retval
= ack
== SWD_ACK_WAIT
? ERROR_WAIT
: ERROR_FAIL
;
785 pending_transfer_count
= 0;
786 int retval
= queued_retval
;
787 queued_retval
= ERROR_OK
;
792 static void kitprog_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
)
794 if (pending_transfer_count
== pending_queue_len
) {
795 /* Not enough room in the queue. Run the queue. */
796 queued_retval
= kitprog_swd_run_queue();
799 if (queued_retval
!= ERROR_OK
)
802 pending_transfers
[pending_transfer_count
].data
= data
;
803 pending_transfers
[pending_transfer_count
].cmd
= cmd
;
804 if (cmd
& SWD_CMD_RNW
) {
805 /* Queue a read transaction */
806 pending_transfers
[pending_transfer_count
].buffer
= dst
;
808 pending_transfer_count
++;
811 /*************** jtag lowlevel functions ********************/
813 static int kitprog_reset(int trst
, int srst
)
815 int retval
= ERROR_OK
;
818 LOG_ERROR("KitProg: Interface has no TRST");
823 retval
= kitprog_reset_target();
824 /* Since the previous command also disables SWCLK output, we need to send an
825 * SWD bus reset command to re-enable it. For some reason, running
826 * kitprog_swd_seq() immediately after kitprog_reset_target() won't
827 * actually fix this. Instead, kitprog_swd_seq() will be run once OpenOCD
828 * tries to send a JTAG-to-SWD sequence, which should happen during
829 * swd_check_reconnect (see the JTAG_TO_SWD case in kitprog_swd_switch_seq).
833 if (retval
!= ERROR_OK
)
834 LOG_ERROR("KitProg: Interface reset failed");
838 COMMAND_HANDLER(kitprog_handle_info_command
)
840 int retval
= kitprog_get_info();
846 COMMAND_HANDLER(kitprog_handle_acquire_psoc_command
)
848 int retval
= kitprog_generic_acquire();
853 COMMAND_HANDLER(kitprog_handle_init_acquire_psoc_command
)
855 kitprog_init_acquire_psoc
= true;
860 static const struct command_registration kitprog_subcommand_handlers
[] = {
863 .handler
= &kitprog_handle_info_command
,
864 .mode
= COMMAND_EXEC
,
866 .help
= "show KitProg info",
869 .name
= "acquire_psoc",
870 .handler
= &kitprog_handle_acquire_psoc_command
,
871 .mode
= COMMAND_EXEC
,
873 .help
= "try to acquire a PSoC",
875 COMMAND_REGISTRATION_DONE
878 static const struct command_registration kitprog_command_handlers
[] = {
882 .help
= "perform KitProg management",
884 .chain
= kitprog_subcommand_handlers
,
887 .name
= "kitprog_init_acquire_psoc",
888 .handler
= &kitprog_handle_init_acquire_psoc_command
,
889 .mode
= COMMAND_CONFIG
,
890 .help
= "try to acquire a PSoC during init",
893 COMMAND_REGISTRATION_DONE
896 static const struct swd_driver kitprog_swd
= {
897 .init
= kitprog_swd_init
,
898 .switch_seq
= kitprog_swd_switch_seq
,
899 .read_reg
= kitprog_swd_read_reg
,
900 .write_reg
= kitprog_swd_write_reg
,
901 .run
= kitprog_swd_run_queue
,
904 static const char * const kitprog_transports
[] = { "swd", NULL
};
906 struct adapter_driver kitprog_adapter_driver
= {
908 .transports
= kitprog_transports
,
909 .commands
= kitprog_command_handlers
,
911 .init
= kitprog_init
,
912 .quit
= kitprog_quit
,
913 .reset
= kitprog_reset
,
915 .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)