STM32

开贴记录SWD 脱机烧录器开发过程，请各路大神指教

2019-12-09 19:23发布

站内问答 / STM32/STM8
10894 94 95
参考 CMISI_DAP,BlackMagic代码。
预备下周末结案，目前方案：
1：Host用STM32F427，跑RTEMS系统， IO口模拟SWD时序。
2：flash的操作函数，由Host通过SWD下载入target ram执行。（CMISI_DAP采用这种方式）
     不知道jlink的flash操作是不是一样的原理。他要适用这么多芯片，那得有准备多少这样的小程序啊。。。
3：USB用的虚拟串口，用ST官方提供的驱动，上位机编程简单。tafget本身程序.bin文件由上位机通过虚拟串口传入。
     此虚拟串口的波特率，奇偶，起停位设置均形同虚设。

目前状态：
SWD时序基本调试通过，读写target ID/reg已经正常，暂时未经过高强度测试。。
正在弄flash操作。
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
该问题目前已经被作者或者管理员关闭, 无法添加新回复
94条回答
shangdawei
1楼-- · 2019-12-13 15:14
 精彩回答 2  元偷偷看……
shangdawei
2楼-- · 2019-12-13 19:03
ARM调试接口SWD(Serial Wire Debug) 协议分析
http://www.amobbs.com/thread-5498445-1-1.html
(出处: amoBBS 阿莫电子论坛)
shangdawei
3楼-- · 2019-12-13 20:34
ARM Debug Interface v5 Architecture Specification.pdf (1.67 MB, 下载次数: 64) 2015-8-22 22:30 上传 点击文件名下载附件
shangdawei
4楼-- · 2019-12-13 21:25
https://www.xiaopingtou.cn/data/attach/1912/biie33myl84bsf09u19qlymh3hakhhf4.jpg

HyperSnap1169.png (303.44 KB, 下载次数: 4)

下载附件

2015-8-22 23:29 上传

这个使用了 SPI 接口， 可以参考一下。

混合模式，传送 Request 和 Data 时用 SPI， 传送 ACK 时用模拟的。


  2. //=================================================================================
  3. // ARM SWD Mode Port Bit masks
  4. //
  5. #if (HW_CAPABILITY&CAP_SWD_HW)
  6. #ifndef DATA_PORT
  7. #define DATA_PORT          PTAD
  8. #define DATA_PORT_DDR      PTADD
  9. #define DATA_PORT_PER      PTAPE
  10. #endif

  12. // SWD data out pin
  13. #define SWD_OUT             PTAD_PTAD2
  14. #define SWD_OUT_BIT         (2)  // Bit number!
  15. #define SWD_OUT_MASK        (1<<SWD_OUT_BIT)
  16. #define SWD_OUT_PER         PTAPE_PTAPE2
  17. #define SWD_OUT_DDR         PTADD_PTADD2

  19. // SWD data out 3-state control
  20. #define SWD_OUT_EN          PTAD_PTAD4
  21. #define SWD_OUT_EN_BIT      (4)  // Bit number!
  22. #define SWD_OUT_EN_MASK     (1<<SWD_OUT_EN_BIT)
  23. #define SWD_OUT_EN_PER      PTAPE_PTAPE4
  24. #define SWD_OUT_EN_DDR      PTADD_PTADD4

  26. // Following assume pin already configured by SWD_LOW(),SWD_HIGH(),SWD_3STATE()
  27. #define SWD_ENABLE_ASM      BCLR SWD_OUT_EN_BIT,DATA_PORT
  28. #define SWD_3STATE_ASM      BSET SWD_OUT_EN_BIT,DATA_PORT
  29. #define SWD_LOW_ASM         BCLR SWD_OUT_BIT,DATA_PORT
  30. #define SWD_HIGH_ASM        BSET SWD_OUT_BIT,DATA_PORT
  31. #define SWD_DISABLE_ASM     BCLR SWD_OUT_EN_BIT,DATA_PORT_DDR
  32. #define SWD_ENABLE_DRV_ASM  BSET SWD_OUT_EN_BIT,DATA_PORT_DDR

  34. // Following configure pin & driver
  35. #define SWD_LOW()           (SWD_OUT=0, SWD_OUT_DDR=1, SWD_OUT_EN=0, SWD_OUT_EN_DDR=1)
  36. #define SWD_HIGH()          (SWD_OUT=1, SWD_OUT_DDR=1, SWD_OUT_EN=0, SWD_OUT_EN_DDR=1)
  37. #define SWD_3STATE()        (SWD_OUT_EN=1, SWD_OUT_EN_DDR=1, SWD_OUT_DDR=1)
  38. #define SWD_DISABLE()       (SWD_OUT_EN=1, SWD_OUT_EN_DDR=0, SWD_OUT_DDR=0) // PUPs

  40. // SWD data in pin
  41. #define SWD_IN              PTAD_PTAD0
  42. #define SWD_IN_BIT          (0)  // Bit number!
  43. #define SWD_IN_MASK         (1<<SWD_IN_BIT)
  44. #define SWD_IN_PER          PTAPE_PTAPE0
  45. #define SWD_IN_DDR          PTADD_PTADD0

  47. // SWCLK out pin
  48. #define SWCLK_OUT           PTAD_PTAD3
  49. #define SWCLK_OUT_BIT       (3)  // Bit number!
  50. #define SWCLK_OUT_MASK      (1<<SWCLK_OUT_BIT)
  51. #define SWCLK_OUT_PER       PTAPE_PTAPE3
  52. #define SWCLK_OUT_DDR       PTADD_PTADD3

  54. // SWCLK enable pin - controls buffer enable
  55. #define SWCLK_OUT_EN        PTBD_PTBD1
  56. #define SWCLK_OUT_EN_BIT    (1)  // Bit number!
  57. #define SWCLK_OUT_EN_MASK   (1<<SWCLK_OUT_EN_BIT)
  58. #define SWCLK_OUT_EN_PER    PTBPE_PTBPE1
  59. #define SWCLK_OUT_EN_DDR    PTBDD_PTBDD1

  61. // Following assume pin direction already set
  62. #define SWCLK_LOW_ASM       BCLR SWCLK_OUT_BIT,DATA_PORT
  63. #define SWCLK_HIGH_ASM      BSET SWCLK_OUT_BIT,DATA_PORT

  65. // Following configure pin & driver
  66. #define SWCLK_LOW()         (SWCLK_OUT=0, SWCLK_OUT_DDR=1, SWCLK_OUT_EN=0, SWCLK_OUT_EN_DDR=1)
  67. #define SWCLK_HIGH()        (SWCLK_OUT=1, SWCLK_OUT_DDR=1, SWCLK_OUT_EN=0, SWCLK_OUT_EN_DDR=1)
  68. #define SWCLK_3STATE()      (SWCLK_OUT_EN=1, SWCLK_OUT_EN_DDR=1, SWCLK_OUT_DDR=1) // PUPs
  69. #define SWCLK_DISABLE()     (SWCLK_OUT_EN=1, SWCLK_OUT_EN_DDR=0, SWCLK_OUT_DDR=0) // PUPs

  71. #endif // CAP_SWD
复制代码
  1. /*
  2. * SWD.h
  3. *
  4. *  Created on: 04/08/2012
  5. *      Author: PODonoghue
  6. */

  8. #ifndef SWD_H_
  9. #define SWD_H_

  11. #include "Common.h"

  13. // Ack values displaced by offset introduced during read (left justified 8-bit value)
  14. #define SWD_ACK_OK       (0x1<<5)
  15. #define SWD_ACK_WAIT     (0x2<<5)
  16. #define SWD_ACK_FAULT    (0x4<<5)
  17. #define SWD_ACK_PROTOCOL (0x7<<5)

  19. void swd_interfaceIdle(void);
  20. void swd_init(void);
  21. void swd_txIdle8(void);

  23. U8 swd_test(void);

  25. U8 swd_sendCommandWithWait(U8 command);

  27. U8 swd_connect(void);
  28. U8 swd_readReg(U8 command, U8 *data);
  29. U8 swd_writeReg(U8 command, const U8 *data);
  30. U8 swd_readAPReg(const U8 *address, U8 *buff);
  31. U8 swd_writeAPReg(const U8 *address, const U8 *buff);
  32. U8 swd_clearStickyError(void);
  33. U8 swd_abortAP(void);
  34. #endif /* SWD_H_ */
复制代码
  1. /*! file
  2.     rief ARM-SWD routines

  4.    verbatim

  6.    USBDM

  8.    Copyright (C) 2007  Peter O'Donoghue

  10.    This program is free software; you can redistribute it and/or modify
  11.    it under the terms of the GNU General Public License as published by
  12.    the Free Software Foundation; either version 2 of the License, or
  13.    (at your option) any later version.

  15.    This program is distributed in the hope that it will be useful,
  16.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.    GNU General Public License for more details.

  20.    You should have received a copy of the GNU General Public License
  21.    along with this program; if not, write to the Free Software
  22.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23.    endverbatim

  25.    Change History
  26.    +==================================================================================================
  27.    | 21 Feb 2014 | Fixed unbalanced stack in swd_sendCommandWithWait()                      V4.10.6.30
  28.    | 10 Feb 2014 | Dramatically extended retry times to allow for slow clocks               V4.10.6.20
  29.    | 30 Aug 2012 | ARM-JTAG & ARM-SWD Changes                                               V4.9.5
  30.    +==================================================================================================
  31.    endverbatim
  32. */

  34. #include "Common.h"
  35. #include "Configure.h"
  36. #include "Commands.h"
  37. #include "SWD.h"
  38. #include "Commands.h"
  39. #include "BDM.h"
  40. #include "BDM_CF.h"
  41. #include "CmdProcessing.h"
  42. #include "BDMCommon.h"
  43. #include "SPI.h"
  44. #include "TargetDefines.h"
  45. #include "SWD.h"
  46.   
  47. #if TARGET_CAPABILITY & CAP_ARM_SWD

  49. //! SPI Masks - Mask to enable SPI as master Tx
  50. #define SPIxC1_OFF      (SPIxC1_MSTR_MASK)     //!< SPI Masks - Mask to disable SPI
  51. #define SPIxC1_M_ON_TX  (SPIxC1_SPE_MASK|SPIxC1_MSTR_MASK|SPIxC1_CPOL_MASK|SPIxC1_CPHA_MASK|SPIxC1_SSOE_MASK|SPIxC1_LSBFE_MASK)
  52. #define SPIxC1_M_ON_RX  (SPIxC1_SPE_MASK|SPIxC1_MSTR_MASK|SPIxC1_CPOL_MASK)                   //!< SPI Masks - Mask to enable SPI as master Tx
  53. #define SPIxC2_M_8      (0)                                                                   //!< SPI Masks - 8-bit mode
  54. #define SPIxC2_M_16     (SPIxC2_SPIMODE_MASK)                                                 //!< SPI Masks - 8-bit mode

  56. // Can't use enumerations in assembly code
  57. #define BDM_RC_OKx                 (0)
  58. #define BDM_RC_NO_CONNECTIONx      (5)
  59. #define BDM_RC_ACK_TIMEOUTx        (30)
  60. #define BDM_RC_ARM_PARITY_ERRORx   (51)
  61. #define BDM_RC_ARM_FAULT_ERRORx    (52)

  63. #define SWD_READ_IDCODE 0xA5 // (Park,Stop,Parity,A[32],R/W,AP/DP,Start) = 10100101

  65. // Masks for SWD_WR_DP_ABORT clear sticky
  66. #define SWD_DP_ABORT_CLEAR_STICKY_ERRORS_B3 0x1E

  68. // Masks for SWD_WR_DP_ABORT abort AP
  69. #define SWD_DP_ABORT_ABORT_AP_B3 0x01

  71. // Masks for SWD_RD_DP_STATUS
  72. #define SWD_RD_DP_STATUS_ANYERROR_B3 0xB2

  74. #pragma MESSAGE DISABLE C1404 // Disable warnings about missing return value
  75. #pragma MESSAGE DISABLE C5703 // Disable warnings about unused parameter

  77. //! Sets the SWD interface to an idle state
  78. //! RESET=3-state, SWCLK=High, SWDIO=3-state (SPI off)
  79. //!
  80. void swd_interfaceIdle(void) {
  81. #ifdef RESET_3STATE
  82.    RESET_3STATE();
  83. #endif   
  84.    SWD_3STATE();
  85.    SWCLK_HIGH();
  86.    SPIC1 = SPIxC1_OFF;
  87. }

  89. //! Initialise the SWD interface and sets it to an idle state
  90. //! RESET=3-state, SWCLK=High, SWDIO=3-state
  91. //!
  92. //! @note This includes once-off initialisation such as PUPs etc
  93. //!
  94. void swd_init(void) {
  95.    // 4 pins SWD_OUT, SWD_OUT_EN, SWCLK_OUT, SWCLK_OUT_EN
  96.    // Individually controlled PUPs
  97.    SWD_OUT_PER      = 1;     // Prevent float when disabled
  98.    SWD_OUT_EN_PER   = 1;     // Prevent drive when disabled
  99.    SWCLK_OUT_PER    = 1;     // Prevent float when disabled
  100.    SWCLK_OUT_EN_PER = 1;     // Prevent drive when disabled
  101.    
  102.    SWD_IN_DDR       = 0;  // Make input
  103.    SWD_IN_PER       = 1;  // Shouldn't be req. as external PUP for speed
  104.    
  105. #ifdef RESET_IN_DDR
  106.    RESET_IN_DDR     = 0;     // Make input
  107. #endif
  108. #ifdef RESET_IN_PER
  109.    RESET_IN_PER     = 1;     // Needed for input level translation to 5V
  110. #endif
  111. #ifdef RESET_OUT_PER
  112.    RESET_OUT_PER    = 1;     // Holds RESET_OUT inactive when unused
  113. #endif
  114.    (void)spi_setSpeed(0);
  115.    swd_interfaceIdle();
  116. }

  118. //!  Turns off the SWD interface
  119. //!
  120. //!  Depending upon settings, may leave target power on.
  121. //!
  122. void swd_off( void ) {
  123. #if ((HW_CAPABILITY & CAP_FLASH) != 0)
  124.    (void)bdmSetVpp(BDM_TARGET_VPP_OFF);
  125. #endif
  126.    if (!bdm_option.leaveTargetPowered) {
  127.       VDD_OFF();
  128.    }
  129.    swd_interfaceIdle();
  130.    SWCLK_DISABLE();
  131.    SWD_DISABLE();
  132.    RESET_DISABLE();
  133. }

  135. #define SWD_DATA1_CLK1 SWCLK_OUT_MASK|SWD_OUT_EN_MASK
  136. #define SWD_DATA0_CLK1 SWCLK_OUT_MASK|0

  138. //! Transmits 1 clock with SWDIO 3-state
  139. //!
  140. void swd_turnAround() {
  141.    asm {               
  142.       // 1 clock turn-around
  143.       mov    #SWD_OUT_MASK,DATA_PORT        // SWDIO=3-state,SWCLK=0
  144.       ldx    bitDelay                       // Low time delay
  145.       dbnzx  *-0                            // [4n fppp]
  146.       bset   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=1
  147.       ldx    bitDelay                       // High time delay
  148.       dbnzx  *-0                            // [4n fppp]
  149.    }
  150. }

  152. //! Transmits 8-bits of idle (SDIO=0)
  153. //!
  154. void swd_txIdle8(void) {
  155.    asm {               
  156.      mov    #SPIxC2_M_8,SPIxC2             // Initialise SPI (8 bit)
  157.      mov    #SPIxC1_M_ON_TX,SPIC1          // Enable SPI
  158.      clr    DATA_PORT                      // Enable SWD drive
  159.      cmp    SPIxS                          // Dummy status read
  160.      clr    SPIxD                          // Tx data (=0)
  161.    L1:
  162.      brclr  SPIS_SPRF_BIT,SPIxS,L1         // Wait until Tx/Rx complete
  163.      lda    SPIxD                          // Discard rx data
  164.      mov    #SWCLK_OUT_MASK|SWD_OUT_EN_MASK,DATA_PORT // Setup for SWCLK=1, SWD=3-state
  165.      clr    SPIC1                          // Disable SPI
  166.    }
  167. }

  169. #if (SWD_IN_BIT != 0)
  170. #error "SWD_IN must be bit #0"
  171. #endif
  172. #pragma MESSAGE DISABLE C5703  // Disable warnings about unused parameter
  173. //! SWD command phase
  174. //!
  175. //! Writes 8-bit command and receives 3-bit response
  176. //! It will retry on WAIT response a limited number of times
  177. //!
  178. //! @param command - 8-bit command to write to SWD (including parity!)
  179. //!
  180. //! @return
  181. //!    == ef BDM_RC_OK              => Success        
  182. //!    == ef BDM_RC_ARM_FAULT_ERROR => FAULT response from target
  183. //!    == ef BDM_RC_ACK_TIMEOUT     => Excessive number of WAIT responses from target
  184. //!    == ef BDM_RC_NO_CONNECTION   => Unexpected/no response from target
  185. //!
  186. //! @note A turn-around clock period will be added on error responses
  187. //!
  188. uint8_t swd_sendCommandWithWait(uint8_t command) {
  189.    asm {
  190.           sta    txTiming1                      // Save data (for retry)
  191.           ldx    #(2000/250)                    // Set up outer retry count

  193.    retry_outer:
  194.           pshx                                  // Save outer retry count
  195.       mov    #250,rxTiming1                 // Reset inner retry count

  197.    retry:
  198.    
  199.       // 8-bit Start|APnDP|R/W|Parity|Stop|Park
  200.       lda    txTiming1                      // Get Tx data
  201.       mov    #SPIxC2_M_8,SPIxC2             // Initialise SPI (8 bit)
  202.       mov    #SPIxC1_M_ON_TX,SPIC1          // Enable SPI
  203.       clr    DATA_PORT                      // Enable SWD drive
  204.       cmp    SPIxS                          // Dummy status read
  205.       sta    SPIxD                          // Tx data
  206.    L1:
  207.       brclr  SPIS_SPRF_BIT,SPIxS,L1         // Wait until Tx/Rx complete
  208.       ldx    SPIxD                          // Discard rx data
  209.       SWD_3STATE_ASM                        // SWD=3-state
  210.       clr    SPIC1                          // Disable SPI

  212.       // 1 clock turn-around
  213.       bclr   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=0
  214.       ldx    bitDelay                       // Low time delay
  215.       dbnzx  *-0                            // [4n fppp]
  216.       bset   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=1
  217.       ldx    bitDelay                       // High time delay
  218.       dbnzx  *-0                            // [4n fppp]
  219.       
  220.       // 1st bit ACK
  221.       clra                                  // Clear initial data value
  222.       bclr   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=0
  223.       ldx    bitDelay                       // Low time delay
  224.       dbnzx  *-0                            // [4n fppp]
  225.       ldx    DATA_PORT                      // Capture data before rising edge
  226.       rorx
  227.       rora
  228.       bset   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=1
  229.       ldx    bitDelay                       // High time delay
  230.       dbnzx  *-0                            // [4n fppp]

  232.       // 2nd bit ACK
  233.       bclr   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=0
  234.       ldx    bitDelay                       // Low time delay
  235.       dbnzx  *-0                            // [4n fppp]
  236.       ldx    DATA_PORT                      // Capture data before rising edge
  237.       rorx
  238.       rora
  239.       bset   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=1
  240.       ldx    bitDelay                       // High time delay
  241.       dbnzx  *-0                            // [4n fppp]

  243.       // 3rd bit ACK
  244.       bclr   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=0
  245.       ldx    bitDelay                       // Low time delay
  246.       dbnzx  *-0                            // [4n fppp]
  247.       ldx    DATA_PORT
  248.       rorx
  249.       rora      
  250.       bset   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=1
  251.       ldx    bitDelay                       // High time delay
  252.       dbnzx  *-0                            // [4n fppp]
  253.       
  254.       tax
  255.       lda    #BDM_RC_OKx
  256.       cbeqx  #SWD_ACK_OK,balanceStack
  257.       
  258.       // Do turn-around clock on anything other than ACK_OK response
  259.       bclr   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=0
  260.       lda    bitDelay                       // Low time delay
  261.       dbnza  *-0                            // [4n fppp]
  262.       bset   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=1
  263.       lda    bitDelay                       // High time delay
  264.       dbnza  *-0                            // [4n fppp]
  265.       
  266.       // Check for wait response
  267.       cpx    #SWD_ACK_WAIT                  // Wait response?
  268.       bne    identifyError                  // No - exit with other error
  269.       
  270.       // Check for wait timeout
  271.       dbnz   rxTiming1,retry                // Retry limit reached
  272.       pulx
  273.       dbnzx  retry_outer   

  275.       lda    #BDM_RC_ACK_TIMEOUTx           // Too many retries
  276.       bra    done                           // Return error (stack already balanced)
  277.       
  278.    identifyError:
  279.       lda    #BDM_RC_ARM_FAULT_ERRORx       // Identify error
  280.       cbeqx  #SWD_ACK_FAULT,balanceStack
  281.       lda    #BDM_RC_NO_CONNECTIONx
  282.       
  283.    balanceStack:
  284.       pulx                                  // Balance stack
  285.       
  286.    done:
  287.    }
  288. }

  290. #pragma MESSAGE DEFAULT C5703 // Restore warnings about unused parameter

  292. #pragma MESSAGE DISABLE C5703 // Disable warnings about unused parameter
  293. //! Transmits 32-bit value
  294. //!
  295. //! Sequence as follows:
  296. //!   - 1-clock turn-around
  297. //!   - 32-bit data value
  298. //!   - 1-bit parity
  299. //!   - 8-bit idle
  300. //!
  301. //! @param data - ptr to 32-bit data to Tx
  302. //!
  303. static void swd_tx32(const uint8_t *data) {
  304.    asm {
  305.       // 1 clock turn-around
  306.       bclr   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=0
  307.       lda    bitDelay                       // Low time delay
  308.       dbnza  *-0                            // [4n fppp]
  309.       bset   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=1

  311.       mov    #SPIxC2_M_16,SPIxC2            // Initialise SPI (16 bit)
  312.       mov    #SPIxC1_M_ON_TX,SPIxC1         // Enable SPI
  313.       clr    DATA_PORT                      // Enable SWD drive

  315.       cmp    SPIxS                          // Dummy status read
  316.       
  317.       lda    3,x                            // Start Tx 1st & 2nd bytes
  318.       sta    SPIxDL                        
  319.       lda    2,x
  320.       sta    SPIxDH                        
  321.       lda    0,x                            // Do byte-wide parity
  322.       eor    1,x
  323.       eor    2,x
  324.       eor    3,x
  325.       ldhx   0,x                            // Get 3rd & 4th bytes
  326.   L1:
  327.       brclr  SPIS_SPRF_BIT,SPIxS,L1         // Wait until previous Tx/Rx complete
  328.       cphx   SPIxD16                        // Discard read data
  329.       sthx   SPIxD16                        // Tx 3rd & 4th bytes
  330.       
  331.       // Calculate nibble parity
  332.       psha             // [2]
  333.       nsa              // [1]
  334.       eor    1,sp      // [4]
  335.       ais    #1        // [2]
  336.       
  337.       // Calculate final parity
  338.       tax              // [1]
  339.       clra             // [1]
  340.       rorx             // [1]
  341.       adc    #0        // [2]
  342.       rorx             // [1]
  343.       adc    #0        // [2]
  344.       rorx             // [1]
  345.       adc    #0        // [2]
  346.       rorx             // [1]
  347.       adc    #0        // [2]
  348.       //parity in A.0

  350.   L2:
  351.      brclr  SPIS_SPRF_BIT,SPIxS,L2         // Wait until previous Tx/Rx complete
  352.      ldhx   SPIxD16                        // Discard read data
  353.       
  354. #if SWD_OUT_BIT >= 1                        // move to SWD_OUT position
  355.       lsla
  356. #endif
  357. #if SWD_OUT_BIT == 2
  358.       lsla
  359. #else
  360. #error Fix this code
  361. #endif
  362.       and    #SWD_OUT_MASK                  // SWD=p, SWCLK=0
  363.       sta    DATA_PORT                      // Set up - no effect yet
  364.       ldx    bitDelay                       // Low time delay
  365.       clr    SPIC1                          // Disable SPI,  
  366.       dbnzx  *-0                            // [4n fppp]
  367.       bset   SWCLK_OUT_BIT,DATA_PORT        // SWD=p, SWCLK=1

  369.       // Start Tx of 8-bit idle
  370.      mov    #SPIxC2_M_8,SPIxC2             // Initialise SPI (8 bit)
  371.      mov    #SPIxC1_M_ON_TX,SPIC1          // Enable SPI
  372.      clr    DATA_PORT                      // Enable SWD drive
  373.      cmp    SPIxS                          // Dummy status read
  374.      clr    SPIxD                          // Tx data (=0)

  376.      // Wait for Idle Tx to complete
  377.    L3:
  378.      brclr  SPIS_SPRF_BIT,SPIxS,L3         // Wait until Tx/Rx complete
  379.      cmp    SPIxD                          // Discard rx data
  380.      mov    #SWCLK_OUT_MASK|SWD_OUT_EN_MASK,DATA_PORT // Setup for SWCLK=1, SWD=3-state
  381.      clr    SPIC1                          // Disable SPI
  382.       rts
  383.    }
  384. }
  385. #pragma MESSAGE DEFAULT C5703 // Restore warnings about unused parameter

  387. #pragma MESSAGE DISABLE C5703 // Disable warnings about unused parameter
  388. //! Receives a 32-bit value with parity at end (33 total)
  389. //!
  390. //! Sequence as follows:
  391. //!   - 32-bit data value
  392. //!   - 1-bit parity
  393. //!   - 8-bit idle
  394. //!
  395. //! @param data - ptr to buffer for Rx data
  396. //!
  397. //! @return BDM_RC_OK
  398. //!         BDM_RC_ARM_PARITY_ERROR
  399. //!
  400. static uint8_t swd_rx32(uint8_t *data) {
  401. #define SPIS_SPTEF_BIT (5)
  402. #define SPIS_SPRF_BIT  (7)

  404.    asm {
  405.       SWD_3STATE_ASM                        // SWD=3-state
  406.       mov    #SPIxC2_M_16,SPIxC2            // Initialise SPI (16 bit)
  407.       mov    #SPIxC1_M_ON_TX,SPIxC1         // Enable SPI
  408.       cmp    SPIxS                          // Dummy status read

  410.       sthx   SPIxD16                        // Tx dummy/Rx                        
  411.   L1:
  412.       brclr  SPIS_SPRF_BIT,SPIxS,L1         // Wait until Rx complete
  413.       lda    SPIxDH                         // Save data
  414.       sta    2,x
  415.       lda    SPIxDL
  416.       sta    3,x
  417.       sthx   SPIxD16                        // Tx dummy/Rx                        
  418.   L2:
  419.       brclr  SPIS_SPRF_BIT,SPIxS,L2         // Wait until Rx complete
  420.       lda    SPIxDH                         // Save data
  421.       sta    0,x
  422.       lda    SPIxDL
  423.       sta    1,x

  425.       bclr   SWCLK_OUT_BIT,DATA_PORT        // Setup for SWCLK=0
  426.       clr    SPIC1                          // Disable SPI (SWCLK=0)

  428.       // Parity bit
  429.       lda    bitDelay                       // Low time delay
  430.       dbnza  *-0                            // [4n fppp]
  431.       lda    DATA_PORT                      // Capture data before rising clock edge
  432.       bset   SWCLK_OUT_BIT,DATA_PORT        // SWCLK=1
  433.       and    #SWD_IN_MASK                   // Convert parity to byte width
  434.       // Single Parity bit remains - position is unimportant

  436.       // Start Tx of 8-bit idle
  437.       mov    #SPIxC2_M_8,SPIxC2             // Initialise SPI (8 bit)
  438.       mov    #SPIxC1_M_ON_TX,SPIC1          // Enable SPI
  439.       clr    DATA_PORT                      // Enable SWD drive
  440.       cmp    SPIxS                          // Dummy status read
  441.       clr    SPIxD                          // Tx data (=0)

  443.       // Do parity calculation
  444.       eor    0,x                            // Do byte-wide parity on data & parity bit
  445.       eor    1,x
  446.       eor    2,x
  447.       eor    3,x

  449.       ldx    bitDelay                       // High time delay
  450.       dbnzx  *-0                            // [4n fppp]

  452.       // Calculate nibble parity
  453.       psha             // [2]
  454.       nsa              // [1]
  455.       eor    1,sp      // [4]
  456.       ais    #1        // [2]

  458.       // Calculate final parity
  459.       tax              // [1]
  460.       clra             // [1]
  461.       rorx             // [1]
  462.       adc    #0        // [2]
  463.       rorx             // [1]
  464.       adc    #0        // [2]
  465.       rorx             // [1]
  466.       adc    #0        // [2]
  467.       rorx             // [1]
  468.       adc    #0        // [2]
  469.       and    #1
  470.       // Parity in A.0 - should be 0
  471.       beq    okExit
  472.       lda    #BDM_RC_ARM_PARITY_ERRORx
  473.    okExit:

  475.       // Wait for Idle Tx to complete
  476.    L3:
  477.       brclr  SPIS_SPRF_BIT,SPIxS,L3         // Wait until Tx/Rx complete
  478.       cmp    SPIxD                          // Discard rx data
  479.       mov    #SWCLK_OUT_MASK|SWD_OUT_EN_MASK,DATA_PORT // Setup for SWCLK=1, SWD=3-state
  480.       clr    SPIC1                          // Disable SPI
  481.       rts
  482.    }
  483. }
  484. #pragma MESSAGE DEFAULT C5703 // Restore warnings about unused parameter

  486. #pragma MESSAGE DISABLE C5703 // Disable warnings about unused parameter
  487. //! Switches interface to SWD
  488. //!
  489. //! Sequence as follows:
  490. //!  - 64-bit sequence of 1's
  491. //!  - 8-bit magic number 0xE79E
  492. //!  - 64-bit sequence of 1's
  493. //!
  494. //! @note Interface is reset even if already in SWD mode so IDCODE must be read
  495. //!       to enable interface
  496. //!
  497. static void swd_JTAGtoSWD(void) {
  498.    asm {
  499.       mov    #SPIxC2_M_16,SPIxC2            // Initialise SPI (16 bit)
  500.       mov    #SPIxC1_M_ON_TX,SPIxC1         // Enable SPI
  501.       clr    DATA_PORT                      // Enable SWD drive
  502.       cmp    SPIxS                          // Dummy status read
  503.       
  504.       bsr    txOnes                         // Send 64 clocks
  505.       ldhx   #0xE79E                        // Send magic #
  506.       sthx   SPIxD16                        
  507.   L5:
  508.       brclr  SPIS_SPTEF_BIT,SPIxS,L5        // Wait until Tx buffer empty
  509.       bsr    txOnes                         // Send 64 clocks
  510.   L6:
  511.       brclr  SPIS_SPTEF_BIT,SPIxS,L6                   // Wait until Tx buffer empty
  512.       ldhx   SPIxD16                                   // Discard last data
  513.       mov    #SWCLK_OUT_MASK|SWD_OUT_EN_MASK,DATA_PORT // Setup for SWCLK=1, SWD=3-state
  514.   L7:
  515.       brclr  SPIS_SPRF_BIT,SPIxS,L7                    // Wait until Tx complete
  516.       ldhx   SPIxD16                                   // Discard rx data
  517.       clr    SPIC1                                     // Disable SPI (SWCLK=1)
  518.       rts
  519.       
  520.   txOnes:
  521.       ldhx   #0xFFFF                        // Tx 64 bits with '1'
  522.       sthx   SPIxD16                        
  523.   L1:
  524.       brclr  SPIS_SPTEF_BIT,SPIxS,L1        // Wait until Tx buffer empty
  525.       sthx   SPIxD16                        
  526.   L2:
  527.       brclr  SPIS_SPTEF_BIT,SPIxS,L2        // Wait until Tx buffer empty
  528.       sthx   SPIxD16                        
  529.   L3:
  530.       brclr  SPIS_SPTEF_BIT,SPIxS,L3        // Wait until Tx buffer empty
  531.       sthx   SPIxD16                        
  532.   L4:
  533.       brclr  SPIS_SPTEF_BIT,SPIxS,L4        // Wait until Tx buffer empty
  534.       rts
  535.    }
  536. }
  537. #pragma MESSAGE DEFAULT C5703 // Restore warnings about unused parameter

  539. //! SWD - Try to connect to the target
  540. //!
  541. //! This will do the following:
  542. //! - Switch the interface to SWD mode
  543. //! - Read IDCODE
  544. //!
  545. //! @return
  546. //!    == ef BDM_RC_OK              => Success        
  547. //!    == ef BDM_RC_NO_CONNECTION   => Unexpected/no response from target
  548. //!
  549. uint8_t swd_connect(void) {
  550.    uint8_t buff[4];        
  551.    
  552.    swd_JTAGtoSWD();
  553.    swd_txIdle8();
  554.      
  555.    // Target must respond to read IDCODE immediately
  556.    return swd_readReg(SWD_READ_IDCODE, buff);
  557. }

  559. //! Read ARM-SWD DP & AP register
  560. //!
  561. //! @param command - SWD command byte to select register etc.
  562. //! @param data    - buffer for 32-bit value read
  563. //!
  564. //! @return
  565. //!    == ef BDM_RC_OK               => Success        
  566. //!    == ef BDM_RC_ARM_FAULT_ERROR  => FAULT response from target
  567. //!    == ef BDM_RC_ACK_TIMEOUT      => Excessive number of WAIT responses from target
  568. //!    == ef BDM_RC_NO_CONNECTION    => Unexpected/no response from target
  569. //!    == ef BDM_RC_ARM_PARITY_ERROR => Parity error on data read
  570. //!
  571. //! @note Action and Data returned depends on register (some responses are pipelined)
  572. //!   SWD_RD_DP_IDCODE - Value from IDCODE reg
  573. //!   SWD_RD_DP_STATUS - Value from STATUS reg
  574. //!   SWD_RD_DP_RESEND - LAST value read (AP read or DP-RDBUFF), FAULT on sticky error   
  575. //!   SWD_RD_DP_RDBUFF - Value from last AP read and clear READOK flag in STRL/STAT, FAULT on sticky error
  576. //!   SWD_RD_AP_REGx   - Value from last AP read, clear READOK flag in STRL/STAT and INITIATE next AP read, FAULT on sticky error
  577. //!
  578. uint8_t swd_readReg(uint8_t command, uint8_t *data) {
  579.    uint8_t rc = swd_sendCommandWithWait(command);
  580.    if (rc != BDM_RC_OK) {
  581.       return rc;
  582.    }
  583.    return swd_rx32(data);
  584. }

  586. //! Write ARM-SWD DP & AP register
  587. //!
  588. //! @param command - SWD command byte to select register etc.
  589. //! @param data    - buffer containing 32-bit value to write
  590. //!
  591. //! @return
  592. //!    == ef BDM_RC_OK               => Success        
  593. //!    == ef BDM_RC_ARM_FAULT_ERROR  => FAULT response from target
  594. //!    == ef BDM_RC_ACK_TIMEOUT      => Excessive number of WAIT responses from target
  595. //!    == ef BDM_RC_NO_CONNECTION    => Unexpected/no response from target
  596. //!
  597. //! @note Action depends on register (some responses are pipelined)
  598. //!   SWD_WR_DP_ABORT   - Write value to ABORT register (accepted)
  599. //!   SWD_WR_DP_CONTROL - Write value to CONTROL register (may be pending), FAULT on sticky error.
  600. //!   SWD_WR_DP_SELECT  - Write value to SELECT register (may be pending), FAULT on sticky error.
  601. //!   SWD_WR_AP_REGx    - Write to AP register.  May initiate action e.g. memory access.  Result is pending, FAULT on sticky error.
  602. //!
  603. uint8_t swd_writeReg(uint8_t command, const uint8_t *data) {
  604.    uint8_t rc = swd_sendCommandWithWait(command);
  605.    if (rc != BDM_RC_OK) {
  606.       return rc;
  607.    }
  608.    swd_tx32(data);
  609.    return rc;
  610. }

  612. //! Write register of Access Port
  613. //!
  614. //! @param 16-bit address
  615. //!    A[15:8]  => DP-AP-SELECT[31:24] (AP # Select)
  616. //!    A[7:4]   => DP-AP-SELECT[7:4]   (Bank select within AP)
  617. //!    A[3:2]   => APACC[3:2]          (Register select within bank)
  618. //! @param buff
  619. //!   - [1..4]  =>  32-bit register value
  620. //!
  621. //! @return
  622. //!  == ef BDM_RC_OK => success
  623. //!
  624. //! @note - Access is completed before return
  625. //!
  626. uint8_t swd_writeAPReg(const uint8_t *address, const uint8_t *buff) {
  627.    static const uint8_t writeAP[] = {SWD_WR_AP_REG0,   SWD_WR_AP_REG1,    SWD_WR_AP_REG2,   SWD_WR_AP_REG3};
  628.    uint8_t rc;
  629.    uint8_t regNo = writeAP[(address[1]&0xC)>>2];
  630.    uint8_t selectData[4];
  631.    selectData[0] = address[0];
  632.    selectData[1] = 0;
  633.    selectData[2] = 0;
  634.    selectData[3] = address[1]&0xF0;
  635.    
  636.    // Set up SELECT register for AP access
  637.    rc = swd_writeReg(SWD_WR_DP_SELECT, selectData);
  638.    if (rc != BDM_RC_OK) {
  639.       return rc;
  640.    }
  641.    // Initiate write to AP register
  642.    rc = swd_writeReg(regNo, buff);
  643.    if (rc != BDM_RC_OK) {
  644.       return rc;
  645.    }
  646.    // Read from READBUFF register to allow stall/status response
  647.    return swd_readReg(SWD_RD_DP_RDBUFF, selectData);
  648. }

  650. //! Read register of Access Port
  651. //!
  652. //! @param 16-bit address
  653. //!    A[15:8]  => DP-AP-SELECT[31:24] (AP # Select)
  654. //!    A[7:4]   => DP-AP-SELECT[7:4]   (Bank select within AP)
  655. //!    A[3:2]   => APACC[3:2]          (Register select within bank)
  656. //! @param buff
  657. //!   - [1..4]  =>  32-bit register value
  658. //!
  659. //! @return
  660. //!  == ef BDM_RC_OK => success
  661. //!
  662. //! @note - Access is completed before return
  663. //!
  664. uint8_t swd_readAPReg(const uint8_t *address, uint8_t *buff) {
  665.    static const uint8_t readAP[]  = {SWD_RD_AP_REG0,   SWD_RD_AP_REG1,    SWD_RD_AP_REG2,   SWD_RD_AP_REG3};
  666.    uint8_t rc;
  667.    uint8_t regNo = readAP[(address[1]&0xC)>>2];
  668.    uint8_t selectData[4];
  669.    selectData[0] = address[0];
  670.    selectData[1] = 0;
  671.    selectData[2] = 0;
  672.    selectData[3] = address[1]&0xF0;

  674.    // Set up SELECT register for AP access
  675.    rc = swd_writeReg(SWD_WR_DP_SELECT, selectData);
  676.    if (rc != BDM_RC_OK) {
  677.      return rc;
  678.    }
  679.    // Initiate read from AP register (dummy data)
  680.    rc = swd_readReg(regNo, buff);
  681.    if (rc != BDM_RC_OK) {
  682.      return rc;           
  683.    }
  684.    // Read from READBUFF register
  685.    return swd_readReg(SWD_RD_DP_RDBUFF, buff);
  686. }

  688. //! ARM-SWD - clear sticky bits
  689. //!
  690. //! @return error code
  691. //!
  692. uint8_t swd_clearStickyError(void) {
  693.    static const uint8_t swdClearErrors[4] = {0,0,0,SWD_DP_ABORT_CLEAR_STICKY_ERRORS_B3};
  694.    return swd_writeReg(SWD_WR_DP_ABORT, swdClearErrors);
  695. }

  697. //! ARM-SWD - clear sticky bits and abort AP transactions
  698. //!
  699. //! @return error code
  700. //!
  701. uint8_t swd_abortAP(void) {
  702.    static const uint8_t swdClearErrors[4] =
  703.       {0,0,0,SWD_DP_ABORT_CLEAR_STICKY_ERRORS_B3|SWD_DP_ABORT_ABORT_AP_B3};
  704.    return swd_writeReg(SWD_WR_DP_ABORT, swdClearErrors);
  705. }

  707. uint8_t swd_test(void) {
  708.    return swd_connect();
  709. //   swd_JTAGtoSWD();
  710. //   return BDM_RC_OK;
  711. //   return swd_connect();
  712. }
  713. #endif // HW_CAPABILITY && CAP_SWD_HW
复制代码

shangdawei
5楼-- · 2019-12-14 01:47
abbott.yang 发表于 2015-8-21 16:12
观察了SWD波形，想用SPI的8字节数据去套这个协议。。可惜都不是8字节对齐，中间还有有接收ACK。。。shang ...

JLink 大概用到了 TIMER + SPI + DMA， 没有频繁的中断。
huangqi412
6楼-- · 2019-12-14 03:25
 精彩回答 2  元偷偷看……
首页 上一页 4 5 6 7 8 9 10 11 下一页 最后一页

一周热门 更多>