--- /dev/null
+/******************************************************************************\r
+ * @file DAP.c\r
+ * @brief CMSIS-DAP Commands\r
+ * @version V1.00\r
+ * @date 31. May 2012\r
+ *\r
+ * @note\r
+ * Copyright (C) 2012 ARM Limited. All rights reserved.\r
+ *\r
+ * @par\r
+ * ARM Limited (ARM) is supplying this software for use with Cortex-M\r
+ * processor based microcontrollers.\r
+ *\r
+ * @par\r
+ * THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED\r
+ * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF\r
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.\r
+ * ARM SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR\r
+ * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.\r
+ *\r
+ ******************************************************************************/\r
+\r
+#include <string.h>\r
+#include "DAP_config.h"\r
+#include "DAP.h"\r
+\r
+\r
+#define DAP_FW_VER "1.0" // Firmware Version\r
+\r
+\r
+#if (DAP_PACKET_SIZE < 64)\r
+#error "Minimum Packet Size is 64"\r
+#endif\r
+#if (DAP_PACKET_SIZE > 32768)\r
+#error "Maximum Packet Size is 32768"\r
+#endif\r
+#if (DAP_PACKET_COUNT < 1)\r
+#error "Minimum Packet Count is 1"\r
+#endif\r
+#if (DAP_PACKET_COUNT > 255)\r
+#error "Maximum Packet Count is 255"\r
+#endif\r
+\r
+\r
+// Clock Macros\r
+\r
+#define MAX_SWJ_CLOCK(delay_cycles) \\r
+ (CPU_CLOCK/2 / (IO_PORT_WRITE_CYCLES + delay_cycles))\r
+\r
+#define CLOCK_DELAY(swj_clock) \\r
+ ((CPU_CLOCK/2 / swj_clock) - IO_PORT_WRITE_CYCLES)\r
+\r
+\r
+ DAP_Data_t DAP_Data; // DAP Data\r
+volatile uint8_t DAP_TransferAbort; // Trasfer Abort Flag\r
+\r
+\r
+#ifdef DAP_VENDOR\r
+const char DAP_Vendor [] = DAP_VENDOR;\r
+#endif\r
+#ifdef DAP_PRODUCT\r
+const char DAP_Product[] = DAP_PRODUCT;\r
+#endif\r
+#ifdef DAP_SER_NUM\r
+const char DAP_SerNum [] = DAP_SER_NUM;\r
+#endif\r
+const char DAP_FW_Ver [] = DAP_FW_VER;\r
+\r
+#if TARGET_DEVICE_FIXED\r
+const char TargetDeviceVendor [] = TARGET_DEVICE_VENDOR;\r
+const char TargetDeviceName [] = TARGET_DEVICE_NAME;\r
+#endif\r
+\r
+\r
+// Get DAP Information\r
+// id: info identifier\r
+// info: pointer to info data\r
+// return: number of bytes in info data\r
+static uint8_t DAP_Info(uint8_t id, uint8_t *info) {\r
+ uint8_t length = 0;\r
+\r
+ switch (id) {\r
+ case DAP_ID_VENDOR:\r
+#ifdef DAP_VENDOR\r
+ memcpy(info, DAP_Vendor, sizeof(DAP_Vendor));\r
+ length = sizeof(DAP_Vendor);\r
+#endif\r
+ break;\r
+ case DAP_ID_PRODUCT:\r
+#ifdef DAP_PRODUCT\r
+ memcpy(info, DAP_Product, sizeof(DAP_Product));\r
+ length = sizeof(DAP_Product);\r
+#endif\r
+ break;\r
+ case DAP_ID_SER_NUM:\r
+#ifdef DAP_SER_NUM\r
+ memcpy(info, DAP_SerNum, sizeof(DAP_SerNum));\r
+ length = sizeof(DAP_SerNum);\r
+#endif\r
+ break;\r
+ case DAP_ID_FW_VER:\r
+ memcpy(info, DAP_FW_Ver, sizeof(DAP_FW_Ver));\r
+ length = sizeof(DAP_FW_Ver);\r
+ break;\r
+ case DAP_ID_DEVICE_VENDOR:\r
+#if TARGET_DEVICE_FIXED\r
+ memcpy(info, TargetDeviceVendor, sizeof(TargetDeviceVendor));\r
+ length = sizeof(TargetDeviceVendor);\r
+#endif\r
+ break;\r
+ case DAP_ID_DEVICE_NAME:\r
+#if TARGET_DEVICE_FIXED\r
+ memcpy(info, TargetDeviceName, sizeof(TargetDeviceName));\r
+ length = sizeof(TargetDeviceName);\r
+#endif\r
+ break;\r
+ case DAP_ID_CAPABILITIES:\r
+ info[0] = ((DAP_SWD != 0) ? (1 << 0) : 0) |\r
+ ((DAP_JTAG != 0) ? (1 << 1) : 0);\r
+ length = 1;\r
+ break;\r
+ case DAP_ID_PACKET_SIZE:\r
+ info[0] = (uint8_t)(DAP_PACKET_SIZE >> 0);\r
+ info[1] = (uint8_t)(DAP_PACKET_SIZE >> 8);\r
+ length = 2;\r
+ break;\r
+ case DAP_ID_PACKET_COUNT:\r
+ info[0] = DAP_PACKET_COUNT;\r
+ length = 1;\r
+ break;\r
+ }\r
+\r
+ return (length);\r
+}\r
+\r
+\r
+// Timer Functions\r
+\r
+#if ((DAP_SWD != 0) || (DAP_JTAG != 0))\r
+\r
+// Start Timer\r
+static __inline void TIMER_START (uint32_t usec) {\r
+ SysTick->VAL = 0;\r
+ SysTick->LOAD = usec * CPU_CLOCK/1000000;\r
+ SysTick->CTRL = (1 << SysTick_CTRL_ENABLE_Pos) |\r
+ (1 << SysTick_CTRL_CLKSOURCE_Pos);\r
+}\r
+\r
+// Stop Timer\r
+static __inline void TIMER_STOP (void) {\r
+ SysTick->CTRL = 0;\r
+}\r
+\r
+// Check if Timer expired\r
+static __inline uint32_t TIMER_EXPIRED (void) {\r
+ return ((SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk) ? 1 : 0);\r
+}\r
+\r
+#endif\r
+\r
+\r
+// Delay for specified time\r
+// delay: delay time in ms\r
+void Delayms(uint32_t delay) {\r
+ delay *= (CPU_CLOCK/1000 + (DELAY_SLOW_CYCLES-1)) / DELAY_SLOW_CYCLES;\r
+ PIN_DELAY_SLOW(delay);\r
+}\r
+\r
+\r
+// Process Delay command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+static uint32_t DAP_Delay(uint8_t *request, uint8_t *response) {\r
+ uint32_t delay;\r
+\r
+ delay = *(request+0) | (*(request+1) << 8);\r
+ delay *= (CPU_CLOCK/1000000 + (DELAY_SLOW_CYCLES-1)) / DELAY_SLOW_CYCLES;\r
+\r
+ PIN_DELAY_SLOW(delay);\r
+\r
+ *response = DAP_OK;\r
+ return (1);\r
+}\r
+\r
+\r
+// Process LED command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+static uint32_t DAP_LED(uint8_t *request, uint8_t *response) {\r
+\r
+ switch (*request) {\r
+ case DAP_LED_DEBUGGER_CONNECTED:\r
+ LED_CONNECTED_OUT((*(request+1) & 1));\r
+ break;\r
+ case DAP_LED_TARGET_RUNNING:\r
+ LED_RUNNING_OUT((*(request+1) & 1));\r
+ break;\r
+ default:\r
+ *response = DAP_ERROR;\r
+ return (1);\r
+ }\r
+\r
+ *response = DAP_OK;\r
+ return (1);\r
+}\r
+\r
+\r
+// Process Connect command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+static uint32_t DAP_Connect(uint8_t *request, uint8_t *response) {\r
+ uint32_t port;\r
+\r
+ if (*request == DAP_PORT_AUTODETECT) {\r
+ port = DAP_DEFAULT_PORT;\r
+ } else {\r
+ port = *request;\r
+ }\r
+ \r
+ switch (port) {\r
+#if (DAP_SWD != 0)\r
+ case DAP_PORT_SWD:\r
+ DAP_Data.debug_port = DAP_PORT_SWD;\r
+ PORT_SWD_SETUP();\r
+ break;\r
+#endif\r
+#if (DAP_JTAG != 0)\r
+ case DAP_PORT_JTAG:\r
+ DAP_Data.debug_port = DAP_PORT_JTAG;\r
+ PORT_JTAG_SETUP();\r
+ break;\r
+#endif\r
+ default:\r
+ *response = DAP_PORT_DISABLED;\r
+ return (1);\r
+ }\r
+\r
+ *response = port;\r
+ return (1);\r
+}\r
+\r
+\r
+// Process Disconnect command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+static uint32_t DAP_Disconnect(uint8_t *response) {\r
+\r
+ DAP_Data.debug_port = DAP_PORT_DISABLED;\r
+ PORT_OFF();\r
+\r
+ *response = DAP_OK;\r
+ return (1);\r
+}\r
+\r
+\r
+// Process Reset Target command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+static uint32_t DAP_ResetTarget(uint8_t *response) {\r
+\r
+ *(response+1) = RESET_TARGET();\r
+ *(response+0) = DAP_OK;\r
+ return (2);\r
+}\r
+\r
+\r
+// Process SWJ Pins command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+#if ((DAP_SWD != 0) || (DAP_JTAG != 0))\r
+static uint32_t DAP_SWJ_Pins(uint8_t *request, uint8_t *response) {\r
+ uint32_t value;\r
+ uint32_t select;\r
+ uint32_t wait;\r
+ \r
+ value = *(request+0);\r
+ select = *(request+1); \r
+ wait = (*(request+2) << 0) |\r
+ (*(request+3) << 8) |\r
+ (*(request+4) << 16) |\r
+ (*(request+5) << 24);\r
+\r
+ if (select & (1 << DAP_SWJ_SWCLK_TCK)) {\r
+ if (value & (1 << DAP_SWJ_SWCLK_TCK)) {\r
+ PIN_SWCLK_TCK_SET();\r
+ } else {\r
+ PIN_SWCLK_TCK_CLR();\r
+ }\r
+ }\r
+ if (select & (1 << DAP_SWJ_SWDIO_TMS)) {\r
+ if (value & (1 << DAP_SWJ_SWDIO_TMS)) {\r
+ PIN_SWDIO_TMS_SET();\r
+ } else {\r
+ PIN_SWDIO_TMS_CLR();\r
+ }\r
+ }\r
+ if (select & (1 << DAP_SWJ_TDI)) {\r
+ PIN_TDI_OUT(value >> DAP_SWJ_TDI);\r
+ }\r
+ if (select & (1 << DAP_SWJ_nTRST)) {\r
+ PIN_nTRST_OUT(value >> DAP_SWJ_nTRST);\r
+ }\r
+ if (select & (1 << DAP_SWJ_nRESET)) {\r
+ PIN_nRESET_OUT(value >> DAP_SWJ_nRESET);\r
+ }\r
+\r
+ if (wait) {\r
+ if (wait > 3000000) wait = 3000000;\r
+ TIMER_START(wait);\r
+ do {\r
+ if (select & (1 << DAP_SWJ_SWCLK_TCK)) {\r
+ if ((value >> DAP_SWJ_SWCLK_TCK) ^ PIN_SWCLK_TCK_IN()) continue;\r
+ }\r
+ if (select & (1 << DAP_SWJ_SWDIO_TMS)) {\r
+ if ((value >> DAP_SWJ_SWDIO_TMS) ^ PIN_SWDIO_TMS_IN()) continue;\r
+ }\r
+ if (select & (1 << DAP_SWJ_TDI)) {\r
+ if ((value >> DAP_SWJ_TDI) ^ PIN_TDI_IN()) continue;\r
+ }\r
+ if (select & (1 << DAP_SWJ_nTRST)) {\r
+ if ((value >> DAP_SWJ_nTRST) ^ PIN_nTRST_IN()) continue;\r
+ }\r
+ if (select & (1 << DAP_SWJ_nRESET)) {\r
+ if ((value >> DAP_SWJ_nRESET) ^ PIN_nRESET_IN()) continue;\r
+ }\r
+ break;\r
+ } while (!TIMER_EXPIRED());\r
+ TIMER_STOP();\r
+ }\r
+\r
+ value = (PIN_SWCLK_TCK_IN() << DAP_SWJ_SWCLK_TCK) |\r
+ (PIN_SWDIO_TMS_IN() << DAP_SWJ_SWDIO_TMS) |\r
+ (PIN_TDI_IN() << DAP_SWJ_TDI) |\r
+ (PIN_TDO_IN() << DAP_SWJ_TDO) |\r
+ (PIN_nTRST_IN() << DAP_SWJ_nTRST) |\r
+ (PIN_nRESET_IN() << DAP_SWJ_nRESET);\r
+\r
+ *response = (uint8_t)value;\r
+ return (1);\r
+}\r
+#endif\r
+\r
+\r
+// Process SWJ Clock command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+#if ((DAP_SWD != 0) || (DAP_JTAG != 0))\r
+static uint32_t DAP_SWJ_Clock(uint8_t *request, uint8_t *response) {\r
+ uint32_t clock;\r
+ uint32_t delay;\r
+\r
+ clock = (*(request+0) << 0) |\r
+ (*(request+1) << 8) |\r
+ (*(request+2) << 16) |\r
+ (*(request+3) << 24);\r
+\r
+ if (clock == 0) {\r
+ *response = DAP_ERROR;\r
+ return (1);\r
+ }\r
+\r
+ if (clock >= MAX_SWJ_CLOCK(DELAY_FAST_CYCLES)) {\r
+ DAP_Data.fast_clock = 1;\r
+ DAP_Data.clock_delay = 1;\r
+ } else {\r
+ DAP_Data.fast_clock = 0;\r
+\r
+ delay = (CPU_CLOCK/2 + (clock - 1)) / clock;\r
+ if (delay > IO_PORT_WRITE_CYCLES) {\r
+ delay -= IO_PORT_WRITE_CYCLES;\r
+ delay = (delay + (DELAY_SLOW_CYCLES - 1)) / DELAY_SLOW_CYCLES;\r
+ } else {\r
+ delay = 1;\r
+ }\r
+\r
+ DAP_Data.clock_delay = delay;\r
+ }\r
+\r
+ *response = DAP_OK;\r
+ return (1);\r
+}\r
+#endif\r
+\r
+\r
+// Process SWJ Sequence command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+#if ((DAP_SWD != 0) || (DAP_JTAG != 0))\r
+static uint32_t DAP_SWJ_Sequence(uint8_t *request, uint8_t *response) {\r
+ uint32_t count;\r
+\r
+ count = *request++;\r
+ if (count == 0) count = 256;\r
+\r
+ SWJ_Sequence(count, request);\r
+\r
+ *response = DAP_OK;\r
+ return (1);\r
+}\r
+#endif\r
+\r
+\r
+// Process SWD Configure command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+#if (DAP_SWD != 0)\r
+static uint32_t DAP_SWD_Configure(uint8_t *request, uint8_t *response) {\r
+ uint8_t value;\r
+\r
+ value = *request;\r
+ DAP_Data.swd_conf.turnaround = (value & 0x03) + 1;\r
+ DAP_Data.swd_conf.data_phase = (value & 0x04) ? 1 : 0;\r
+ \r
+ *response = DAP_OK;\r
+\r
+ return (1);\r
+}\r
+#endif\r
+\r
+\r
+// Process SWD Abort command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+#if (DAP_SWD != 0)\r
+static uint32_t DAP_SWD_Abort(uint8_t *request, uint8_t *response) {\r
+ uint32_t data;\r
+\r
+ if (DAP_Data.debug_port != DAP_PORT_SWD) {\r
+ *response = DAP_ERROR;\r
+ return (1);\r
+ }\r
+\r
+ // Load data (Ignore DAP index)\r
+ data = (*(request+1) << 0) |\r
+ (*(request+2) << 8) |\r
+ (*(request+3) << 16) |\r
+ (*(request+4) << 24);\r
+\r
+ // Write Abort register\r
+ SWD_Transfer(DP_ABORT, &data);\r
+ *response = DAP_OK;\r
+\r
+ return (1);\r
+}\r
+#endif\r
+\r
+\r
+// Process JTAG Sequence command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+#if (DAP_JTAG != 0)\r
+static uint32_t DAP_JTAG_Sequence(uint8_t *request, uint8_t *response) {\r
+ uint32_t sequence_info;\r
+ uint32_t sequence_count;\r
+ uint32_t response_count;\r
+ uint32_t count;\r
+\r
+ *response++ = DAP_OK;\r
+ response_count = 1;\r
+\r
+ sequence_count = *request++;\r
+ while (sequence_count--) {\r
+ sequence_info = *request++;\r
+ JTAG_Sequence(sequence_info, request, response);\r
+ count = sequence_info & JTAG_SEQUENCE_TCK;\r
+ if (count == 0) count = 64;\r
+ count = (count + 7) / 8;\r
+ request += count;\r
+ if (sequence_info & JTAG_SEQUENCE_TDO) {\r
+ response += count;\r
+ response_count += count;\r
+ }\r
+ }\r
+\r
+ return (response_count);\r
+}\r
+#endif\r
+\r
+\r
+// Process JTAG Configure command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+#if (DAP_JTAG != 0)\r
+static uint32_t DAP_JTAG_Configure(uint8_t *request, uint8_t *response) {\r
+ uint32_t count;\r
+ uint32_t length;\r
+ uint32_t bits;\r
+ uint32_t n;\r
+\r
+ count = *request++;\r
+ DAP_Data.jtag_dev.count = count;\r
+\r
+ bits = 0;\r
+ for (n = 0; n < count; n++) {\r
+ length = *request++;\r
+ DAP_Data.jtag_dev.ir_length[n] = length;\r
+ DAP_Data.jtag_dev.ir_before[n] = bits;\r
+ bits += length;\r
+ }\r
+ for (n = 0; n < count; n++) {\r
+ bits -= DAP_Data.jtag_dev.ir_length[n];\r
+ DAP_Data.jtag_dev.ir_after[n] = bits;\r
+ }\r
+\r
+ *response = DAP_OK;\r
+ return (1);\r
+}\r
+#endif\r
+\r
+\r
+// Process JTAG IDCODE command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+#if (DAP_JTAG != 0)\r
+static uint32_t DAP_JTAG_IDCode(uint8_t *request, uint8_t *response) {\r
+ uint32_t data;\r
+\r
+ if (DAP_Data.debug_port != DAP_PORT_JTAG) {\r
+err:*response = DAP_ERROR;\r
+ return (1);\r
+ }\r
+\r
+ // Device index (JTAP TAP)\r
+ DAP_Data.jtag_dev.index = *request;\r
+ if (DAP_Data.jtag_dev.index >= DAP_Data.jtag_dev.count) goto err;\r
+\r
+ // Select JTAG chain\r
+ JTAG_IR(JTAG_IDCODE);\r
+\r
+ // Read IDCODE register\r
+ data = JTAG_ReadIDCode();\r
+\r
+ // Store Data\r
+ *(response+0) = DAP_OK;\r
+ *(response+1) = (uint8_t)(data >> 0);\r
+ *(response+2) = (uint8_t)(data >> 8);\r
+ *(response+3) = (uint8_t)(data >> 16);\r
+ *(response+4) = (uint8_t)(data >> 24);\r
+\r
+ return (1+4);\r
+}\r
+#endif\r
+\r
+\r
+// Process JTAG Abort command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+#if (DAP_JTAG != 0)\r
+static uint32_t DAP_JTAG_Abort(uint8_t *request, uint8_t *response) {\r
+ uint32_t data;\r
+\r
+ if (DAP_Data.debug_port != DAP_PORT_JTAG) {\r
+err:*response = DAP_ERROR;\r
+ return (1);\r
+ }\r
+\r
+ // Device index (JTAP TAP)\r
+ DAP_Data.jtag_dev.index = *request;\r
+ if (DAP_Data.jtag_dev.index >= DAP_Data.jtag_dev.count) goto err;\r
+\r
+ // Select JTAG chain\r
+ JTAG_IR(JTAG_ABORT);\r
+\r
+ // Load data\r
+ data = (*(request+1) << 0) |\r
+ (*(request+2) << 8) |\r
+ (*(request+3) << 16) |\r
+ (*(request+4) << 24);\r
+\r
+ // Write Abort register\r
+ JTAG_WriteAbort(data);\r
+ *response = DAP_OK;\r
+\r
+ return (1);\r
+}\r
+#endif\r
+\r
+\r
+// Process Transfer Configure command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+static uint32_t DAP_TransferConfigure(uint8_t *request, uint8_t *response) {\r
+\r
+ DAP_Data.transfer.idle_cycles = *(request+0);\r
+ DAP_Data.transfer.retry_count = *(request+1) | (*(request+2) << 8);\r
+ DAP_Data.transfer.match_retry = *(request+3) | (*(request+4) << 8);\r
+ \r
+ *response = DAP_OK;\r
+\r
+ return (1);\r
+}\r
+\r
+\r
+// Process SWD Transfer command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+#if (DAP_SWD != 0)\r
+static uint32_t DAP_SWD_Transfer(uint8_t *request, uint8_t *response) {\r
+ uint32_t request_count;\r
+ uint32_t request_value;\r
+ uint32_t response_count;\r
+ uint32_t response_value;\r
+ uint8_t *response_head;\r
+ uint32_t post_read;\r
+ uint32_t check_write;\r
+ uint32_t match_value;\r
+ uint32_t match_retry;\r
+ uint32_t retry;\r
+ uint32_t data;\r
+\r
+ response_count = 0;\r
+ response_value = 0;\r
+ response_head = response;\r
+ response += 2;\r
+\r
+ DAP_TransferAbort = 0;\r
+\r
+ post_read = 0;\r
+ check_write = 0;\r
+\r
+ request++; // Ignore DAP index\r
+\r
+ request_count = *request++;\r
+ while (request_count--) {\r
+ request_value = *request++;\r
+ if (request_value & DAP_TRANSFER_RnW) {\r
+ // Read register\r
+ if (post_read) {\r
+ // Read was posted before\r
+ retry = DAP_Data.transfer.retry_count;\r
+ if ((request_value & (DAP_TRANSFER_APnDP | DAP_TRANSFER_MATCH_VALUE)) == DAP_TRANSFER_APnDP) {\r
+ // Read previous AP data and post next AP read\r
+ do {\r
+ response_value = SWD_Transfer(request_value, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ } else {\r
+ // Read previous AP data\r
+ do {\r
+ response_value = SWD_Transfer(DP_RDBUFF | DAP_TRANSFER_RnW, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ post_read = 0;\r
+ }\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ // Store previous AP data\r
+ *response++ = (uint8_t) data;\r
+ *response++ = (uint8_t)(data >> 8);\r
+ *response++ = (uint8_t)(data >> 16);\r
+ *response++ = (uint8_t)(data >> 24);\r
+ }\r
+ if (request_value & DAP_TRANSFER_MATCH_VALUE) {\r
+ // Read with value match\r
+ match_value = (*(request+0) << 0) |\r
+ (*(request+1) << 8) |\r
+ (*(request+2) << 16) |\r
+ (*(request+3) << 24);\r
+ request += 4;\r
+ match_retry = DAP_Data.transfer.match_retry;\r
+ if (request_value & DAP_TRANSFER_APnDP) {\r
+ // Post AP read\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = SWD_Transfer(request_value, NULL);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ }\r
+ do {\r
+ // Read register until its value matches or retry counter expires\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = SWD_Transfer(request_value, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ } while (((data & DAP_Data.transfer.match_mask) != match_value) && match_retry-- && !DAP_TransferAbort);\r
+ if ((data & DAP_Data.transfer.match_mask) != match_value) {\r
+ response_value |= DAP_TRANSFER_MISMATCH;\r
+ }\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ } else {\r
+ // Normal read\r
+ retry = DAP_Data.transfer.retry_count;\r
+ if (request_value & DAP_TRANSFER_APnDP) {\r
+ // Read AP register\r
+ if (post_read == 0) {\r
+ // Post AP read\r
+ do {\r
+ response_value = SWD_Transfer(request_value, NULL);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ post_read = 1;\r
+ }\r
+ } else {\r
+ // Read DP register\r
+ do {\r
+ response_value = SWD_Transfer(request_value, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ // Store data\r
+ *response++ = (uint8_t) data;\r
+ *response++ = (uint8_t)(data >> 8);\r
+ *response++ = (uint8_t)(data >> 16);\r
+ *response++ = (uint8_t)(data >> 24);\r
+ }\r
+ }\r
+ check_write = 0;\r
+ } else {\r
+ // Write register\r
+ if (post_read) {\r
+ // Read previous data\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = SWD_Transfer(DP_RDBUFF | DAP_TRANSFER_RnW, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ // Store previous data\r
+ *response++ = (uint8_t) data;\r
+ *response++ = (uint8_t)(data >> 8);\r
+ *response++ = (uint8_t)(data >> 16);\r
+ *response++ = (uint8_t)(data >> 24);\r
+ post_read = 0;\r
+ }\r
+ // Load data\r
+ data = (*(request+0) << 0) |\r
+ (*(request+1) << 8) |\r
+ (*(request+2) << 16) |\r
+ (*(request+3) << 24);\r
+ request += 4;\r
+ if (request_value & DAP_TRANSFER_MATCH_MASK) {\r
+ // Write match mask\r
+ DAP_Data.transfer.match_mask = data;\r
+ response_value = DAP_TRANSFER_OK;\r
+ } else {\r
+ // Write DP/AP register\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = SWD_Transfer(request_value, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ check_write = 1;\r
+ }\r
+ }\r
+ response_count++;\r
+ if (DAP_TransferAbort) break;\r
+ }\r
+\r
+ if (response_value == DAP_TRANSFER_OK) {\r
+ if (post_read) {\r
+ // Read previous data\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = SWD_Transfer(DP_RDBUFF | DAP_TRANSFER_RnW, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) goto end;\r
+ // Store previous data\r
+ *response++ = (uint8_t) data;\r
+ *response++ = (uint8_t)(data >> 8);\r
+ *response++ = (uint8_t)(data >> 16);\r
+ *response++ = (uint8_t)(data >> 24);\r
+ } else if (check_write) {\r
+ // Check last write\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = SWD_Transfer(DP_RDBUFF | DAP_TRANSFER_RnW, NULL);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ }\r
+ }\r
+\r
+end:\r
+ *(response_head+0) = (uint8_t)response_count;\r
+ *(response_head+1) = (uint8_t)response_value;\r
+\r
+ return (response - response_head);\r
+}\r
+#endif\r
+\r
+\r
+// Process JTAG Transfer command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+#if (DAP_JTAG != 0)\r
+static uint32_t DAP_JTAG_Transfer(uint8_t *request, uint8_t *response) {\r
+ uint32_t request_count;\r
+ uint32_t request_value;\r
+ uint32_t request_ir;\r
+ uint32_t response_count;\r
+ uint32_t response_value;\r
+ uint8_t *response_head;\r
+ uint32_t post_read;\r
+ uint32_t match_value;\r
+ uint32_t match_retry;\r
+ uint32_t retry;\r
+ uint32_t data;\r
+ uint32_t ir;\r
+\r
+ response_count = 0;\r
+ response_value = 0;\r
+ response_head = response;\r
+ response += 2;\r
+\r
+ DAP_TransferAbort = 0;\r
+\r
+ ir = 0;\r
+ post_read = 0;\r
+\r
+ // Device index (JTAP TAP)\r
+ DAP_Data.jtag_dev.index = *request++;\r
+ if (DAP_Data.jtag_dev.index >= DAP_Data.jtag_dev.count) goto end;\r
+\r
+ request_count = *request++;\r
+ while (request_count--) {\r
+ request_value = *request++;\r
+ request_ir = (request_value & DAP_TRANSFER_APnDP) ? JTAG_APACC : JTAG_DPACC;\r
+ if (request_value & DAP_TRANSFER_RnW) {\r
+ // Read register\r
+ if (post_read) {\r
+ // Read was posted before\r
+ retry = DAP_Data.transfer.retry_count;\r
+ if ((ir == request_ir) && ((request_value & DAP_TRANSFER_MATCH_VALUE) == 0)) {\r
+ // Read previous data and post next read\r
+ do {\r
+ response_value = JTAG_Transfer(request_value, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ } else {\r
+ // Select JTAG chain\r
+ if (ir != JTAG_DPACC) {\r
+ ir = JTAG_DPACC;\r
+ JTAG_IR(ir);\r
+ }\r
+ // Read previous data\r
+ do {\r
+ response_value = JTAG_Transfer(DP_RDBUFF | DAP_TRANSFER_RnW, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ post_read = 0;\r
+ }\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ // Store previous data\r
+ *response++ = (uint8_t) data;\r
+ *response++ = (uint8_t)(data >> 8);\r
+ *response++ = (uint8_t)(data >> 16);\r
+ *response++ = (uint8_t)(data >> 24);\r
+ }\r
+ if (request_value & DAP_TRANSFER_MATCH_VALUE) {\r
+ // Read with value match\r
+ match_value = (*(request+0) << 0) |\r
+ (*(request+1) << 8) |\r
+ (*(request+2) << 16) |\r
+ (*(request+3) << 24);\r
+ request += 4;\r
+ match_retry = DAP_Data.transfer.match_retry;\r
+ // Select JTAG chain\r
+ if (ir != request_ir) {\r
+ ir = request_ir;\r
+ JTAG_IR(ir);\r
+ }\r
+ // Post DP/AP read\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = JTAG_Transfer(request_value, NULL);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ do {\r
+ // Read register until its value matches or retry counter expires\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = JTAG_Transfer(request_value, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ } while (((data & DAP_Data.transfer.match_mask) != match_value) && match_retry-- && !DAP_TransferAbort);\r
+ if ((data & DAP_Data.transfer.match_mask) != match_value) {\r
+ response_value |= DAP_TRANSFER_MISMATCH;\r
+ }\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ } else {\r
+ // Normal read\r
+ if (post_read == 0) {\r
+ // Select JTAG chain\r
+ if (ir != request_ir) {\r
+ ir = request_ir;\r
+ JTAG_IR(ir);\r
+ }\r
+ // Post DP/AP read\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = JTAG_Transfer(request_value, NULL);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ post_read = 1;\r
+ }\r
+ }\r
+ } else {\r
+ // Write register\r
+ if (post_read) {\r
+ // Select JTAG chain\r
+ if (ir != JTAG_DPACC) {\r
+ ir = JTAG_DPACC;\r
+ JTAG_IR(ir);\r
+ }\r
+ // Read previous data\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = JTAG_Transfer(DP_RDBUFF | DAP_TRANSFER_RnW, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ // Store previous data\r
+ *response++ = (uint8_t) data;\r
+ *response++ = (uint8_t)(data >> 8);\r
+ *response++ = (uint8_t)(data >> 16);\r
+ *response++ = (uint8_t)(data >> 24);\r
+ post_read = 0;\r
+ }\r
+ // Load data\r
+ data = (*(request+0) << 0) |\r
+ (*(request+1) << 8) |\r
+ (*(request+2) << 16) |\r
+ (*(request+3) << 24);\r
+ request += 4;\r
+ if (request_value & DAP_TRANSFER_MATCH_MASK) {\r
+ // Write match mask\r
+ DAP_Data.transfer.match_mask = data;\r
+ response_value = DAP_TRANSFER_OK;\r
+ } else {\r
+ // Select JTAG chain\r
+ if (ir != request_ir) {\r
+ ir = request_ir;\r
+ JTAG_IR(ir);\r
+ }\r
+ // Write DP/AP register\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = JTAG_Transfer(request_value, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) break;\r
+ }\r
+ }\r
+ response_count++;\r
+ if (DAP_TransferAbort) break;\r
+ }\r
+\r
+ if (response_value == DAP_TRANSFER_OK) {\r
+ // Select JTAG chain\r
+ if (ir != JTAG_DPACC) {\r
+ ir = JTAG_DPACC;\r
+ JTAG_IR(ir);\r
+ }\r
+ if (post_read) {\r
+ // Read previous data\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = JTAG_Transfer(DP_RDBUFF | DAP_TRANSFER_RnW, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) goto end;\r
+ // Store previous data\r
+ *response++ = (uint8_t) data;\r
+ *response++ = (uint8_t)(data >> 8);\r
+ *response++ = (uint8_t)(data >> 16);\r
+ *response++ = (uint8_t)(data >> 24);\r
+ } else {\r
+ // Check last write\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = JTAG_Transfer(DP_RDBUFF | DAP_TRANSFER_RnW, NULL);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ }\r
+ }\r
+\r
+end:\r
+ *(response_head+0) = (uint8_t)response_count;\r
+ *(response_head+1) = (uint8_t)response_value;\r
+\r
+ return (response - response_head);\r
+}\r
+#endif\r
+\r
+\r
+// Process SWD Transfer Block command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+#if (DAP_SWD != 0)\r
+static uint32_t DAP_SWD_TransferBlock(uint8_t *request, uint8_t *response) {\r
+ uint32_t request_count;\r
+ uint32_t request_value;\r
+ uint32_t response_count;\r
+ uint32_t response_value;\r
+ uint8_t *response_head;\r
+ uint32_t retry;\r
+ uint32_t data;\r
+\r
+ response_count = 0;\r
+ response_value = 0;\r
+ response_head = response;\r
+ response += 3;\r
+\r
+ DAP_TransferAbort = 0;\r
+\r
+ request++; // Ignore DAP index\r
+\r
+ request_count = *request | (*(request+1) << 8);\r
+ request += 2;\r
+ if (request_count == 0) goto end;\r
+\r
+ request_value = *request++;\r
+ if (request_value & DAP_TRANSFER_RnW) {\r
+ // Read register block\r
+ if (request_value & DAP_TRANSFER_APnDP) {\r
+ // Post AP read\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = SWD_Transfer(request_value, NULL);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) goto end;\r
+ }\r
+ while (request_count--) {\r
+ // Read DP/AP register\r
+ if ((request_count == 0) && (request_value & DAP_TRANSFER_APnDP)) {\r
+ // Last AP read\r
+ request_value = DP_RDBUFF | DAP_TRANSFER_RnW;\r
+ }\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = SWD_Transfer(request_value, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) goto end;\r
+ // Store data\r
+ *response++ = (uint8_t) data;\r
+ *response++ = (uint8_t)(data >> 8);\r
+ *response++ = (uint8_t)(data >> 16);\r
+ *response++ = (uint8_t)(data >> 24);\r
+ response_count++;\r
+ }\r
+ } else {\r
+ // Write register block\r
+ while (request_count--) {\r
+ // Load data\r
+ data = (*(request+0) << 0) |\r
+ (*(request+1) << 8) |\r
+ (*(request+2) << 16) |\r
+ (*(request+3) << 24);\r
+ request += 4;\r
+ // Write DP/AP register\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = SWD_Transfer(request_value, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) goto end;\r
+ response_count++;\r
+ }\r
+ // Check last write\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = SWD_Transfer(DP_RDBUFF | DAP_TRANSFER_RnW, NULL);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ }\r
+\r
+end:\r
+ *(response_head+0) = (uint8_t)(response_count >> 0);\r
+ *(response_head+1) = (uint8_t)(response_count >> 8);\r
+ *(response_head+2) = (uint8_t) response_value;\r
+\r
+ return (response - response_head);\r
+}\r
+#endif\r
+\r
+\r
+// Process JTAG Transfer Block command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+#if (DAP_JTAG != 0)\r
+static uint32_t DAP_JTAG_TransferBlock(uint8_t *request, uint8_t *response) {\r
+ uint32_t request_count;\r
+ uint32_t request_value;\r
+ uint32_t response_count;\r
+ uint32_t response_value;\r
+ uint8_t *response_head;\r
+ uint32_t retry;\r
+ uint32_t data;\r
+ uint32_t ir;\r
+\r
+ response_count = 0;\r
+ response_value = 0;\r
+ response_head = response;\r
+ response += 3;\r
+\r
+ DAP_TransferAbort = 0;\r
+\r
+ // Device index (JTAP TAP)\r
+ DAP_Data.jtag_dev.index = *request++;\r
+ if (DAP_Data.jtag_dev.index >= DAP_Data.jtag_dev.count) goto end;\r
+\r
+ request_count = *request | (*(request+1) << 8);\r
+ request += 2;\r
+ if (request_count == 0) goto end;\r
+\r
+ request_value = *request++;\r
+\r
+ // Select JTAG chain\r
+ ir = (request_value & DAP_TRANSFER_APnDP) ? JTAG_APACC : JTAG_DPACC;\r
+ JTAG_IR(ir);\r
+\r
+ if (request_value & DAP_TRANSFER_RnW) {\r
+ // Post read\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = JTAG_Transfer(request_value, NULL);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) goto end;\r
+ // Read register block\r
+ while (request_count--) {\r
+ // Read DP/AP register\r
+ if (request_count == 0) {\r
+ // Last read\r
+ if (ir != JTAG_DPACC) {\r
+ JTAG_IR(JTAG_DPACC);\r
+ }\r
+ request_value = DP_RDBUFF | DAP_TRANSFER_RnW;\r
+ }\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = JTAG_Transfer(request_value, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) goto end;\r
+ // Store data\r
+ *response++ = (uint8_t) data;\r
+ *response++ = (uint8_t)(data >> 8);\r
+ *response++ = (uint8_t)(data >> 16);\r
+ *response++ = (uint8_t)(data >> 24);\r
+ response_count++;\r
+ }\r
+ } else {\r
+ // Write register block\r
+ while (request_count--) {\r
+ // Load data\r
+ data = (*(request+0) << 0) |\r
+ (*(request+1) << 8) |\r
+ (*(request+2) << 16) |\r
+ (*(request+3) << 24);\r
+ request += 4;\r
+ // Write DP/AP register\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = JTAG_Transfer(request_value, &data);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ if (response_value != DAP_TRANSFER_OK) goto end;\r
+ response_count++;\r
+ }\r
+ // Check last write\r
+ if (ir != JTAG_DPACC) {\r
+ JTAG_IR(JTAG_DPACC);\r
+ }\r
+ retry = DAP_Data.transfer.retry_count;\r
+ do {\r
+ response_value = JTAG_Transfer(DP_RDBUFF | DAP_TRANSFER_RnW, NULL);\r
+ } while ((response_value == DAP_TRANSFER_WAIT) && retry-- && !DAP_TransferAbort);\r
+ }\r
+\r
+end:\r
+ *(response_head+0) = (uint8_t)(response_count >> 0);\r
+ *(response_head+1) = (uint8_t)(response_count >> 8);\r
+ *(response_head+2) = (uint8_t) response_value;\r
+\r
+ return (response - response_head);\r
+}\r
+#endif\r
+\r
+\r
+// Process DAP Vendor command and prepare response\r
+// Default function (can be overridden)\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+__weak uint32_t DAP_ProcessVendorCommand(uint8_t *request, uint8_t *response) {\r
+ *response = ID_DAP_Invalid;\r
+ return (1);\r
+}\r
+\r
+\r
+// Process DAP command and prepare response\r
+// request: pointer to request data\r
+// response: pointer to response data\r
+// return: number of bytes in response\r
+uint32_t DAP_ProcessCommand(uint8_t *request, uint8_t *response) {\r
+ uint32_t num;\r
+\r
+ if ((*request >= ID_DAP_Vendor0) && (*request <= ID_DAP_Vendor31)) {\r
+ return DAP_ProcessVendorCommand(request, response);\r
+ }\r
+\r
+ *response++ = *request;\r
+\r
+ switch (*request++) {\r
+ case ID_DAP_Info:\r
+ num = DAP_Info(*request, response+1);\r
+ *response = num;\r
+ return (2 + num);\r
+ case ID_DAP_LED:\r
+ num = DAP_LED(request, response);\r
+ break;\r
+ case ID_DAP_Connect:\r
+ num = DAP_Connect(request, response);\r
+ break;\r
+ case ID_DAP_Disconnect:\r
+ num = DAP_Disconnect(response);\r
+ break;\r
+ case ID_DAP_Delay:\r
+ num = DAP_Delay(request, response);\r
+ break;\r
+ case ID_DAP_ResetTarget:\r
+ num = DAP_ResetTarget(response);\r
+ break;\r
+\r
+#if ((DAP_SWD != 0) || (DAP_JTAG != 0))\r
+ case ID_DAP_SWJ_Pins:\r
+ num = DAP_SWJ_Pins(request, response);\r
+ break;\r
+ case ID_DAP_SWJ_Clock:\r
+ num = DAP_SWJ_Clock(request, response);\r
+ break;\r
+ case ID_DAP_SWJ_Sequence:\r
+ num = DAP_SWJ_Sequence(request, response);\r
+ break;\r
+#else\r
+ case ID_DAP_SWJ_Pins:\r
+ case ID_DAP_SWJ_Clock:\r
+ case ID_DAP_SWJ_Sequence:\r
+ *response = DAP_ERROR;\r
+ return (2);\r
+#endif\r
+\r
+#if (DAP_SWD != 0)\r
+ case ID_DAP_SWD_Configure:\r
+ num = DAP_SWD_Configure(request, response);\r
+ break;\r
+#else\r
+ case ID_DAP_SWD_Configure:\r
+ *response = DAP_ERROR;\r
+ return (2);\r
+#endif\r
+\r
+#if (DAP_JTAG != 0)\r
+ case ID_DAP_JTAG_Sequence:\r
+ num = DAP_JTAG_Sequence(request, response);\r
+ break;\r
+ case ID_DAP_JTAG_Configure:\r
+ num = DAP_JTAG_Configure(request, response);\r
+ break;\r
+ case ID_DAP_JTAG_IDCODE:\r
+ num = DAP_JTAG_IDCode(request, response);\r
+ break;\r
+#else\r
+ case ID_DAP_JTAG_Sequence:\r
+ case ID_DAP_JTAG_Configure:\r
+ case ID_DAP_JTAG_IDCODE:\r
+ *response = DAP_ERROR;\r
+ return (2);\r
+#endif\r
+\r
+ case ID_DAP_TransferConfigure:\r
+ num = DAP_TransferConfigure(request, response);\r
+ break;\r
+\r
+ case ID_DAP_Transfer:\r
+ switch (DAP_Data.debug_port) {\r
+#if (DAP_SWD != 0)\r
+ case DAP_PORT_SWD:\r
+ num = DAP_SWD_Transfer (request, response);\r
+ break;\r
+#endif\r
+#if (DAP_JTAG != 0)\r
+ case DAP_PORT_JTAG:\r
+ num = DAP_JTAG_Transfer(request, response);\r
+ break;\r
+#endif\r
+ default:\r
+ *(response+0) = 0; // Response count\r
+ *(response+1) = 0; // Response value\r
+ num = 2;\r
+ }\r
+ break;\r
+\r
+ case ID_DAP_TransferBlock:\r
+ switch (DAP_Data.debug_port) {\r
+#if (DAP_SWD != 0)\r
+ case DAP_PORT_SWD:\r
+ num = DAP_SWD_TransferBlock (request, response);\r
+ break;\r
+#endif\r
+#if (DAP_JTAG != 0)\r
+ case DAP_PORT_JTAG:\r
+ num = DAP_JTAG_TransferBlock(request, response);\r
+ break;\r
+#endif\r
+ default:\r
+ *(response+0) = 0; // Response count [7:0]\r
+ *(response+1) = 0; // Response count[15:8]\r
+ *(response+2) = 0; // Response value\r
+ num = 3;\r
+ }\r
+ break;\r
+\r
+ case ID_DAP_WriteABORT:\r
+ switch (DAP_Data.debug_port) {\r
+#if (DAP_SWD != 0)\r
+ case DAP_PORT_SWD:\r
+ num = DAP_SWD_Abort (request, response);\r
+ break;\r
+#endif\r
+#if (DAP_JTAG != 0)\r
+ case DAP_PORT_JTAG:\r
+ num = DAP_JTAG_Abort(request, response);\r
+ break;\r
+#endif\r
+ default:\r
+ *response = DAP_ERROR;\r
+ return (2);\r
+ }\r
+ break;\r
+\r
+ default:\r
+ *(response-1) = ID_DAP_Invalid;\r
+ return (1);\r
+ }\r
+\r
+ return (1 + num);\r
+}\r
+\r
+\r
+// Setup DAP\r
+void DAP_Setup(void) {\r
+\r
+ // Default settings (only non-zero values)\r
+//DAP_Data.debug_port = 0;\r
+//DAP_Data.fast_clock = 0;\r
+ DAP_Data.clock_delay = CLOCK_DELAY(DAP_DEFAULT_SWJ_CLOCK);\r
+//DAP_Data.transfer.idle_cycles = 0;\r
+ DAP_Data.transfer.retry_count = 100;\r
+//DAP_Data.transfer.match_retry = 0;\r
+//DAP_Data.transfer.match_mask = 0x000000;\r
+#if (DAP_SWD != 0)\r
+ DAP_Data.swd_conf.turnaround = 1;\r
+//DAP_Data.swd_conf.data_phase = 0;\r
+#endif\r
+#if (DAP_JTAG != 0)\r
+//DAP_Data.jtag_dev.count = 0;\r
+#endif\r
+\r
+ DAP_SETUP(); // Device specific setup\r
+}\r
projects / armstart-ibdap / blobdiff