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_common.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 jtag_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
) != 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 (jtag_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 ret
= jtag_libusb_bulk_write(kitprog_handle
->usb_handle
,
735 BULK_EP_OUT
, (char *)buffer
, write_count
, 0);
737 queued_retval
= ERROR_OK
;
739 LOG_ERROR("Bulk write failed");
740 queued_retval
= ERROR_FAIL
;
744 /* We use the maximum buffer size here because the KitProg sometimes
745 * doesn't like bulk reads of fewer than 62 bytes. (?!?!)
747 ret
= jtag_libusb_bulk_read(kitprog_handle
->usb_handle
,
748 BULK_EP_IN
| LIBUSB_ENDPOINT_IN
, (char *)buffer
,
749 SWD_MAX_BUFFER_LENGTH
, 0);
751 /* Handle garbage data by offsetting the initial read index */
752 if ((unsigned int)ret
> read_count
)
753 read_index
= ret
- read_count
;
754 queued_retval
= ERROR_OK
;
756 LOG_ERROR("Bulk read failed");
757 queued_retval
= ERROR_FAIL
;
761 for (int i
= 0; i
< pending_transfer_count
; i
++) {
762 if (pending_transfers
[i
].cmd
& SWD_CMD_RnW
) {
763 uint32_t data
= le_to_h_u32(&buffer
[read_index
]);
765 LOG_DEBUG_IO("Read result: %"PRIx32
, data
);
767 if (pending_transfers
[i
].buffer
)
768 *(uint32_t *)pending_transfers
[i
].buffer
= data
;
773 uint8_t ack
= buffer
[read_index
] & 0x07;
774 if (ack
!= SWD_ACK_OK
|| (buffer
[read_index
] & 0x08)) {
775 LOG_DEBUG("SWD ack not OK: %d %s", i
,
776 ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK");
777 queued_retval
= ack
== SWD_ACK_WAIT
? ERROR_WAIT
: ERROR_FAIL
;
784 pending_transfer_count
= 0;
785 int retval
= queued_retval
;
786 queued_retval
= ERROR_OK
;
791 static void kitprog_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
)
793 if (pending_transfer_count
== pending_queue_len
) {
794 /* Not enough room in the queue. Run the queue. */
795 queued_retval
= kitprog_swd_run_queue();
798 if (queued_retval
!= ERROR_OK
)
801 pending_transfers
[pending_transfer_count
].data
= data
;
802 pending_transfers
[pending_transfer_count
].cmd
= cmd
;
803 if (cmd
& SWD_CMD_RnW
) {
804 /* Queue a read transaction */
805 pending_transfers
[pending_transfer_count
].buffer
= dst
;
807 pending_transfer_count
++;
810 /*************** jtag lowlevel functions ********************/
812 static void kitprog_execute_reset(struct jtag_command
*cmd
)
814 int retval
= ERROR_OK
;
816 if (cmd
->cmd
.reset
->srst
== 1) {
817 retval
= kitprog_reset_target();
818 /* Since the previous command also disables SWCLK output, we need to send an
819 * SWD bus reset command to re-enable it. For some reason, running
820 * kitprog_swd_seq() immediately after kitprog_reset_target() won't
821 * actually fix this. Instead, kitprog_swd_seq() will be run once OpenOCD
822 * tries to send a JTAG-to-SWD sequence, which should happen during
823 * swd_check_reconnect (see the JTAG_TO_SWD case in kitprog_swd_switch_seq).
827 if (retval
!= ERROR_OK
)
828 LOG_ERROR("KitProg: Interface reset failed");
831 static void kitprog_execute_sleep(struct jtag_command
*cmd
)
833 jtag_sleep(cmd
->cmd
.sleep
->us
);
836 static void kitprog_execute_command(struct jtag_command
*cmd
)
840 kitprog_execute_reset(cmd
);
843 kitprog_execute_sleep(cmd
);
846 LOG_ERROR("BUG: unknown JTAG command type encountered");
851 static int kitprog_execute_queue(void)
853 struct jtag_command
*cmd
= jtag_command_queue
;
855 while (cmd
!= NULL
) {
856 kitprog_execute_command(cmd
);
863 COMMAND_HANDLER(kitprog_handle_info_command
)
865 int retval
= kitprog_get_info();
871 COMMAND_HANDLER(kitprog_handle_acquire_psoc_command
)
873 int retval
= kitprog_generic_acquire();
878 COMMAND_HANDLER(kitprog_handle_serial_command
)
881 size_t len
= strlen(CMD_ARGV
[0]);
882 kitprog_serial
= calloc(len
+ 1, sizeof(char));
883 if (kitprog_serial
== NULL
) {
884 LOG_ERROR("Failed to allocate memory for the serial number");
887 strncpy(kitprog_serial
, CMD_ARGV
[0], len
+ 1);
889 LOG_ERROR("expected exactly one argument to kitprog_serial <serial-number>");
896 COMMAND_HANDLER(kitprog_handle_init_acquire_psoc_command
)
898 kitprog_init_acquire_psoc
= true;
903 static const struct command_registration kitprog_subcommand_handlers
[] = {
906 .handler
= &kitprog_handle_info_command
,
907 .mode
= COMMAND_EXEC
,
909 .help
= "show KitProg info",
912 .name
= "acquire_psoc",
913 .handler
= &kitprog_handle_acquire_psoc_command
,
914 .mode
= COMMAND_EXEC
,
916 .help
= "try to acquire a PSoC",
918 COMMAND_REGISTRATION_DONE
921 static const struct command_registration kitprog_command_handlers
[] = {
925 .help
= "perform KitProg management",
927 .chain
= kitprog_subcommand_handlers
,
930 .name
= "kitprog_serial",
931 .handler
= &kitprog_handle_serial_command
,
932 .mode
= COMMAND_CONFIG
,
933 .help
= "set the serial number of the adapter",
934 .usage
= "serial_string",
937 .name
= "kitprog_init_acquire_psoc",
938 .handler
= &kitprog_handle_init_acquire_psoc_command
,
939 .mode
= COMMAND_CONFIG
,
940 .help
= "try to acquire a PSoC during init",
943 COMMAND_REGISTRATION_DONE
946 static const struct swd_driver kitprog_swd
= {
947 .init
= kitprog_swd_init
,
948 .switch_seq
= kitprog_swd_switch_seq
,
949 .read_reg
= kitprog_swd_read_reg
,
950 .write_reg
= kitprog_swd_write_reg
,
951 .run
= kitprog_swd_run_queue
,
954 static const char * const kitprog_transports
[] = { "swd", NULL
};
956 struct jtag_interface kitprog_interface
= {
958 .commands
= kitprog_command_handlers
,
959 .transports
= kitprog_transports
,
961 .execute_queue
= kitprog_execute_queue
,
962 .init
= kitprog_init
,