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/interface.h>
44 #include <jtag/commands.h>
46 #include "libusb_helper.h"
54 #define CONTROL_TYPE_READ 0x01
55 #define CONTROL_TYPE_WRITE 0x02
57 #define CONTROL_COMMAND_PROGRAM 0x07
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
66 #define PROTOCOL_JTAG 0x00
67 #define PROTOCOL_SWD 0x01
69 #define DEVICE_PSOC4 0x00
70 #define DEVICE_PSOC3 0x01
71 #define DEVICE_UNKNOWN 0x02
72 #define DEVICE_PSOC5 0x03
74 #define ACQUIRE_MODE_RESET 0x00
75 #define ACQUIRE_MODE_POWER_CYCLE 0x01
77 #define SEQUENCE_LINE_RESET 0x00
78 #define SEQUENCE_JTAG_TO_SWD 0x01
80 #define PROGRAMMER_NOK_NACK 0x00
81 #define PROGRAMMER_OK_ACK 0x01
83 #define HID_TYPE_WRITE 0x00
84 #define HID_TYPE_READ 0x01
85 #define HID_TYPE_START 0x02
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
93 /* 512 bytes seems to work reliably */
94 #define SWD_MAX_BUFFER_LENGTH 512
97 hid_device
*hid_handle
;
98 struct libusb_device_handle
*usb_handle
;
100 uint16_t packet_index
;
101 uint8_t *packet_buffer
;
103 uint8_t hardware_version
;
104 uint8_t minor_version
;
105 uint8_t major_version
;
108 bool supports_jtag_to_swd
;
111 struct pending_transfer_result
{
117 static char *kitprog_serial
;
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
== NULL
) {
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
== NULL
) {
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
== NULL
) {
219 LOG_ERROR("Failed to allocate memory for the SWD transfer queue");
226 static int kitprog_quit(void)
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
);
237 if (kitprog_serial
!= NULL
)
238 free(kitprog_serial
);
240 if (pending_transfers
!= NULL
)
241 free(pending_transfers
);
246 /*************** kitprog usb functions *********************/
248 static int kitprog_get_usb_serial(void)
251 const uint8_t str_index
= 128; /* This seems to be a constant */
252 char desc_string
[256+1]; /* Max size of string descriptor */
254 retval
= libusb_get_string_descriptor_ascii(kitprog_handle
->usb_handle
,
255 str_index
, (unsigned char *)desc_string
, sizeof(desc_string
)-1);
257 LOG_ERROR("libusb_get_string_descriptor_ascii() failed with %d", retval
);
261 /* Null terminate descriptor string */
262 desc_string
[retval
] = '\0';
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");
271 /* Store the serial number */
272 strncpy(kitprog_handle
->serial
, desc_string
, retval
+ 1);
277 static int kitprog_usb_open(void)
279 const uint16_t vids
[] = { VID
, 0 };
280 const uint16_t pids
[] = { PID
, 0 };
282 if (jtag_libusb_open(vids
, pids
, kitprog_serial
,
283 &kitprog_handle
->usb_handle
, NULL
) != ERROR_OK
) {
284 LOG_ERROR("Failed to open or find the device");
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");
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");
299 if (mbstowcs(hid_serial
, kitprog_handle
->serial
, len
+ 1) == (size_t)-1) {
301 LOG_ERROR("Failed to convert serial number");
305 /* Use HID for the KitBridge interface */
306 kitprog_handle
->hid_handle
= hid_open(VID
, PID
, hid_serial
);
308 if (kitprog_handle
->hid_handle
== NULL
) {
309 LOG_ERROR("Failed to open KitBridge (HID) interface");
313 /* Claim the KitProg Programmer (bulk transfer) interface */
314 if (libusb_claim_interface(kitprog_handle
->usb_handle
, 1) != ERROR_OK
) {
315 LOG_ERROR("Failed to claim KitProg Programmer (bulk transfer) interface");
322 static void kitprog_usb_close(void)
324 if (kitprog_handle
->hid_handle
!= NULL
) {
325 hid_close(kitprog_handle
->hid_handle
);
329 jtag_libusb_close(kitprog_handle
->usb_handle
);
332 /*************** kitprog lowlevel functions *********************/
334 static int kitprog_hid_command(uint8_t *command
, size_t command_length
,
335 uint8_t *data
, size_t data_length
)
339 ret
= hid_write(kitprog_handle
->hid_handle
, command
, command_length
);
341 LOG_DEBUG("HID write returned %i", ret
);
345 ret
= hid_read(kitprog_handle
->hid_handle
, data
, data_length
);
347 LOG_DEBUG("HID read returned %i", ret
);
354 static int kitprog_get_version(void)
358 unsigned char command
[3] = {HID_TYPE_START
| HID_TYPE_WRITE
, 0x00, HID_COMMAND_VERSION
};
359 unsigned char data
[64];
361 ret
= kitprog_hid_command(command
, sizeof command
, data
, sizeof data
);
365 kitprog_handle
->hardware_version
= data
[1];
366 kitprog_handle
->minor_version
= data
[2];
367 kitprog_handle
->major_version
= data
[3];
372 static int kitprog_get_millivolts(void)
376 unsigned char command
[3] = {HID_TYPE_START
| HID_TYPE_READ
, 0x00, HID_COMMAND_POWER
};
377 unsigned char data
[64];
379 ret
= kitprog_hid_command(command
, sizeof command
, data
, sizeof data
);
383 kitprog_handle
->millivolts
= (data
[4] << 8) | data
[3];
388 static int kitprog_get_info(void)
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
);
397 LOG_ERROR("Failed to get KitProg version");
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);
406 LOG_ERROR("Failed to get target voltage");
413 static int kitprog_set_protocol(uint8_t protocol
)
416 char status
= PROGRAMMER_NOK_NACK
;
418 transferred
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
419 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
421 (CONTROL_MODE_SET_PROGRAMMER_PROTOCOL
<< 8) | CONTROL_COMMAND_PROGRAM
,
422 protocol
, &status
, 1, 0);
424 if (transferred
== 0) {
425 LOG_DEBUG("Zero bytes transferred");
429 if (status
!= PROGRAMMER_OK_ACK
) {
430 LOG_DEBUG("Programmer did not respond OK");
437 static int kitprog_get_status(void)
440 char status
= PROGRAMMER_NOK_NACK
;
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
,
447 (CONTROL_MODE_POLL_PROGRAMMER_STATUS
<< 8) | CONTROL_COMMAND_PROGRAM
,
452 if (transferred
== 0) {
453 LOG_DEBUG("Zero bytes transferred");
457 if (status
!= PROGRAMMER_OK_ACK
) {
458 LOG_DEBUG("Programmer did not respond OK");
465 static int kitprog_set_unknown(void)
468 char status
= PROGRAMMER_NOK_NACK
;
470 transferred
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
471 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
476 if (transferred
== 0) {
477 LOG_DEBUG("Zero bytes transferred");
481 if (status
!= PROGRAMMER_OK_ACK
) {
482 LOG_DEBUG("Programmer did not respond OK");
489 static int kitprog_acquire_psoc(uint8_t psoc_type
, uint8_t acquire_mode
,
490 uint8_t max_attempts
)
493 char status
= PROGRAMMER_NOK_NACK
;
495 transferred
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
496 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
498 (CONTROL_MODE_ACQUIRE_SWD_TARGET
<< 8) | CONTROL_COMMAND_PROGRAM
,
499 (max_attempts
<< 8) | (acquire_mode
<< 4) | psoc_type
, &status
, 1, 0);
501 if (transferred
== 0) {
502 LOG_DEBUG("Zero bytes transferred");
506 if (status
!= PROGRAMMER_OK_ACK
) {
507 LOG_DEBUG("Programmer did not respond OK");
514 static int kitprog_reset_target(void)
517 char status
= PROGRAMMER_NOK_NACK
;
519 transferred
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
520 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
522 (CONTROL_MODE_RESET_TARGET
<< 8) | CONTROL_COMMAND_PROGRAM
,
525 if (transferred
== 0) {
526 LOG_DEBUG("Zero bytes transferred");
530 if (status
!= PROGRAMMER_OK_ACK
) {
531 LOG_DEBUG("Programmer did not respond OK");
538 static int kitprog_swd_sync(void)
541 char status
= PROGRAMMER_NOK_NACK
;
543 transferred
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
544 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
546 (CONTROL_MODE_SYNCHRONIZE_TRANSFER
<< 8) | CONTROL_COMMAND_PROGRAM
,
549 if (transferred
== 0) {
550 LOG_DEBUG("Zero bytes transferred");
554 if (status
!= PROGRAMMER_OK_ACK
) {
555 LOG_DEBUG("Programmer did not respond OK");
562 static int kitprog_swd_seq(uint8_t seq_type
)
565 char status
= PROGRAMMER_NOK_NACK
;
567 transferred
= jtag_libusb_control_transfer(kitprog_handle
->usb_handle
,
568 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
,
570 (CONTROL_MODE_SEND_SWD_SEQUENCE
<< 8) | CONTROL_COMMAND_PROGRAM
,
571 seq_type
, &status
, 1, 0);
573 if (transferred
== 0) {
574 LOG_DEBUG("Zero bytes transferred");
578 if (status
!= PROGRAMMER_OK_ACK
) {
579 LOG_DEBUG("Programmer did not respond OK");
586 static int kitprog_generic_acquire(void)
588 const uint8_t devices
[] = {DEVICE_PSOC4
, DEVICE_PSOC3
, DEVICE_PSOC5
};
591 int acquire_count
= 0;
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).
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.
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
]);
613 if (kitprog_get_status() == ERROR_OK
)
620 if (acquire_count
< 2)
626 /*************** swd wrapper functions *********************/
628 static int kitprog_swd_init(void)
633 static void kitprog_swd_write_reg(uint8_t cmd
, uint32_t value
, uint32_t ap_delay_clk
)
635 assert(!(cmd
& SWD_CMD_RnW
));
636 kitprog_swd_queue_cmd(cmd
, NULL
, value
);
639 static void kitprog_swd_read_reg(uint8_t cmd
, uint32_t *value
, uint32_t ap_delay_clk
)
641 assert(cmd
& SWD_CMD_RnW
);
642 kitprog_swd_queue_cmd(cmd
, value
, 0);
645 /*************** swd lowlevel functions ********************/
647 static int kitprog_swd_switch_seq(enum swd_special_seq seq
)
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
)
657 LOG_DEBUG("JTAG to SWD not supported");
658 /* Fall through to fix target reset issue */
662 LOG_DEBUG("SWD line reset");
663 if (kitprog_swd_seq(SEQUENCE_LINE_RESET
) != ERROR_OK
)
667 LOG_ERROR("Sequence %d not supported.", seq
);
674 static int kitprog_swd_run_queue(void)
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
;
684 LOG_DEBUG_IO("Executing %d queued transactions", pending_transfer_count
);
686 if (queued_retval
!= ERROR_OK
) {
687 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval
);
691 if (!pending_transfer_count
)
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
;
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
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
;
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
);
722 buffer
[write_count
++] = (cmd
| SWD_CMD_START
| SWD_CMD_PARK
) & ~SWD_CMD_STOP
;
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;
734 if (jtag_libusb_bulk_write(kitprog_handle
->usb_handle
,
735 BULK_EP_OUT
, (char *)buffer
,
736 write_count
, 0, &ret
)) {
737 LOG_ERROR("Bulk write failed");
738 queued_retval
= ERROR_FAIL
;
741 queued_retval
= ERROR_OK
;
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. (?!?!)
753 size_t read_count_workaround
= SWD_MAX_BUFFER_LENGTH
;
754 if (read_count
% 64 == 0)
755 read_count_workaround
= read_count
;
757 if (jtag_libusb_bulk_read(kitprog_handle
->usb_handle
,
758 BULK_EP_IN
| LIBUSB_ENDPOINT_IN
, (char *)buffer
,
759 read_count_workaround
, 1000, &ret
)) {
760 LOG_ERROR("Bulk read failed");
761 queued_retval
= ERROR_FAIL
;
764 /* Handle garbage data by offsetting the initial read index */
765 if ((unsigned int)ret
> read_count
)
766 read_index
= ret
- read_count
;
767 queued_retval
= ERROR_OK
;
770 for (int i
= 0; i
< pending_transfer_count
; i
++) {
771 if (pending_transfers
[i
].cmd
& SWD_CMD_RnW
) {
772 uint32_t data
= le_to_h_u32(&buffer
[read_index
]);
774 LOG_DEBUG_IO("Read result: %"PRIx32
, data
);
776 if (pending_transfers
[i
].buffer
)
777 *(uint32_t *)pending_transfers
[i
].buffer
= data
;
782 uint8_t ack
= buffer
[read_index
] & 0x07;
783 if (ack
!= SWD_ACK_OK
|| (buffer
[read_index
] & 0x08)) {
784 LOG_DEBUG("SWD ack not OK: %d %s", i
,
785 ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK");
786 queued_retval
= ack
== SWD_ACK_WAIT
? ERROR_WAIT
: ERROR_FAIL
;
793 pending_transfer_count
= 0;
794 int retval
= queued_retval
;
795 queued_retval
= ERROR_OK
;
800 static void kitprog_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
)
802 if (pending_transfer_count
== pending_queue_len
) {
803 /* Not enough room in the queue. Run the queue. */
804 queued_retval
= kitprog_swd_run_queue();
807 if (queued_retval
!= ERROR_OK
)
810 pending_transfers
[pending_transfer_count
].data
= data
;
811 pending_transfers
[pending_transfer_count
].cmd
= cmd
;
812 if (cmd
& SWD_CMD_RnW
) {
813 /* Queue a read transaction */
814 pending_transfers
[pending_transfer_count
].buffer
= dst
;
816 pending_transfer_count
++;
819 /*************** jtag lowlevel functions ********************/
821 static int kitprog_reset(int trst
, int srst
)
823 int retval
= ERROR_OK
;
826 LOG_ERROR("KitProg: Interface has no TRST");
831 retval
= kitprog_reset_target();
832 /* Since the previous command also disables SWCLK output, we need to send an
833 * SWD bus reset command to re-enable it. For some reason, running
834 * kitprog_swd_seq() immediately after kitprog_reset_target() won't
835 * actually fix this. Instead, kitprog_swd_seq() will be run once OpenOCD
836 * tries to send a JTAG-to-SWD sequence, which should happen during
837 * swd_check_reconnect (see the JTAG_TO_SWD case in kitprog_swd_switch_seq).
841 if (retval
!= ERROR_OK
)
842 LOG_ERROR("KitProg: Interface reset failed");
846 COMMAND_HANDLER(kitprog_handle_info_command
)
848 int retval
= kitprog_get_info();
854 COMMAND_HANDLER(kitprog_handle_acquire_psoc_command
)
856 int retval
= kitprog_generic_acquire();
861 COMMAND_HANDLER(kitprog_handle_serial_command
)
864 kitprog_serial
= strdup(CMD_ARGV
[0]);
865 if (kitprog_serial
== NULL
) {
866 LOG_ERROR("Failed to allocate memory for the serial number");
870 LOG_ERROR("expected exactly one argument to kitprog_serial <serial-number>");
877 COMMAND_HANDLER(kitprog_handle_init_acquire_psoc_command
)
879 kitprog_init_acquire_psoc
= true;
884 static const struct command_registration kitprog_subcommand_handlers
[] = {
887 .handler
= &kitprog_handle_info_command
,
888 .mode
= COMMAND_EXEC
,
890 .help
= "show KitProg info",
893 .name
= "acquire_psoc",
894 .handler
= &kitprog_handle_acquire_psoc_command
,
895 .mode
= COMMAND_EXEC
,
897 .help
= "try to acquire a PSoC",
899 COMMAND_REGISTRATION_DONE
902 static const struct command_registration kitprog_command_handlers
[] = {
906 .help
= "perform KitProg management",
908 .chain
= kitprog_subcommand_handlers
,
911 .name
= "kitprog_serial",
912 .handler
= &kitprog_handle_serial_command
,
913 .mode
= COMMAND_CONFIG
,
914 .help
= "set the serial number of the adapter",
915 .usage
= "serial_string",
918 .name
= "kitprog_init_acquire_psoc",
919 .handler
= &kitprog_handle_init_acquire_psoc_command
,
920 .mode
= COMMAND_CONFIG
,
921 .help
= "try to acquire a PSoC during init",
924 COMMAND_REGISTRATION_DONE
927 static const struct swd_driver kitprog_swd
= {
928 .init
= kitprog_swd_init
,
929 .switch_seq
= kitprog_swd_switch_seq
,
930 .read_reg
= kitprog_swd_read_reg
,
931 .write_reg
= kitprog_swd_write_reg
,
932 .run
= kitprog_swd_run_queue
,
935 static const char * const kitprog_transports
[] = { "swd", NULL
};
937 struct adapter_driver kitprog_adapter_driver
= {
939 .transports
= kitprog_transports
,
940 .commands
= kitprog_command_handlers
,
942 .init
= kitprog_init
,
943 .quit
= kitprog_quit
,
944 .reset
= kitprog_reset
,
946 .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)