Sophie Dexter / Mbed 2 deprecated Just4Trionic

Just4Trionic - CAN and BDM FLASH programmer for Saab cars

Dependencies:   mbed

bdmcpu32.cpp@3:92dae9083c83, 2011-06-07 (annotated)

Committer:
Just4pLeisure
Date:
Tue Jun 07 12:23:28 2011 +0000
Revision:
3:92dae9083c83
Parent:
2:bf3a2b29259a
Child:
4:682d96ff6d79
Basic T7 CAN DUMP and FLASH for P-BUS connection only

Requires MyBooty V2.x for T5 CAN FLASHing at 1 Mbps

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Just4pLeisure 1:d5452e398b76 1 /*******************************************************************************
Just4pLeisure 1:d5452e398b76 2
Just4pLeisure 1:d5452e398b76 3 bdmcpu32.cpp
Just4pLeisure 1:d5452e398b76 4 (c) 2010 by Sophie Dexter
Just4pLeisure 1:d5452e398b76 5
Just4pLeisure 1:d5452e398b76 6 Generic BDM functions for Just4Trionic by Just4pLeisure
Just4pLeisure 1:d5452e398b76 7
Just4pLeisure 1:d5452e398b76 8 A derivative work based on:
Just4pLeisure 1:d5452e398b76 9 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 10 // CAN/BDM adapter firmware
Just4pLeisure 1:d5452e398b76 11 // (C) Janis Silins, 2010
Just4pLeisure 1:d5452e398b76 12 // $id$
Just4pLeisure 1:d5452e398b76 13 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 14
Just4pLeisure 1:d5452e398b76 15 ********************************************************************************
Just4pLeisure 1:d5452e398b76 16
Just4pLeisure 1:d5452e398b76 17 WARNING: Use at your own risk, sadly this software comes with no guarantees.
Just4pLeisure 1:d5452e398b76 18 This software is provided 'free' and in good faith, but the author does not
Just4pLeisure 1:d5452e398b76 19 accept liability for any damage arising from its use.
Just4pLeisure 1:d5452e398b76 20
Just4pLeisure 1:d5452e398b76 21 *******************************************************************************/
Just4pLeisure 1:d5452e398b76 22
Just4pLeisure 1:d5452e398b76 23 #include "bdmcpu32.h"
Just4pLeisure 1:d5452e398b76 24
Just4pLeisure 1:d5452e398b76 25 // constants
Just4pLeisure 1:d5452e398b76 26 #define MCU_SETTLE_TIME 10 ///< delay to let MCU switch modes, ms
Just4pLeisure 1:d5452e398b76 27 #define CMD_BIT_COUNT 17 ///< command size, bits
Just4pLeisure 1:d5452e398b76 28
Just4pLeisure 1:d5452e398b76 29 // BDM commands
Just4pLeisure 1:d5452e398b76 30 #define BDM_NOP 0x0000 ///< no-op
Just4pLeisure 1:d5452e398b76 31 #define BDM_GO 0x0c00 ///< resume execution
Just4pLeisure 1:d5452e398b76 32 #define BDM_WRITE 0x1800 ///< write memory
Just4pLeisure 1:d5452e398b76 33 #define BDM_READ 0x1900 ///< read memory
Just4pLeisure 1:d5452e398b76 34 #define BDM_WSREG 0x2480 ///< write system register
Just4pLeisure 1:d5452e398b76 35 #define BDM_RSREG 0x2580 ///< read system register
Just4pLeisure 1:d5452e398b76 36 #define BDM_RDREG 0x2180 ///< read A/D register
Just4pLeisure 1:d5452e398b76 37 #define BDM_WRREG 0x2080 ///< write A/D register
Just4pLeisure 1:d5452e398b76 38 #define BDM_DUMP 0x1d00 ///< dump memory
Just4pLeisure 1:d5452e398b76 39 #define BDM_FILL 0x1c00 ///< fill memory
Just4pLeisure 1:d5452e398b76 40 #define BDM_CALL 0x0800 ///< function call
Just4pLeisure 1:d5452e398b76 41 #define BDM_RST 0x0400 ///< reset
Just4pLeisure 1:d5452e398b76 42
Just4pLeisure 1:d5452e398b76 43 // system registers
Just4pLeisure 1:d5452e398b76 44 #define SREG_RPC 0x0
Just4pLeisure 1:d5452e398b76 45 #define SREG_PCC 0x1
Just4pLeisure 1:d5452e398b76 46 #define SREG_SR 0xb
Just4pLeisure 1:d5452e398b76 47 #define SREG_USP 0xc
Just4pLeisure 1:d5452e398b76 48 #define SREG_SSP 0xd
Just4pLeisure 1:d5452e398b76 49 #define SREG_SFC 0xe
Just4pLeisure 1:d5452e398b76 50 #define SREG_DFC 0xf
Just4pLeisure 1:d5452e398b76 51 #define SREG_ATEMP 0x8
Just4pLeisure 1:d5452e398b76 52 #define SREG_FAR 0x9
Just4pLeisure 1:d5452e398b76 53 #define SREG_VBR 0xa
Just4pLeisure 1:d5452e398b76 54
Just4pLeisure 1:d5452e398b76 55 // BDM responses
Just4pLeisure 1:d5452e398b76 56 #define BDM_CMDCMPLTE 0x0000ffff ///< command complete
Just4pLeisure 1:d5452e398b76 57 #define BDM_NOTREADY 0x00010000 ///< response not ready
Just4pLeisure 1:d5452e398b76 58 #define BDM_BERR 0x00010001 ///< error
Just4pLeisure 1:d5452e398b76 59 #define BDM_ILLEGAL 0x0001ffff ///< illegal command
Just4pLeisure 1:d5452e398b76 60
Just4pLeisure 1:d5452e398b76 61 // BDM data sizes
Just4pLeisure 1:d5452e398b76 62 #define BDM_BYTESIZE 0x00 ///< byte
Just4pLeisure 1:d5452e398b76 63 #define BDM_WORDSIZE 0x40 ///< word (2 bytes)
Just4pLeisure 1:d5452e398b76 64 #define BDM_LONGSIZE 0x80 ///< long word (4 bytes)
Just4pLeisure 1:d5452e398b76 65
Just4pLeisure 1:d5452e398b76 66 // static variables
Just4pLeisure 1:d5452e398b76 67 static uint32_t bdm_response; ///< result of BDM read/write operation
Just4pLeisure 1:d5452e398b76 68
Just4pLeisure 1:d5452e398b76 69 // private functions
Just4pLeisure 1:d5452e398b76 70 bool bdm_read(uint32_t* result, uint16_t cmd, const uint32_t* addr);
Just4pLeisure 1:d5452e398b76 71 //bool bdm_read_overlap(uint32_t* result, uint16_t cmd, const uint32_t* addr, uint16_t next_cmd);
Just4pLeisure 1:d5452e398b76 72 //bool bdm_read_continue(uint32_t* result, const uint32_t* addr, uint16_t next_cmd);
Just4pLeisure 1:d5452e398b76 73 bool bdm_write(const uint32_t* addr, uint16_t cmd, const uint32_t* value);
Just4pLeisure 1:d5452e398b76 74 //bool bdm_write_overlap(const uint32_t* addr, uint16_t cmd, const uint32_t* value, uint16_t next_cmd);
Just4pLeisure 1:d5452e398b76 75 void bdm_clk(uint16_t value, uint8_t num_bits);
Just4pLeisure 2:bf3a2b29259a 76 void bdm_clk_fast(uint16_t value, uint8_t num_bits);
Just4pLeisure 1:d5452e398b76 77 void bdm_clear();
Just4pLeisure 1:d5452e398b76 78
Just4pLeisure 1:d5452e398b76 79 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 80 /**
Just4pLeisure 1:d5452e398b76 81 Stops target MCU and puts into background debug mode (BDM).
Just4pLeisure 1:d5452e398b76 82
Just4pLeisure 1:d5452e398b76 83 @return status flag
Just4pLeisure 1:d5452e398b76 84 */
Just4pLeisure 1:d5452e398b76 85 uint8_t stop_chip() {
Just4pLeisure 1:d5452e398b76 86 // not connected
Just4pLeisure 1:d5452e398b76 87 if (!IS_CONNECTED) {
Just4pLeisure 1:d5452e398b76 88 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 89 }
Just4pLeisure 1:d5452e398b76 90
Just4pLeisure 1:d5452e398b76 91 // pull BKPT low to enter background mode (the pin must remain in output mode,
Just4pLeisure 1:d5452e398b76 92 // otherwise the target will pull it high and we'll lose the first DSO bit)
Just4pLeisure 1:d5452e398b76 93 PIN_BKPT.write(0);
Just4pLeisure 1:d5452e398b76 94 // set BPKT pin as output
Just4pLeisure 1:d5452e398b76 95 PIN_BKPT.output();
Just4pLeisure 1:d5452e398b76 96
Just4pLeisure 1:d5452e398b76 97 // wait for target MCU to settle
Just4pLeisure 1:d5452e398b76 98 wait_ms(MCU_SETTLE_TIME);
Just4pLeisure 1:d5452e398b76 99
Just4pLeisure 1:d5452e398b76 100 // check if succeeded
Just4pLeisure 1:d5452e398b76 101 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 102 // set BKPT back as input and fail
Just4pLeisure 1:d5452e398b76 103 PIN_BKPT.input();
Just4pLeisure 1:d5452e398b76 104 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 105 }
Just4pLeisure 1:d5452e398b76 106
Just4pLeisure 1:d5452e398b76 107 return TERM_OK;
Just4pLeisure 1:d5452e398b76 108 }
Just4pLeisure 1:d5452e398b76 109
Just4pLeisure 1:d5452e398b76 110 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 111 /**
Just4pLeisure 1:d5452e398b76 112 Forces hardware reset on target MCU and lets it run.
Just4pLeisure 1:d5452e398b76 113
Just4pLeisure 1:d5452e398b76 114 @return status flag
Just4pLeisure 1:d5452e398b76 115 */
Just4pLeisure 1:d5452e398b76 116 uint8_t reset_chip() {
Just4pLeisure 1:d5452e398b76 117 // not connected
Just4pLeisure 1:d5452e398b76 118 if (!IS_CONNECTED) {
Just4pLeisure 1:d5452e398b76 119 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 120 }
Just4pLeisure 1:d5452e398b76 121
Just4pLeisure 1:d5452e398b76 122 // BKPT pin as input
Just4pLeisure 1:d5452e398b76 123 PIN_BKPT.input();
Just4pLeisure 1:d5452e398b76 124 // push RESET low
Just4pLeisure 1:d5452e398b76 125 PIN_RESET.write(0);
Just4pLeisure 1:d5452e398b76 126 // RESET pins as output
Just4pLeisure 1:d5452e398b76 127 PIN_RESET.output();
Just4pLeisure 1:d5452e398b76 128 // wait for MCU to settle
Just4pLeisure 1:d5452e398b76 129 wait_ms(MCU_SETTLE_TIME);
Just4pLeisure 1:d5452e398b76 130 // rising edge on RESET line
Just4pLeisure 1:d5452e398b76 131 PIN_RESET.write(1);
Just4pLeisure 1:d5452e398b76 132 // wait for MCU to settle
Just4pLeisure 1:d5452e398b76 133 wait_ms(MCU_SETTLE_TIME);
Just4pLeisure 1:d5452e398b76 134
Just4pLeisure 1:d5452e398b76 135 // set RESET as an input again
Just4pLeisure 1:d5452e398b76 136 PIN_RESET.input();
Just4pLeisure 1:d5452e398b76 137
Just4pLeisure 1:d5452e398b76 138 // check if succeeded
Just4pLeisure 1:d5452e398b76 139 return IS_RUNNING ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 140 }
Just4pLeisure 1:d5452e398b76 141
Just4pLeisure 1:d5452e398b76 142 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 143 /**
Just4pLeisure 1:d5452e398b76 144 Starts target MCU from the specified address. If address is 0, execution
Just4pLeisure 1:d5452e398b76 145 begins at the current address in program counter.
Just4pLeisure 1:d5452e398b76 146
Just4pLeisure 1:d5452e398b76 147 @param addr start address
Just4pLeisure 1:d5452e398b76 148
Just4pLeisure 1:d5452e398b76 149 @return status flag
Just4pLeisure 1:d5452e398b76 150 */
Just4pLeisure 1:d5452e398b76 151 uint8_t run_chip(const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 152 // check state
Just4pLeisure 1:d5452e398b76 153 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 154 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 155 }
Just4pLeisure 1:d5452e398b76 156
Just4pLeisure 1:d5452e398b76 157 // set program counter
Just4pLeisure 1:d5452e398b76 158 if ((*addr > 0) && sysreg_write(SREG_RPC, addr) != TERM_OK) {
Just4pLeisure 1:d5452e398b76 159 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 160 }
Just4pLeisure 1:d5452e398b76 161 // resume MCU
Just4pLeisure 1:d5452e398b76 162 bdm_clk(BDM_GO, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 163
Just4pLeisure 1:d5452e398b76 164 // set BKPT back as input
Just4pLeisure 1:d5452e398b76 165 PIN_BKPT.input();
Just4pLeisure 1:d5452e398b76 166
Just4pLeisure 1:d5452e398b76 167 return TERM_OK;
Just4pLeisure 1:d5452e398b76 168 }
Just4pLeisure 1:d5452e398b76 169
Just4pLeisure 1:d5452e398b76 170 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 171 /**
Just4pLeisure 1:d5452e398b76 172 Resets target MCU and stops execution on first instruction fetch.
Just4pLeisure 1:d5452e398b76 173
Just4pLeisure 1:d5452e398b76 174 @return status flag
Just4pLeisure 1:d5452e398b76 175 */
Just4pLeisure 1:d5452e398b76 176 uint8_t restart_chip() {
Just4pLeisure 1:d5452e398b76 177 // not connected
Just4pLeisure 1:d5452e398b76 178 if (!IS_CONNECTED) {
Just4pLeisure 1:d5452e398b76 179 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 180 }
Just4pLeisure 1:d5452e398b76 181
Just4pLeisure 1:d5452e398b76 182 // pull BKPT low to enter background mode (the pin must remain an output,
Just4pLeisure 1:d5452e398b76 183 // otherwise the target will pull it high and we'll lose the first DSO bit)
Just4pLeisure 1:d5452e398b76 184 PIN_BKPT.write(0);
Just4pLeisure 1:d5452e398b76 185 // push RESET low
Just4pLeisure 1:d5452e398b76 186 PIN_RESET.write(0);
Just4pLeisure 1:d5452e398b76 187 // RESET, BKPT pins as outputs
Just4pLeisure 1:d5452e398b76 188 PIN_BKPT.output();
Just4pLeisure 1:d5452e398b76 189 PIN_RESET.output();
Just4pLeisure 1:d5452e398b76 190 // wait for target MCU to settle
Just4pLeisure 1:d5452e398b76 191 wait_ms(MCU_SETTLE_TIME);
Just4pLeisure 1:d5452e398b76 192 // rising edge on RESET line
Just4pLeisure 1:d5452e398b76 193 PIN_RESET.write(1);
Just4pLeisure 1:d5452e398b76 194 // wait for target MCU to settle
Just4pLeisure 1:d5452e398b76 195 wait_ms(MCU_SETTLE_TIME);
Just4pLeisure 1:d5452e398b76 196 // set RESET back as an input
Just4pLeisure 1:d5452e398b76 197 PIN_RESET.input();
Just4pLeisure 1:d5452e398b76 198
Just4pLeisure 1:d5452e398b76 199 // check if succeeded
Just4pLeisure 1:d5452e398b76 200 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 201 // set BKPT back as input and fail
Just4pLeisure 1:d5452e398b76 202 PIN_BKPT.input();
Just4pLeisure 1:d5452e398b76 203 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 204 }
Just4pLeisure 1:d5452e398b76 205
Just4pLeisure 1:d5452e398b76 206 return TERM_OK;
Just4pLeisure 1:d5452e398b76 207 }
Just4pLeisure 1:d5452e398b76 208
Just4pLeisure 1:d5452e398b76 209 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 210 /**
Just4pLeisure 1:d5452e398b76 211 Sends GO command word to target MCU, then triggers breakpoint on first
Just4pLeisure 1:d5452e398b76 212 instruction fetch.
Just4pLeisure 1:d5452e398b76 213
Just4pLeisure 1:d5452e398b76 214 @return status flag
Just4pLeisure 1:d5452e398b76 215 */
Just4pLeisure 1:d5452e398b76 216 uint8_t step_chip() {
Just4pLeisure 1:d5452e398b76 217 // not connected
Just4pLeisure 1:d5452e398b76 218 if (!IS_CONNECTED) {
Just4pLeisure 1:d5452e398b76 219 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 220 }
Just4pLeisure 1:d5452e398b76 221
Just4pLeisure 1:d5452e398b76 222 // resume MCU
Just4pLeisure 1:d5452e398b76 223 bdm_clk(BDM_GO, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 224
Just4pLeisure 1:d5452e398b76 225 // pull BKPT low to enter background mode (the pin must remain an output,
Just4pLeisure 1:d5452e398b76 226 // otherwise the target pulls it high and we lose the first DSO bit)
Just4pLeisure 1:d5452e398b76 227 PIN_BKPT.write(0);
Just4pLeisure 1:d5452e398b76 228 // set BPKT pin as output
Just4pLeisure 1:d5452e398b76 229 PIN_BKPT.output();
Just4pLeisure 1:d5452e398b76 230
Just4pLeisure 1:d5452e398b76 231 // wait for target MCU to settle
Just4pLeisure 1:d5452e398b76 232 // delay_ms(MCU_SETTLE_TIME);
Just4pLeisure 1:d5452e398b76 233 wait_ms(MCU_SETTLE_TIME);
Just4pLeisure 1:d5452e398b76 234
Just4pLeisure 1:d5452e398b76 235 // check if succeeded
Just4pLeisure 1:d5452e398b76 236 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 237 // set BKPT back as input and fail
Just4pLeisure 1:d5452e398b76 238 PIN_BKPT.input();
Just4pLeisure 1:d5452e398b76 239 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 240 }
Just4pLeisure 1:d5452e398b76 241
Just4pLeisure 1:d5452e398b76 242 return TERM_OK;
Just4pLeisure 1:d5452e398b76 243 }
Just4pLeisure 1:d5452e398b76 244
Just4pLeisure 1:d5452e398b76 245 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 246 /**
Just4pLeisure 1:d5452e398b76 247 Pulls BKPT pin low.
Just4pLeisure 1:d5452e398b76 248 */
Just4pLeisure 1:d5452e398b76 249 uint8_t bkpt_low() {
Just4pLeisure 1:d5452e398b76 250 PIN_BKPT.write(0);
Just4pLeisure 1:d5452e398b76 251 PIN_BKPT.output();
Just4pLeisure 1:d5452e398b76 252
Just4pLeisure 1:d5452e398b76 253 return TERM_OK;
Just4pLeisure 1:d5452e398b76 254 }
Just4pLeisure 1:d5452e398b76 255
Just4pLeisure 1:d5452e398b76 256 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 257 /**
Just4pLeisure 1:d5452e398b76 258 Pulls BKPT pin high.
Just4pLeisure 1:d5452e398b76 259 */
Just4pLeisure 1:d5452e398b76 260 uint8_t bkpt_high() {
Just4pLeisure 1:d5452e398b76 261 PIN_BKPT.write(1);
Just4pLeisure 1:d5452e398b76 262 PIN_BKPT.output();
Just4pLeisure 1:d5452e398b76 263
Just4pLeisure 1:d5452e398b76 264 return TERM_OK;
Just4pLeisure 1:d5452e398b76 265 }
Just4pLeisure 1:d5452e398b76 266
Just4pLeisure 1:d5452e398b76 267 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 268 /**
Just4pLeisure 1:d5452e398b76 269 Pulls RESET pin low.
Just4pLeisure 1:d5452e398b76 270 */
Just4pLeisure 1:d5452e398b76 271 uint8_t reset_low() {
Just4pLeisure 1:d5452e398b76 272 PIN_RESET.write(0);
Just4pLeisure 1:d5452e398b76 273 PIN_RESET.output();
Just4pLeisure 1:d5452e398b76 274
Just4pLeisure 1:d5452e398b76 275 return TERM_OK;
Just4pLeisure 1:d5452e398b76 276 }
Just4pLeisure 1:d5452e398b76 277
Just4pLeisure 1:d5452e398b76 278 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 279 /**
Just4pLeisure 1:d5452e398b76 280 Pulls RESET pin high.
Just4pLeisure 1:d5452e398b76 281 */
Just4pLeisure 1:d5452e398b76 282 uint8_t reset_high() {
Just4pLeisure 1:d5452e398b76 283 PIN_RESET.write(1);
Just4pLeisure 1:d5452e398b76 284 PIN_RESET.output();
Just4pLeisure 1:d5452e398b76 285
Just4pLeisure 1:d5452e398b76 286 return TERM_OK;
Just4pLeisure 1:d5452e398b76 287 }
Just4pLeisure 1:d5452e398b76 288
Just4pLeisure 1:d5452e398b76 289 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 290 /**
Just4pLeisure 1:d5452e398b76 291 Returns byte from the specified memory location; MCU must be in
Just4pLeisure 1:d5452e398b76 292 background mode.
Just4pLeisure 1:d5452e398b76 293
Just4pLeisure 1:d5452e398b76 294 @param result value (out)
Just4pLeisure 1:d5452e398b76 295 @param addr source address
Just4pLeisure 1:d5452e398b76 296
Just4pLeisure 1:d5452e398b76 297 @return status flag
Just4pLeisure 1:d5452e398b76 298 */
Just4pLeisure 1:d5452e398b76 299 uint8_t memread_byte(uint8_t* result, const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 300 // check state
Just4pLeisure 1:d5452e398b76 301 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 302 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 303 }
Just4pLeisure 1:d5452e398b76 304
Just4pLeisure 1:d5452e398b76 305 // read byte
Just4pLeisure 1:d5452e398b76 306 if (!bdm_read((uint32_t*)result, BDM_READ, addr)) {
Just4pLeisure 1:d5452e398b76 307 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 308 bdm_clear();
Just4pLeisure 1:d5452e398b76 309 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 310 }
Just4pLeisure 1:d5452e398b76 311
Just4pLeisure 1:d5452e398b76 312 return TERM_OK;
Just4pLeisure 1:d5452e398b76 313 }
Just4pLeisure 1:d5452e398b76 314
Just4pLeisure 1:d5452e398b76 315 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 316 /**
Just4pLeisure 1:d5452e398b76 317 Returns word (2 bytes) from the specified memory location. Address must be
Just4pLeisure 1:d5452e398b76 318 word-aligned and MCU must be in background mode.
Just4pLeisure 1:d5452e398b76 319
Just4pLeisure 1:d5452e398b76 320 @param result value (out)
Just4pLeisure 1:d5452e398b76 321 @param addr source address
Just4pLeisure 1:d5452e398b76 322
Just4pLeisure 1:d5452e398b76 323 @return status flag
Just4pLeisure 1:d5452e398b76 324 */
Just4pLeisure 1:d5452e398b76 325 uint8_t memread_word(uint16_t* result, const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 326 // check state
Just4pLeisure 1:d5452e398b76 327 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 328 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 329 }
Just4pLeisure 1:d5452e398b76 330
Just4pLeisure 1:d5452e398b76 331 // read word
Just4pLeisure 1:d5452e398b76 332 if (!bdm_read((uint32_t*)result, BDM_READ + BDM_WORDSIZE, addr)) {
Just4pLeisure 1:d5452e398b76 333 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 334 bdm_clear();
Just4pLeisure 1:d5452e398b76 335 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 336 }
Just4pLeisure 1:d5452e398b76 337
Just4pLeisure 1:d5452e398b76 338 return TERM_OK;
Just4pLeisure 1:d5452e398b76 339 }
Just4pLeisure 1:d5452e398b76 340
Just4pLeisure 1:d5452e398b76 341 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 342 /**
Just4pLeisure 1:d5452e398b76 343 Returns long word (4 bytes) from the specified memory location. Address
Just4pLeisure 1:d5452e398b76 344 must be word-aligned and target MCU must be in background mode.
Just4pLeisure 1:d5452e398b76 345
Just4pLeisure 1:d5452e398b76 346 @param result value
Just4pLeisure 1:d5452e398b76 347 @param addr source address
Just4pLeisure 1:d5452e398b76 348
Just4pLeisure 1:d5452e398b76 349 @return status flag
Just4pLeisure 1:d5452e398b76 350 */
Just4pLeisure 1:d5452e398b76 351 uint8_t memread_long(uint32_t* result, const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 352 // check state
Just4pLeisure 1:d5452e398b76 353 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 354 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 355 }
Just4pLeisure 1:d5452e398b76 356
Just4pLeisure 1:d5452e398b76 357 // read long word
Just4pLeisure 1:d5452e398b76 358 if (!bdm_read(result, BDM_READ + BDM_LONGSIZE, addr)) {
Just4pLeisure 1:d5452e398b76 359 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 360 bdm_clear();
Just4pLeisure 1:d5452e398b76 361 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 362 }
Just4pLeisure 1:d5452e398b76 363
Just4pLeisure 1:d5452e398b76 364 return TERM_OK;
Just4pLeisure 1:d5452e398b76 365 }
Just4pLeisure 1:d5452e398b76 366
Just4pLeisure 1:d5452e398b76 367 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 368 /**
Just4pLeisure 1:d5452e398b76 369 Dumps byte from the specified memory location; MCU must be in background
Just4pLeisure 1:d5452e398b76 370 mode. Any memread_*() function must be called beforehand to set the
Just4pLeisure 1:d5452e398b76 371 initial address.
Just4pLeisure 1:d5452e398b76 372
Just4pLeisure 1:d5452e398b76 373 @param value result (out)
Just4pLeisure 1:d5452e398b76 374
Just4pLeisure 1:d5452e398b76 375 @return status flag
Just4pLeisure 1:d5452e398b76 376 */
Just4pLeisure 1:d5452e398b76 377 uint8_t memdump_byte(uint8_t* result) {
Just4pLeisure 1:d5452e398b76 378 // check state
Just4pLeisure 1:d5452e398b76 379 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 380 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 381 }
Just4pLeisure 1:d5452e398b76 382
Just4pLeisure 1:d5452e398b76 383 // dump byte
Just4pLeisure 1:d5452e398b76 384 if (!bdm_read((uint32_t*)result, BDM_DUMP, NULL)) {
Just4pLeisure 1:d5452e398b76 385 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 386 bdm_clear();
Just4pLeisure 1:d5452e398b76 387 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 388 }
Just4pLeisure 1:d5452e398b76 389
Just4pLeisure 1:d5452e398b76 390 return TERM_OK;
Just4pLeisure 1:d5452e398b76 391 }
Just4pLeisure 1:d5452e398b76 392
Just4pLeisure 1:d5452e398b76 393 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 394 /**
Just4pLeisure 1:d5452e398b76 395 dumps word from the specified memory location; MCU must be in background
Just4pLeisure 1:d5452e398b76 396 mode. Any memread_*() function must be called beforehand to set the
Just4pLeisure 1:d5452e398b76 397 initial address.
Just4pLeisure 1:d5452e398b76 398
Just4pLeisure 1:d5452e398b76 399 @param value result (out)
Just4pLeisure 1:d5452e398b76 400
Just4pLeisure 1:d5452e398b76 401 @return status flag
Just4pLeisure 1:d5452e398b76 402 */
Just4pLeisure 1:d5452e398b76 403 uint8_t memdump_word(uint16_t* result) {
Just4pLeisure 1:d5452e398b76 404 // check state
Just4pLeisure 1:d5452e398b76 405 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 406 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 407 }
Just4pLeisure 1:d5452e398b76 408
Just4pLeisure 1:d5452e398b76 409 // dump word
Just4pLeisure 1:d5452e398b76 410 if (!bdm_read((uint32_t*)result, BDM_DUMP + BDM_WORDSIZE, NULL)) {
Just4pLeisure 1:d5452e398b76 411 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 412 bdm_clear();
Just4pLeisure 1:d5452e398b76 413 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 414 }
Just4pLeisure 1:d5452e398b76 415
Just4pLeisure 1:d5452e398b76 416 return TERM_OK;
Just4pLeisure 1:d5452e398b76 417 }
Just4pLeisure 1:d5452e398b76 418
Just4pLeisure 1:d5452e398b76 419 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 420 /**
Just4pLeisure 1:d5452e398b76 421 Dumps long word from the specified memory location; MCU must be in
Just4pLeisure 1:d5452e398b76 422 background mode. Any memread_*() function must be called beforehand to set
Just4pLeisure 1:d5452e398b76 423 the initial address.
Just4pLeisure 1:d5452e398b76 424
Just4pLeisure 1:d5452e398b76 425 @param value result (out)
Just4pLeisure 1:d5452e398b76 426
Just4pLeisure 1:d5452e398b76 427 @return status flag
Just4pLeisure 1:d5452e398b76 428 */
Just4pLeisure 1:d5452e398b76 429 uint8_t memdump_long(uint32_t* result) {
Just4pLeisure 1:d5452e398b76 430 // check state
Just4pLeisure 1:d5452e398b76 431 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 432 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 433 }
Just4pLeisure 1:d5452e398b76 434
Just4pLeisure 1:d5452e398b76 435 // dump long word
Just4pLeisure 1:d5452e398b76 436 if (!bdm_read(result, BDM_DUMP + BDM_LONGSIZE, NULL)) {
Just4pLeisure 1:d5452e398b76 437 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 438 bdm_clear();
Just4pLeisure 1:d5452e398b76 439 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 440 }
Just4pLeisure 1:d5452e398b76 441
Just4pLeisure 1:d5452e398b76 442 return TERM_OK;
Just4pLeisure 1:d5452e398b76 443 }
Just4pLeisure 1:d5452e398b76 444
Just4pLeisure 1:d5452e398b76 445 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 446 /**
Just4pLeisure 1:d5452e398b76 447 Writes byte to the specified memory location; MCU must be in background
Just4pLeisure 1:d5452e398b76 448 mode.
Just4pLeisure 1:d5452e398b76 449
Just4pLeisure 1:d5452e398b76 450 @param addr destination address
Just4pLeisure 1:d5452e398b76 451 @param value value
Just4pLeisure 1:d5452e398b76 452
Just4pLeisure 1:d5452e398b76 453 @return status flag
Just4pLeisure 1:d5452e398b76 454 */
Just4pLeisure 1:d5452e398b76 455 uint8_t memwrite_byte(const uint32_t* addr, uint8_t value) {
Just4pLeisure 1:d5452e398b76 456 // check state
Just4pLeisure 1:d5452e398b76 457 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 458 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 459 }
Just4pLeisure 1:d5452e398b76 460
Just4pLeisure 1:d5452e398b76 461 // write byte
Just4pLeisure 1:d5452e398b76 462 if (!bdm_write(addr, BDM_WRITE, (uint32_t*)&value)) {
Just4pLeisure 1:d5452e398b76 463 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 464 bdm_clear();
Just4pLeisure 1:d5452e398b76 465 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 466 }
Just4pLeisure 1:d5452e398b76 467
Just4pLeisure 1:d5452e398b76 468 return TERM_OK;
Just4pLeisure 1:d5452e398b76 469 }
Just4pLeisure 1:d5452e398b76 470
Just4pLeisure 1:d5452e398b76 471 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 472 /**
Just4pLeisure 1:d5452e398b76 473 Writes word to the specified memory location. Address must be word-aligned
Just4pLeisure 1:d5452e398b76 474 and MCU must be in background mode.
Just4pLeisure 1:d5452e398b76 475
Just4pLeisure 1:d5452e398b76 476 @param addr memory address
Just4pLeisure 1:d5452e398b76 477 @param value value
Just4pLeisure 1:d5452e398b76 478
Just4pLeisure 1:d5452e398b76 479 @return status flag
Just4pLeisure 1:d5452e398b76 480 */
Just4pLeisure 1:d5452e398b76 481 uint8_t memwrite_word(const uint32_t* addr, uint16_t value) {
Just4pLeisure 1:d5452e398b76 482 // check state
Just4pLeisure 1:d5452e398b76 483 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 484 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 485 }
Just4pLeisure 1:d5452e398b76 486
Just4pLeisure 1:d5452e398b76 487 // write word
Just4pLeisure 1:d5452e398b76 488 if (!bdm_write(addr, BDM_WRITE + BDM_WORDSIZE, (uint32_t*)&value)) {
Just4pLeisure 1:d5452e398b76 489 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 490 bdm_clear();
Just4pLeisure 1:d5452e398b76 491 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 492 }
Just4pLeisure 1:d5452e398b76 493
Just4pLeisure 1:d5452e398b76 494 return TERM_OK;
Just4pLeisure 1:d5452e398b76 495 }
Just4pLeisure 1:d5452e398b76 496
Just4pLeisure 1:d5452e398b76 497 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 498 /**
Just4pLeisure 1:d5452e398b76 499 Writes long word to the specified memory location. Address must be
Just4pLeisure 1:d5452e398b76 500 word-aligned and target MCU must be in background mode.
Just4pLeisure 1:d5452e398b76 501
Just4pLeisure 1:d5452e398b76 502 @param addr memory address
Just4pLeisure 1:d5452e398b76 503 @param value value
Just4pLeisure 1:d5452e398b76 504
Just4pLeisure 1:d5452e398b76 505 @return status flag
Just4pLeisure 1:d5452e398b76 506 */
Just4pLeisure 1:d5452e398b76 507 uint8_t memwrite_long(const uint32_t* addr, const uint32_t* value) {
Just4pLeisure 1:d5452e398b76 508 // check state
Just4pLeisure 1:d5452e398b76 509 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 510 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 511 }
Just4pLeisure 1:d5452e398b76 512
Just4pLeisure 1:d5452e398b76 513 // write long word
Just4pLeisure 1:d5452e398b76 514 if (!bdm_write(addr, BDM_WRITE + BDM_LONGSIZE, value)) {
Just4pLeisure 1:d5452e398b76 515 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 516 bdm_clear();
Just4pLeisure 1:d5452e398b76 517 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 518 }
Just4pLeisure 1:d5452e398b76 519
Just4pLeisure 1:d5452e398b76 520 return TERM_OK;
Just4pLeisure 1:d5452e398b76 521 }
Just4pLeisure 1:d5452e398b76 522
Just4pLeisure 1:d5452e398b76 523 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 524 /**
Just4pLeisure 1:d5452e398b76 525 Writes byte to the current memory location; MCU must be in background
Just4pLeisure 1:d5452e398b76 526 mode. Any memwrite_*() function must be called beforehand to set the
Just4pLeisure 1:d5452e398b76 527 current address.
Just4pLeisure 1:d5452e398b76 528
Just4pLeisure 1:d5452e398b76 529 @param value value
Just4pLeisure 1:d5452e398b76 530
Just4pLeisure 1:d5452e398b76 531 @return status flag
Just4pLeisure 1:d5452e398b76 532 */
Just4pLeisure 1:d5452e398b76 533 uint8_t memfill_byte(uint8_t value) {
Just4pLeisure 1:d5452e398b76 534 // check state
Just4pLeisure 1:d5452e398b76 535 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 536 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 537 }
Just4pLeisure 1:d5452e398b76 538
Just4pLeisure 1:d5452e398b76 539 // fill byte
Just4pLeisure 1:d5452e398b76 540 if (!bdm_write(NULL, BDM_FILL, (uint32_t*)&value)) {
Just4pLeisure 1:d5452e398b76 541 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 542 bdm_clear();
Just4pLeisure 1:d5452e398b76 543 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 544 }
Just4pLeisure 1:d5452e398b76 545
Just4pLeisure 1:d5452e398b76 546 return TERM_OK;
Just4pLeisure 1:d5452e398b76 547 }
Just4pLeisure 1:d5452e398b76 548
Just4pLeisure 1:d5452e398b76 549 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 550 /**
Just4pLeisure 1:d5452e398b76 551 Writes word to the specified memory location; MCU must be in background
Just4pLeisure 1:d5452e398b76 552 mode. Any memwrite_*() function must be called beforehand to set the
Just4pLeisure 1:d5452e398b76 553 initial address.
Just4pLeisure 1:d5452e398b76 554
Just4pLeisure 1:d5452e398b76 555 @param value value
Just4pLeisure 1:d5452e398b76 556
Just4pLeisure 1:d5452e398b76 557 @return status flag
Just4pLeisure 1:d5452e398b76 558 */
Just4pLeisure 1:d5452e398b76 559 uint8_t memfill_word(uint16_t value) {
Just4pLeisure 1:d5452e398b76 560 // check state
Just4pLeisure 1:d5452e398b76 561 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 562 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 563 }
Just4pLeisure 1:d5452e398b76 564
Just4pLeisure 1:d5452e398b76 565 // fill word
Just4pLeisure 1:d5452e398b76 566 if (!IN_BDM || !bdm_write(NULL, BDM_FILL + BDM_WORDSIZE, (uint32_t*)&value)) {
Just4pLeisure 1:d5452e398b76 567 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 568 bdm_clear();
Just4pLeisure 1:d5452e398b76 569 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 570 }
Just4pLeisure 1:d5452e398b76 571
Just4pLeisure 1:d5452e398b76 572 return TERM_OK;
Just4pLeisure 1:d5452e398b76 573 }
Just4pLeisure 1:d5452e398b76 574
Just4pLeisure 1:d5452e398b76 575 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 576 /**
Just4pLeisure 1:d5452e398b76 577 Writes long word to the specified memory location; MCU must be in background
Just4pLeisure 1:d5452e398b76 578 mode. Any memwrite_*() function must be called beforehand to set the
Just4pLeisure 1:d5452e398b76 579 initial address.
Just4pLeisure 1:d5452e398b76 580
Just4pLeisure 1:d5452e398b76 581 @param value value
Just4pLeisure 1:d5452e398b76 582
Just4pLeisure 1:d5452e398b76 583 @return status flag
Just4pLeisure 1:d5452e398b76 584 */
Just4pLeisure 1:d5452e398b76 585 uint8_t memfill_long(const uint32_t* value) {
Just4pLeisure 1:d5452e398b76 586 // check state
Just4pLeisure 1:d5452e398b76 587 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 588 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 589 }
Just4pLeisure 1:d5452e398b76 590
Just4pLeisure 1:d5452e398b76 591 // fill long word
Just4pLeisure 1:d5452e398b76 592 if (!bdm_write(NULL, BDM_FILL + BDM_LONGSIZE, value)) {
Just4pLeisure 1:d5452e398b76 593 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 594 bdm_clear();
Just4pLeisure 1:d5452e398b76 595 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 596 }
Just4pLeisure 1:d5452e398b76 597
Just4pLeisure 1:d5452e398b76 598 return TERM_OK;
Just4pLeisure 1:d5452e398b76 599 }
Just4pLeisure 1:d5452e398b76 600
Just4pLeisure 1:d5452e398b76 601 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 602 /**
Just4pLeisure 1:d5452e398b76 603 Issues a read byte command to MCU.
Just4pLeisure 1:d5452e398b76 604
Just4pLeisure 1:d5452e398b76 605 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 606
Just4pLeisure 1:d5452e398b76 607 @return status flag
Just4pLeisure 1:d5452e398b76 608 */
Just4pLeisure 1:d5452e398b76 609 uint8_t memread_byte_cmd(const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 610
Just4pLeisure 1:d5452e398b76 611 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 612
Just4pLeisure 1:d5452e398b76 613 // write command code
Just4pLeisure 1:d5452e398b76 614 if (!bdm_command(BDM_READ + BDM_BYTESIZE)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 615 // write the optional address
Just4pLeisure 1:d5452e398b76 616 if (addr) {
Just4pLeisure 2:bf3a2b29259a 617 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 618 }
Just4pLeisure 1:d5452e398b76 619
Just4pLeisure 1:d5452e398b76 620 return TERM_OK;
Just4pLeisure 1:d5452e398b76 621 }
Just4pLeisure 1:d5452e398b76 622
Just4pLeisure 1:d5452e398b76 623 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 624 /**
Just4pLeisure 1:d5452e398b76 625 Issues a read word command to MCU.
Just4pLeisure 1:d5452e398b76 626
Just4pLeisure 1:d5452e398b76 627 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 628
Just4pLeisure 1:d5452e398b76 629 @return status flag
Just4pLeisure 1:d5452e398b76 630 */
Just4pLeisure 1:d5452e398b76 631 uint8_t memread_word_cmd(const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 632
Just4pLeisure 1:d5452e398b76 633 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 634
Just4pLeisure 1:d5452e398b76 635 // write command code
Just4pLeisure 1:d5452e398b76 636 bdm_clk(BDM_READ + BDM_WORDSIZE, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 637 if (bdm_response > BDM_CMDCMPLTE) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 638 // write the optional address
Just4pLeisure 1:d5452e398b76 639 if (addr) {
Just4pLeisure 2:bf3a2b29259a 640 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 641 }
Just4pLeisure 1:d5452e398b76 642
Just4pLeisure 1:d5452e398b76 643 return TERM_OK;
Just4pLeisure 1:d5452e398b76 644 }
Just4pLeisure 1:d5452e398b76 645
Just4pLeisure 1:d5452e398b76 646 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 647 /**
Just4pLeisure 1:d5452e398b76 648 Issues a read long command to MCU.
Just4pLeisure 1:d5452e398b76 649
Just4pLeisure 1:d5452e398b76 650 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 651
Just4pLeisure 1:d5452e398b76 652 @return status flag
Just4pLeisure 1:d5452e398b76 653 */
Just4pLeisure 1:d5452e398b76 654 uint8_t memread_long_cmd(const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 655
Just4pLeisure 1:d5452e398b76 656 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 657
Just4pLeisure 1:d5452e398b76 658 // write command code
Just4pLeisure 1:d5452e398b76 659 bdm_clk(BDM_READ + BDM_LONGSIZE, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 660 if (bdm_response > BDM_CMDCMPLTE) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 661 // write the optional address
Just4pLeisure 1:d5452e398b76 662 if (addr) {
Just4pLeisure 2:bf3a2b29259a 663 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 664 }
Just4pLeisure 1:d5452e398b76 665
Just4pLeisure 1:d5452e398b76 666 return TERM_OK;
Just4pLeisure 1:d5452e398b76 667 }
Just4pLeisure 1:d5452e398b76 668 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 669 /**
Just4pLeisure 1:d5452e398b76 670 Issues a write byte command to MCU.
Just4pLeisure 1:d5452e398b76 671
Just4pLeisure 1:d5452e398b76 672 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 673
Just4pLeisure 1:d5452e398b76 674 @return status flag
Just4pLeisure 1:d5452e398b76 675 */
Just4pLeisure 1:d5452e398b76 676 uint8_t memwrite_byte_cmd(const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 677
Just4pLeisure 1:d5452e398b76 678 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 2:bf3a2b29259a 679
Just4pLeisure 1:d5452e398b76 680 // write command code
Just4pLeisure 1:d5452e398b76 681 if (!bdm_command(BDM_WRITE + BDM_BYTESIZE)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 682 // write the optional address
Just4pLeisure 1:d5452e398b76 683 if (addr) {
Just4pLeisure 2:bf3a2b29259a 684 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 685 }
Just4pLeisure 1:d5452e398b76 686
Just4pLeisure 1:d5452e398b76 687 return TERM_OK;
Just4pLeisure 1:d5452e398b76 688 }
Just4pLeisure 1:d5452e398b76 689
Just4pLeisure 1:d5452e398b76 690 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 691 /**
Just4pLeisure 1:d5452e398b76 692 Issues a write word command to MCU.
Just4pLeisure 1:d5452e398b76 693
Just4pLeisure 1:d5452e398b76 694 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 695
Just4pLeisure 1:d5452e398b76 696 @return status flag
Just4pLeisure 1:d5452e398b76 697 */
Just4pLeisure 1:d5452e398b76 698 uint8_t memwrite_word_cmd(const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 699
Just4pLeisure 1:d5452e398b76 700 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 701
Just4pLeisure 1:d5452e398b76 702 // write command code
Just4pLeisure 1:d5452e398b76 703 bdm_clk(BDM_WRITE + BDM_WORDSIZE, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 704 if (bdm_response > BDM_CMDCMPLTE) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 705 // write the optional address
Just4pLeisure 1:d5452e398b76 706 if (addr) {
Just4pLeisure 2:bf3a2b29259a 707 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 708 }
Just4pLeisure 1:d5452e398b76 709
Just4pLeisure 1:d5452e398b76 710 return TERM_OK;
Just4pLeisure 1:d5452e398b76 711 }
Just4pLeisure 1:d5452e398b76 712
Just4pLeisure 1:d5452e398b76 713 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 714 /**
Just4pLeisure 1:d5452e398b76 715 Issues a write long command to MCU.
Just4pLeisure 1:d5452e398b76 716
Just4pLeisure 1:d5452e398b76 717 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 718
Just4pLeisure 1:d5452e398b76 719 @return status flag
Just4pLeisure 1:d5452e398b76 720 */
Just4pLeisure 1:d5452e398b76 721 uint8_t memwrite_long_cmd(const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 722
Just4pLeisure 1:d5452e398b76 723 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 724
Just4pLeisure 1:d5452e398b76 725 // write command code
Just4pLeisure 1:d5452e398b76 726 bdm_clk(BDM_WRITE + BDM_LONGSIZE, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 727 if (bdm_response > BDM_CMDCMPLTE) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 728 // write the optional address
Just4pLeisure 1:d5452e398b76 729 if (addr) {
Just4pLeisure 2:bf3a2b29259a 730 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 731 }
Just4pLeisure 1:d5452e398b76 732
Just4pLeisure 1:d5452e398b76 733 return TERM_OK;
Just4pLeisure 1:d5452e398b76 734 }
Just4pLeisure 1:d5452e398b76 735
Just4pLeisure 1:d5452e398b76 736 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 737 /**
Just4pLeisure 1:d5452e398b76 738 Gets a byte from the MCU (follows a previously sent read or dump word cmd)
Just4pLeisure 1:d5452e398b76 739 Sends a READ_BYTE command so that commands overlap
Just4pLeisure 1:d5452e398b76 740
Just4pLeisure 1:d5452e398b76 741 @param result read result (out)
Just4pLeisure 1:d5452e398b76 742 addr address (optional)
Just4pLeisure 1:d5452e398b76 743
Just4pLeisure 1:d5452e398b76 744 @return status flag
Just4pLeisure 1:d5452e398b76 745 */
Just4pLeisure 1:d5452e398b76 746 uint8_t memread_read_byte(uint8_t* result, const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 747
Just4pLeisure 1:d5452e398b76 748 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 749 // write the optional address
Just4pLeisure 1:d5452e398b76 750 if (addr) {
Just4pLeisure 2:bf3a2b29259a 751 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 752 }
Just4pLeisure 1:d5452e398b76 753 // receive the response byte
Just4pLeisure 1:d5452e398b76 754 return (bdm_get ((uint32_t*)result, BDM_BYTESIZE, BDM_READ + BDM_BYTESIZE)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 755 }
Just4pLeisure 1:d5452e398b76 756
Just4pLeisure 1:d5452e398b76 757 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 758 /**
Just4pLeisure 1:d5452e398b76 759 Gets a byte from the MCU (follows a previously sent read or dump word cmd)
Just4pLeisure 1:d5452e398b76 760 Sends a WRITE_BYTE command so that commands overlap
Just4pLeisure 1:d5452e398b76 761
Just4pLeisure 1:d5452e398b76 762 @param result read result (out)
Just4pLeisure 1:d5452e398b76 763 addr address (optional)
Just4pLeisure 1:d5452e398b76 764
Just4pLeisure 1:d5452e398b76 765 @return status flag
Just4pLeisure 1:d5452e398b76 766 */
Just4pLeisure 1:d5452e398b76 767 uint8_t memread_write_byte(uint8_t* result, const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 768
Just4pLeisure 1:d5452e398b76 769 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 770 // write the optional address
Just4pLeisure 1:d5452e398b76 771 if (addr) {
Just4pLeisure 2:bf3a2b29259a 772 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 773 }
Just4pLeisure 1:d5452e398b76 774 // receive the response byte
Just4pLeisure 1:d5452e398b76 775 return (bdm_get((uint32_t*)result, BDM_BYTESIZE, BDM_WRITE + BDM_BYTESIZE)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 776 }
Just4pLeisure 1:d5452e398b76 777
Just4pLeisure 1:d5452e398b76 778 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 779 /**
Just4pLeisure 1:d5452e398b76 780 Gets a byte from the MCU (follows a previously sent read or dump word cmd)
Just4pLeisure 1:d5452e398b76 781 Sends a BDM_NOP command to end a sequence of overlapping commands
Just4pLeisure 1:d5452e398b76 782
Just4pLeisure 1:d5452e398b76 783 @param result read result (out)
Just4pLeisure 1:d5452e398b76 784 addr address (optional)
Just4pLeisure 1:d5452e398b76 785
Just4pLeisure 1:d5452e398b76 786 @return status flag
Just4pLeisure 1:d5452e398b76 787 */
Just4pLeisure 1:d5452e398b76 788 uint8_t memread_nop_byte(uint8_t* result, const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 789
Just4pLeisure 1:d5452e398b76 790 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 791 // write the optional address
Just4pLeisure 1:d5452e398b76 792 if (addr) {
Just4pLeisure 2:bf3a2b29259a 793 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 794 }
Just4pLeisure 1:d5452e398b76 795 // receive the response byte
Just4pLeisure 1:d5452e398b76 796 return (bdm_get((uint32_t*)result, BDM_BYTESIZE, BDM_NOP)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 797 }
Just4pLeisure 1:d5452e398b76 798
Just4pLeisure 1:d5452e398b76 799 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 800 /**
Just4pLeisure 1:d5452e398b76 801 Writes a byte to the MCU (follows a previously sent write or fill word cmd)
Just4pLeisure 1:d5452e398b76 802 Sends a WRITE_BYTE command so that commands overlap
Just4pLeisure 1:d5452e398b76 803
Just4pLeisure 1:d5452e398b76 804 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 805 value value to write
Just4pLeisure 1:d5452e398b76 806
Just4pLeisure 1:d5452e398b76 807 @return status flag
Just4pLeisure 1:d5452e398b76 808 */
Just4pLeisure 1:d5452e398b76 809 uint8_t memwrite_write_byte(const uint32_t* addr, uint8_t value) {
Just4pLeisure 1:d5452e398b76 810
Just4pLeisure 1:d5452e398b76 811 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 812 // write the optional address
Just4pLeisure 1:d5452e398b76 813 if (addr) {
Just4pLeisure 2:bf3a2b29259a 814 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 815 }
Just4pLeisure 1:d5452e398b76 816 // write the value
Just4pLeisure 1:d5452e398b76 817 if (!bdm_put((uint32_t*)&value, BDM_BYTESIZE)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 818 // wait until MCU responds
Just4pLeisure 1:d5452e398b76 819 return (bdm_ready(BDM_WRITE + BDM_BYTESIZE)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 820 }
Just4pLeisure 1:d5452e398b76 821
Just4pLeisure 1:d5452e398b76 822 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 823 /**
Just4pLeisure 1:d5452e398b76 824 Writes a byte to the MCU (follows a previously sent write or fill word cmd)
Just4pLeisure 1:d5452e398b76 825 Sends a READ_BYTE command so that commands overlap
Just4pLeisure 1:d5452e398b76 826
Just4pLeisure 1:d5452e398b76 827 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 828 value value to write
Just4pLeisure 1:d5452e398b76 829
Just4pLeisure 1:d5452e398b76 830 @return status flag
Just4pLeisure 1:d5452e398b76 831 */
Just4pLeisure 1:d5452e398b76 832 uint8_t memwrite_read_byte(const uint32_t* addr, uint8_t value) {
Just4pLeisure 1:d5452e398b76 833
Just4pLeisure 1:d5452e398b76 834 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 835 // write the optional address
Just4pLeisure 1:d5452e398b76 836 if (addr) {
Just4pLeisure 2:bf3a2b29259a 837 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 838 }
Just4pLeisure 1:d5452e398b76 839 // write the value
Just4pLeisure 1:d5452e398b76 840 if (!bdm_put((uint32_t*)&value, BDM_BYTESIZE)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 841 // wait until MCU responds
Just4pLeisure 1:d5452e398b76 842 return (bdm_ready(BDM_READ + BDM_BYTESIZE)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 843 }
Just4pLeisure 1:d5452e398b76 844
Just4pLeisure 1:d5452e398b76 845 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 846 /**
Just4pLeisure 1:d5452e398b76 847 Writes a byte to the MCU (follows a previously sent write or fill word cmd)
Just4pLeisure 1:d5452e398b76 848 Sends a BDM_NOP command to end a sequence of overlapping commands
Just4pLeisure 1:d5452e398b76 849
Just4pLeisure 1:d5452e398b76 850 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 851 value value to write
Just4pLeisure 1:d5452e398b76 852
Just4pLeisure 1:d5452e398b76 853 @return status flag
Just4pLeisure 1:d5452e398b76 854 */
Just4pLeisure 1:d5452e398b76 855 uint8_t memwrite_nop_byte(const uint32_t* addr, uint8_t value) {
Just4pLeisure 1:d5452e398b76 856
Just4pLeisure 1:d5452e398b76 857 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 858 // write the optional address
Just4pLeisure 1:d5452e398b76 859 if (addr) {
Just4pLeisure 2:bf3a2b29259a 860 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 861 }
Just4pLeisure 1:d5452e398b76 862 // write the value
Just4pLeisure 1:d5452e398b76 863 if (!bdm_put((uint32_t*)&value, BDM_BYTESIZE)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 864 // wait until MCU responds
Just4pLeisure 1:d5452e398b76 865 return (bdm_ready(BDM_NOP)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 866 }
Just4pLeisure 1:d5452e398b76 867
Just4pLeisure 1:d5452e398b76 868
Just4pLeisure 1:d5452e398b76 869 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 870 /**
Just4pLeisure 1:d5452e398b76 871 Writes 2 words to the same address
Just4pLeisure 1:d5452e398b76 872 The BDM commands are overlapped to make things a bit faster
Just4pLeisure 1:d5452e398b76 873 A BDM_NOP command is then sent to end the sequence of overlapping commands
Just4pLeisure 2:bf3a2b29259a 874
Just4pLeisure 1:d5452e398b76 875 @param addr address
Just4pLeisure 1:d5452e398b76 876 value1, 2 values to write
Just4pLeisure 1:d5452e398b76 877
Just4pLeisure 1:d5452e398b76 878 @return status flag
Just4pLeisure 1:d5452e398b76 879 */
Just4pLeisure 1:d5452e398b76 880 uint8_t memwrite_word_write_word(const uint32_t* addr, const uint16_t value1, const uint16_t value2) {
Just4pLeisure 2:bf3a2b29259a 881 return (IN_BDM &&
Just4pLeisure 2:bf3a2b29259a 882 bdm_command(BDM_WRITE + BDM_WORDSIZE) && // write command code
Just4pLeisure 2:bf3a2b29259a 883 bdm_address(addr) && // write the address
Just4pLeisure 2:bf3a2b29259a 884 bdm_put((uint32_t*)&value1, BDM_WORDSIZE) && // write the first value
Just4pLeisure 2:bf3a2b29259a 885 bdm_ready(BDM_WRITE + BDM_WORDSIZE) && // wait until MCU responds and overlap the next write command
Just4pLeisure 2:bf3a2b29259a 886 bdm_address(addr) && // write the address (same address for second word)
Just4pLeisure 2:bf3a2b29259a 887 bdm_put((uint32_t*)&value2, BDM_WORDSIZE) && // write the second value
Just4pLeisure 2:bf3a2b29259a 888 bdm_ready(BDM_NOP)) ? TERM_OK : TERM_ERR; // wait until MCU responds
Just4pLeisure 1:d5452e398b76 889 }
Just4pLeisure 1:d5452e398b76 890
Just4pLeisure 1:d5452e398b76 891 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 892 /**
Just4pLeisure 1:d5452e398b76 893 Writes a word then reads back a result from the same address
Just4pLeisure 1:d5452e398b76 894 The BDM commands are overlapped to make things a bit faster
Just4pLeisure 1:d5452e398b76 895 A BDM_NOP command is then sent to end the sequence of overlapping commands
Just4pLeisure 1:d5452e398b76 896
Just4pLeisure 1:d5452e398b76 897 @param result read result (out)
Just4pLeisure 1:d5452e398b76 898 addr address
Just4pLeisure 1:d5452e398b76 899 value value to write
Just4pLeisure 1:d5452e398b76 900
Just4pLeisure 1:d5452e398b76 901 @return status flag
Just4pLeisure 1:d5452e398b76 902 */
Just4pLeisure 1:d5452e398b76 903
Just4pLeisure 1:d5452e398b76 904 uint8_t memwrite_word_read_word(uint16_t* result, const uint32_t* addr, const uint16_t value) {
Just4pLeisure 2:bf3a2b29259a 905 return (IN_BDM &&
Just4pLeisure 2:bf3a2b29259a 906 bdm_command(BDM_WRITE + BDM_WORDSIZE) && // write command code
Just4pLeisure 2:bf3a2b29259a 907 bdm_address(addr) && // write the address
Just4pLeisure 2:bf3a2b29259a 908 bdm_put((uint32_t*)&value, BDM_WORDSIZE) && // write the value
Just4pLeisure 2:bf3a2b29259a 909 bdm_ready(BDM_READ + BDM_WORDSIZE) && // wait until MCU responds and overlap the next read command
Just4pLeisure 2:bf3a2b29259a 910 bdm_address(addr) && // write the address (same address for reading the result)
Just4pLeisure 2:bf3a2b29259a 911 bdm_get((uint32_t*)result, BDM_WORDSIZE, BDM_NOP)) ? TERM_OK : TERM_ERR; // receive the response word
Just4pLeisure 1:d5452e398b76 912 }
Just4pLeisure 1:d5452e398b76 913
Just4pLeisure 1:d5452e398b76 914 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 915 /**
Just4pLeisure 1:d5452e398b76 916 Gets a word from the MCU (follows a previously sent read or dump word cmd)
Just4pLeisure 1:d5452e398b76 917 Sends a DUMP_WORD command so that dump commands overlap
Just4pLeisure 1:d5452e398b76 918
Just4pLeisure 1:d5452e398b76 919 @param result read result (out)
Just4pLeisure 1:d5452e398b76 920
Just4pLeisure 1:d5452e398b76 921 @return status flag
Just4pLeisure 1:d5452e398b76 922 */
Just4pLeisure 1:d5452e398b76 923 uint8_t memget_word(uint16_t* result) {
Just4pLeisure 1:d5452e398b76 924
Just4pLeisure 1:d5452e398b76 925 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 926 // receive the response word
Just4pLeisure 1:d5452e398b76 927 return (bdm_get((uint32_t*)result, BDM_WORDSIZE, BDM_DUMP + BDM_WORDSIZE)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 928 }
Just4pLeisure 1:d5452e398b76 929
Just4pLeisure 1:d5452e398b76 930 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 931 /**
Just4pLeisure 1:d5452e398b76 932 Gets a long from the MCU (follows a previously sent read or dump long cmd)
Just4pLeisure 1:d5452e398b76 933 Sends a DUMP_LONG command so that dump commands overlap
Just4pLeisure 1:d5452e398b76 934
Just4pLeisure 1:d5452e398b76 935 @param result read result (out)
Just4pLeisure 1:d5452e398b76 936
Just4pLeisure 1:d5452e398b76 937 @return status flag
Just4pLeisure 1:d5452e398b76 938 */
Just4pLeisure 1:d5452e398b76 939 uint8_t memget_long(uint32_t* result) {
Just4pLeisure 1:d5452e398b76 940
Just4pLeisure 1:d5452e398b76 941 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 942 // receive the response words
Just4pLeisure 1:d5452e398b76 943 return (bdm_get(result, BDM_LONGSIZE, BDM_DUMP + BDM_LONGSIZE)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 944 }
Just4pLeisure 1:d5452e398b76 945
Just4pLeisure 1:d5452e398b76 946 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 947 /**
Just4pLeisure 1:d5452e398b76 948 Reads value from system register.
Just4pLeisure 1:d5452e398b76 949
Just4pLeisure 1:d5452e398b76 950 @param result register value (out)
Just4pLeisure 1:d5452e398b76 951 @param reg register
Just4pLeisure 1:d5452e398b76 952
Just4pLeisure 1:d5452e398b76 953 @return status flag
Just4pLeisure 1:d5452e398b76 954 */
Just4pLeisure 1:d5452e398b76 955 uint8_t sysreg_read(uint32_t* result, uint8_t reg) {
Just4pLeisure 1:d5452e398b76 956 // check state
Just4pLeisure 1:d5452e398b76 957 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 958 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 959 }
Just4pLeisure 1:d5452e398b76 960
Just4pLeisure 1:d5452e398b76 961 // read register
Just4pLeisure 1:d5452e398b76 962 if (!bdm_read(result, BDM_RSREG + reg, NULL)) {
Just4pLeisure 1:d5452e398b76 963 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 964 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 965 }
Just4pLeisure 1:d5452e398b76 966
Just4pLeisure 1:d5452e398b76 967 return TERM_OK;
Just4pLeisure 1:d5452e398b76 968 }
Just4pLeisure 1:d5452e398b76 969
Just4pLeisure 1:d5452e398b76 970 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 971 /**
Just4pLeisure 1:d5452e398b76 972 Writes value to system register.
Just4pLeisure 1:d5452e398b76 973
Just4pLeisure 1:d5452e398b76 974 @param reg register
Just4pLeisure 1:d5452e398b76 975 @param value register value
Just4pLeisure 1:d5452e398b76 976
Just4pLeisure 1:d5452e398b76 977 @return status flag
Just4pLeisure 1:d5452e398b76 978 */
Just4pLeisure 1:d5452e398b76 979 uint8_t sysreg_write(uint8_t reg, const uint32_t* value) {
Just4pLeisure 1:d5452e398b76 980 // check state
Just4pLeisure 1:d5452e398b76 981 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 982 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 983 }
Just4pLeisure 1:d5452e398b76 984
Just4pLeisure 1:d5452e398b76 985 // write register
Just4pLeisure 1:d5452e398b76 986 if (!bdm_write(NULL, BDM_WSREG + reg, value)) {
Just4pLeisure 1:d5452e398b76 987 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 988 bdm_clear();
Just4pLeisure 1:d5452e398b76 989 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 990 }
Just4pLeisure 1:d5452e398b76 991
Just4pLeisure 1:d5452e398b76 992 return TERM_OK;
Just4pLeisure 1:d5452e398b76 993 }
Just4pLeisure 1:d5452e398b76 994
Just4pLeisure 1:d5452e398b76 995 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 996 /**
Just4pLeisure 1:d5452e398b76 997 Reads value from A/D register.
Just4pLeisure 1:d5452e398b76 998
Just4pLeisure 1:d5452e398b76 999 @param result register value (out)
Just4pLeisure 1:d5452e398b76 1000 @param reg register
Just4pLeisure 1:d5452e398b76 1001
Just4pLeisure 1:d5452e398b76 1002 @return status flag
Just4pLeisure 1:d5452e398b76 1003 */
Just4pLeisure 1:d5452e398b76 1004 uint8_t adreg_read(uint32_t* result, uint8_t reg) {
Just4pLeisure 1:d5452e398b76 1005 // check state
Just4pLeisure 1:d5452e398b76 1006 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 1007 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1008 }
Just4pLeisure 1:d5452e398b76 1009
Just4pLeisure 1:d5452e398b76 1010 // read register
Just4pLeisure 1:d5452e398b76 1011 if (!bdm_read(result, BDM_RDREG + reg, NULL)) {
Just4pLeisure 1:d5452e398b76 1012 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 1013 bdm_clear();
Just4pLeisure 1:d5452e398b76 1014 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1015 }
Just4pLeisure 1:d5452e398b76 1016
Just4pLeisure 1:d5452e398b76 1017 return TERM_OK;
Just4pLeisure 1:d5452e398b76 1018 }
Just4pLeisure 1:d5452e398b76 1019
Just4pLeisure 1:d5452e398b76 1020 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1021 /**
Just4pLeisure 1:d5452e398b76 1022 Writes value to A/D register.
Just4pLeisure 1:d5452e398b76 1023
Just4pLeisure 1:d5452e398b76 1024 @param reg register
Just4pLeisure 1:d5452e398b76 1025 @param value register value
Just4pLeisure 1:d5452e398b76 1026
Just4pLeisure 1:d5452e398b76 1027 @return status flag
Just4pLeisure 1:d5452e398b76 1028 */
Just4pLeisure 1:d5452e398b76 1029 uint8_t adreg_write(uint8_t reg, const uint32_t* value) {
Just4pLeisure 1:d5452e398b76 1030 // check state
Just4pLeisure 1:d5452e398b76 1031 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 1032 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1033 }
Just4pLeisure 1:d5452e398b76 1034
Just4pLeisure 1:d5452e398b76 1035 // write register
Just4pLeisure 1:d5452e398b76 1036 if (!bdm_write(NULL, BDM_WRREG + reg, value)) {
Just4pLeisure 1:d5452e398b76 1037 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 1038 bdm_clear();
Just4pLeisure 1:d5452e398b76 1039 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1040 }
Just4pLeisure 1:d5452e398b76 1041
Just4pLeisure 1:d5452e398b76 1042 return TERM_OK;
Just4pLeisure 1:d5452e398b76 1043 }
Just4pLeisure 1:d5452e398b76 1044
Just4pLeisure 1:d5452e398b76 1045 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1046 /**
Just4pLeisure 1:d5452e398b76 1047 Issues a read command to MCU.
Just4pLeisure 1:d5452e398b76 1048
Just4pLeisure 1:d5452e398b76 1049 @param result read result (out)
Just4pLeisure 1:d5452e398b76 1050 @param cmd command sequence
Just4pLeisure 1:d5452e398b76 1051 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 1052
Just4pLeisure 1:d5452e398b76 1053 @return succ / fail
Just4pLeisure 1:d5452e398b76 1054 */
Just4pLeisure 1:d5452e398b76 1055 bool bdm_read(uint32_t* result, uint16_t cmd, const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 1056 *result = 0;
Just4pLeisure 1:d5452e398b76 1057
Just4pLeisure 1:d5452e398b76 1058 // write command code
Just4pLeisure 1:d5452e398b76 1059 bdm_clk(cmd, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1060 if (bdm_response > BDM_CMDCMPLTE) {
Just4pLeisure 1:d5452e398b76 1061 return false;
Just4pLeisure 1:d5452e398b76 1062 }
Just4pLeisure 1:d5452e398b76 1063
Just4pLeisure 1:d5452e398b76 1064 // write the optional address
Just4pLeisure 1:d5452e398b76 1065 if (addr) {
Just4pLeisure 1:d5452e398b76 1066 // first word
Just4pLeisure 1:d5452e398b76 1067 bdm_clk((uint16_t)(*addr >> 16), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1068 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1069 return false;
Just4pLeisure 1:d5452e398b76 1070 }
Just4pLeisure 1:d5452e398b76 1071 // second word
Just4pLeisure 1:d5452e398b76 1072 bdm_clk((uint16_t)(*addr), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1073 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1074 return false;
Just4pLeisure 1:d5452e398b76 1075 }
Just4pLeisure 1:d5452e398b76 1076 }
Just4pLeisure 1:d5452e398b76 1077
Just4pLeisure 1:d5452e398b76 1078 // receive response words
Just4pLeisure 1:d5452e398b76 1079 uint8_t wait_cnt;
Just4pLeisure 1:d5452e398b76 1080 for (uint8_t curr_word = 0; curr_word < ((cmd & BDM_LONGSIZE) ? 2 : 1);
Just4pLeisure 1:d5452e398b76 1081 ++curr_word) {
Just4pLeisure 1:d5452e398b76 1082 // wait while MCU prepares the response
Just4pLeisure 1:d5452e398b76 1083 wait_cnt = ERR_COUNT;
Just4pLeisure 1:d5452e398b76 1084 do {
Just4pLeisure 1:d5452e398b76 1085 bdm_clk(BDM_NOP, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1086 } while (bdm_response == BDM_NOTREADY && --wait_cnt > 0);
Just4pLeisure 1:d5452e398b76 1087
Just4pLeisure 1:d5452e398b76 1088 // save the result
Just4pLeisure 1:d5452e398b76 1089 if (bdm_response < BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1090 (*result) <<= 16;
Just4pLeisure 1:d5452e398b76 1091 (*result) |= bdm_response;
Just4pLeisure 1:d5452e398b76 1092 } else {
Just4pLeisure 1:d5452e398b76 1093 // result was not received
Just4pLeisure 1:d5452e398b76 1094 return false;
Just4pLeisure 1:d5452e398b76 1095 }
Just4pLeisure 1:d5452e398b76 1096 }
Just4pLeisure 1:d5452e398b76 1097
Just4pLeisure 1:d5452e398b76 1098 return true;
Just4pLeisure 1:d5452e398b76 1099 }
Just4pLeisure 1:d5452e398b76 1100
Just4pLeisure 1:d5452e398b76 1101 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1102 /**
Just4pLeisure 1:d5452e398b76 1103 Issues a write command to MCU.
Just4pLeisure 1:d5452e398b76 1104
Just4pLeisure 1:d5452e398b76 1105 @param num_words number of additional command words
Just4pLeisure 1:d5452e398b76 1106 @param cmd command sequence
Just4pLeisure 1:d5452e398b76 1107
Just4pLeisure 1:d5452e398b76 1108 @return succ / fail
Just4pLeisure 1:d5452e398b76 1109 */
Just4pLeisure 1:d5452e398b76 1110 bool bdm_write(const uint32_t* addr, uint16_t cmd, const uint32_t* value) {
Just4pLeisure 1:d5452e398b76 1111 // write command code
Just4pLeisure 1:d5452e398b76 1112 bdm_clk(cmd, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1113 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1114 return false;
Just4pLeisure 1:d5452e398b76 1115 }
Just4pLeisure 1:d5452e398b76 1116
Just4pLeisure 1:d5452e398b76 1117 // write the optional address
Just4pLeisure 1:d5452e398b76 1118 if (addr) {
Just4pLeisure 1:d5452e398b76 1119 // first word
Just4pLeisure 1:d5452e398b76 1120 bdm_clk((uint16_t)((*addr) >> 16), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1121 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1122 return false;
Just4pLeisure 1:d5452e398b76 1123 }
Just4pLeisure 1:d5452e398b76 1124 // second word
Just4pLeisure 1:d5452e398b76 1125 bdm_clk((uint16_t)(*addr), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1126 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1127 return false;
Just4pLeisure 1:d5452e398b76 1128 }
Just4pLeisure 1:d5452e398b76 1129 }
Just4pLeisure 1:d5452e398b76 1130
Just4pLeisure 1:d5452e398b76 1131 // write the value
Just4pLeisure 1:d5452e398b76 1132 if (cmd & BDM_LONGSIZE) {
Just4pLeisure 1:d5452e398b76 1133 bdm_clk((uint16_t)((*value) >> 16), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1134 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1135 return false;
Just4pLeisure 1:d5452e398b76 1136 }
Just4pLeisure 1:d5452e398b76 1137 }
Just4pLeisure 1:d5452e398b76 1138 bdm_clk((uint16_t)(*value), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1139 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1140 return false;
Just4pLeisure 1:d5452e398b76 1141 }
Just4pLeisure 1:d5452e398b76 1142
Just4pLeisure 1:d5452e398b76 1143 // wait until MCU responds
Just4pLeisure 1:d5452e398b76 1144 uint8_t wait_cnt = ERR_COUNT;
Just4pLeisure 1:d5452e398b76 1145 do {
Just4pLeisure 1:d5452e398b76 1146 // read response
Just4pLeisure 1:d5452e398b76 1147 bdm_clk(BDM_NOP, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1148 } while (bdm_response == BDM_NOTREADY && --wait_cnt > 0);
Just4pLeisure 1:d5452e398b76 1149
Just4pLeisure 1:d5452e398b76 1150 // check if command succeeded
Just4pLeisure 1:d5452e398b76 1151 return (bdm_response == BDM_CMDCMPLTE);
Just4pLeisure 1:d5452e398b76 1152 }
Just4pLeisure 1:d5452e398b76 1153
Just4pLeisure 1:d5452e398b76 1154 bool bdm_command (uint16_t cmd) {
Just4pLeisure 1:d5452e398b76 1155 // write command code
Just4pLeisure 2:bf3a2b29259a 1156 bdm_clk_fast(cmd, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1157 return (bdm_response > BDM_NOTREADY) ? false : true;
Just4pLeisure 1:d5452e398b76 1158 }
Just4pLeisure 1:d5452e398b76 1159
Just4pLeisure 1:d5452e398b76 1160 bool bdm_address (const uint32_t* addr) {
Just4pLeisure 1:d5452e398b76 1161 // write an address
Just4pLeisure 1:d5452e398b76 1162 // first word
Just4pLeisure 2:bf3a2b29259a 1163 bdm_clk_fast((uint16_t)((*addr) >> 16), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1164 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1165 return false;
Just4pLeisure 1:d5452e398b76 1166 }
Just4pLeisure 1:d5452e398b76 1167 // second word
Just4pLeisure 2:bf3a2b29259a 1168 bdm_clk_fast((uint16_t)(*addr), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1169 return (bdm_response > BDM_NOTREADY) ? false : true;
Just4pLeisure 1:d5452e398b76 1170 }
Just4pLeisure 1:d5452e398b76 1171
Just4pLeisure 1:d5452e398b76 1172 bool bdm_get (uint32_t* result, uint8_t size, uint16_t next_cmd) {
Just4pLeisure 1:d5452e398b76 1173 // receive response words
Just4pLeisure 1:d5452e398b76 1174 *result = 0;
Just4pLeisure 1:d5452e398b76 1175 uint8_t wait_cnt;
Just4pLeisure 1:d5452e398b76 1176 for (uint8_t curr_word = 0; curr_word < ((size & BDM_LONGSIZE) ? 2 : 1);
Just4pLeisure 1:d5452e398b76 1177 ++curr_word) {
Just4pLeisure 1:d5452e398b76 1178 // wait while MCU prepares the response
Just4pLeisure 1:d5452e398b76 1179 wait_cnt = ERR_COUNT;
Just4pLeisure 1:d5452e398b76 1180 do {
Just4pLeisure 2:bf3a2b29259a 1181 bdm_clk_fast(next_cmd, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1182 } while (bdm_response == BDM_NOTREADY && --wait_cnt > 0);
Just4pLeisure 1:d5452e398b76 1183
Just4pLeisure 1:d5452e398b76 1184 // save the result
Just4pLeisure 1:d5452e398b76 1185 if (bdm_response < BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1186 (*result) <<= 16;
Just4pLeisure 1:d5452e398b76 1187 (*result) |= bdm_response;
Just4pLeisure 1:d5452e398b76 1188 } else {
Just4pLeisure 1:d5452e398b76 1189 // result was not received
Just4pLeisure 1:d5452e398b76 1190 return false;
Just4pLeisure 1:d5452e398b76 1191 }
Just4pLeisure 1:d5452e398b76 1192 }
Just4pLeisure 1:d5452e398b76 1193 return true;
Just4pLeisure 1:d5452e398b76 1194 }
Just4pLeisure 1:d5452e398b76 1195
Just4pLeisure 1:d5452e398b76 1196 bool bdm_put (const uint32_t* value, uint8_t size) {
Just4pLeisure 1:d5452e398b76 1197 // write the value
Just4pLeisure 1:d5452e398b76 1198 if (size & BDM_LONGSIZE) {
Just4pLeisure 2:bf3a2b29259a 1199 bdm_clk_fast((uint16_t)((*value) >> 16), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1200 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1201 return false;
Just4pLeisure 1:d5452e398b76 1202 }
Just4pLeisure 1:d5452e398b76 1203 }
Just4pLeisure 2:bf3a2b29259a 1204 bdm_clk_fast((uint16_t)(*value), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1205 return (bdm_response > BDM_NOTREADY) ? false : true;
Just4pLeisure 1:d5452e398b76 1206 }
Just4pLeisure 1:d5452e398b76 1207
Just4pLeisure 1:d5452e398b76 1208 bool bdm_ready (uint16_t next_cmd) {
Just4pLeisure 1:d5452e398b76 1209 // wait until MCU responds
Just4pLeisure 1:d5452e398b76 1210 uint8_t wait_cnt = ERR_COUNT;
Just4pLeisure 1:d5452e398b76 1211 do {
Just4pLeisure 1:d5452e398b76 1212 // read response
Just4pLeisure 2:bf3a2b29259a 1213 bdm_clk_fast(next_cmd, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1214 } while (bdm_response == BDM_NOTREADY && --wait_cnt > 0);
Just4pLeisure 1:d5452e398b76 1215
Just4pLeisure 1:d5452e398b76 1216 // check if command succeeded
Just4pLeisure 1:d5452e398b76 1217 return (bdm_response == BDM_CMDCMPLTE);
Just4pLeisure 1:d5452e398b76 1218 }
Just4pLeisure 1:d5452e398b76 1219
Just4pLeisure 1:d5452e398b76 1220 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1221 /**
Just4pLeisure 1:d5452e398b76 1222 Writes a word to target MCU via BDM line and gets the response.
Just4pLeisure 1:d5452e398b76 1223
Just4pLeisure 1:d5452e398b76 1224 @param value value to write
Just4pLeisure 1:d5452e398b76 1225 @param num_bits value size, bits
Just4pLeisure 1:d5452e398b76 1226 */
Just4pLeisure 1:d5452e398b76 1227 void bdm_clk(uint16_t value, uint8_t num_bits) {
Just4pLeisure 1:d5452e398b76 1228 // PIN_BKPT.output();
Just4pLeisure 2:bf3a2b29259a 1229 PIN_DSI.output();
Just4pLeisure 1:d5452e398b76 1230 // clock the value via BDM
Just4pLeisure 1:d5452e398b76 1231 bdm_response = ((uint32_t)value) << (32 - num_bits);
Just4pLeisure 1:d5452e398b76 1232 // bool dsi;
Just4pLeisure 1:d5452e398b76 1233 while (num_bits--) {
Just4pLeisure 1:d5452e398b76 1234
Just4pLeisure 1:d5452e398b76 1235 // falling edge on BKPT/DSCLK
Just4pLeisure 1:d5452e398b76 1236 PIN_BKPT.write(0);
Just4pLeisure 1:d5452e398b76 1237 // set DSI bit
Just4pLeisure 1:d5452e398b76 1238 PIN_DSI.write(bdm_response & 0x80000000);
Just4pLeisure 1:d5452e398b76 1239 bdm_response <<= 1;
Just4pLeisure 1:d5452e398b76 1240 // read DSO bit
Just4pLeisure 1:d5452e398b76 1241 bdm_response |= PIN_DSO.read();
Just4pLeisure 1:d5452e398b76 1242 // short delay
Just4pLeisure 1:d5452e398b76 1243 // for (uint8_t c = 1; c; c--);
Just4pLeisure 1:d5452e398b76 1244 // wait_us(1);
Just4pLeisure 1:d5452e398b76 1245 // rising edge on BKPT/DSCLK
Just4pLeisure 1:d5452e398b76 1246 PIN_BKPT.write(1);
Just4pLeisure 1:d5452e398b76 1247 // short delay
Just4pLeisure 1:d5452e398b76 1248 for (uint8_t c = 1; c; c--);
Just4pLeisure 1:d5452e398b76 1249 // wait_us(1);
Just4pLeisure 1:d5452e398b76 1250 }
Just4pLeisure 1:d5452e398b76 1251 PIN_DSI.input();
Just4pLeisure 1:d5452e398b76 1252 }
Just4pLeisure 1:d5452e398b76 1253
Just4pLeisure 1:d5452e398b76 1254 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1255 /**
Just4pLeisure 2:bf3a2b29259a 1256 Writes a word to target MCU via BDM line and gets the response.
Just4pLeisure 2:bf3a2b29259a 1257 This 'fast' version can be used once the 68332 has been 'prepped'
Just4pLeisure 2:bf3a2b29259a 1258 because the BDM interface can go twice as fast once the 68332
Just4pLeisure 2:bf3a2b29259a 1259 clock is increased from 8 MHz to 16 MHz
Just4pLeisure 2:bf3a2b29259a 1260
Just4pLeisure 2:bf3a2b29259a 1261 @param value value to write
Just4pLeisure 2:bf3a2b29259a 1262 @param num_bits value size, bits
Just4pLeisure 2:bf3a2b29259a 1263 */
Just4pLeisure 2:bf3a2b29259a 1264 void bdm_clk_fast(uint16_t value, uint8_t num_bits) {
Just4pLeisure 2:bf3a2b29259a 1265
Just4pLeisure 2:bf3a2b29259a 1266 //Set BKPT
Just4pLeisure 2:bf3a2b29259a 1267 // PIN_BKPT.write(1);
Just4pLeisure 2:bf3a2b29259a 1268 // LPC_GPIO2->FIOSET = (1 << 4);
Just4pLeisure 2:bf3a2b29259a 1269 // PIN_BKPT.output();
Just4pLeisure 2:bf3a2b29259a 1270
Just4pLeisure 2:bf3a2b29259a 1271 // uint32_t mask = LPC_GPIO2->FIOMASK;
Just4pLeisure 2:bf3a2b29259a 1272 // LPC_GPIO2->FIOMASK = ~((1 << 4) | (1 << 2));
Just4pLeisure 2:bf3a2b29259a 1273 //Make DSI an output
Just4pLeisure 2:bf3a2b29259a 1274 LPC_GPIO2->FIODIR |= (1 << 2);
Just4pLeisure 2:bf3a2b29259a 1275 // clock the value via BDM
Just4pLeisure 2:bf3a2b29259a 1276 bdm_response = ((uint32_t)value) << (32 - num_bits);
Just4pLeisure 2:bf3a2b29259a 1277 while (num_bits--) {
Just4pLeisure 2:bf3a2b29259a 1278 // set DSI bit
Just4pLeisure 2:bf3a2b29259a 1279 // LPC_GPIO2->FIOPIN = ((bool)(bdm_response & 0x80000000) << 2);
Just4pLeisure 2:bf3a2b29259a 1280 if (bdm_response & 0x80000000)
Just4pLeisure 2:bf3a2b29259a 1281 LPC_GPIO2->FIOSET = (1 << 2);
Just4pLeisure 2:bf3a2b29259a 1282 else
Just4pLeisure 2:bf3a2b29259a 1283 LPC_GPIO2->FIOCLR = (1 << 2);
Just4pLeisure 2:bf3a2b29259a 1284 // falling edge on BKPT/DSCLK
Just4pLeisure 2:bf3a2b29259a 1285 LPC_GPIO2->FIOCLR = (1 << 4);
Just4pLeisure 2:bf3a2b29259a 1286 // for (uint8_t c = 1; c; c--);
Just4pLeisure 2:bf3a2b29259a 1287 // // read DSO bit
Just4pLeisure 2:bf3a2b29259a 1288 // (bdm_response <<= 1) |= (bool)((LPC_GPIO0->FIOPIN) & (1 << 11)); -- OLD CONNECTION to PIN 27
Just4pLeisure 2:bf3a2b29259a 1289 (bdm_response <<= 1) |= (bool)((LPC_GPIO2->FIOPIN) & (1 << 1));
Just4pLeisure 2:bf3a2b29259a 1290 // rising edge on BKPT/DSCLK
Just4pLeisure 2:bf3a2b29259a 1291 LPC_GPIO2->FIOSET = (1 << 4);
Just4pLeisure 2:bf3a2b29259a 1292 for (uint8_t c = 1; c; c--);
Just4pLeisure 2:bf3a2b29259a 1293 }
Just4pLeisure 2:bf3a2b29259a 1294 //Make DSI an input
Just4pLeisure 2:bf3a2b29259a 1295 LPC_GPIO2->FIODIR &= ~(1 << 2);
Just4pLeisure 2:bf3a2b29259a 1296 // LPC_GPIO2->FIOMASK = mask;
Just4pLeisure 2:bf3a2b29259a 1297 }
Just4pLeisure 2:bf3a2b29259a 1298 //-----------------------------------------------------------------------------
Just4pLeisure 2:bf3a2b29259a 1299 /**
Just4pLeisure 1:d5452e398b76 1300 Clears the BDM interface after errors.
Just4pLeisure 1:d5452e398b76 1301 */
Just4pLeisure 1:d5452e398b76 1302 void bdm_clear() {
Just4pLeisure 1:d5452e398b76 1303 bdm_clk (BDM_NOP, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1304 bdm_clk (BDM_NOP, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1305 bdm_clk (BDM_NOP, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1306 bdm_clk (BDM_NOP, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1307
Just4pLeisure 1:d5452e398b76 1308 while (bdm_response > 0) {
Just4pLeisure 1:d5452e398b76 1309 bdm_clk(0, 1);
Just4pLeisure 1:d5452e398b76 1310 }
Just4pLeisure 1:d5452e398b76 1311 while (bdm_response < 1) {
Just4pLeisure 1:d5452e398b76 1312 bdm_clk(0, 1);
Just4pLeisure 1:d5452e398b76 1313 }
Just4pLeisure 1:d5452e398b76 1314 bdm_clk(0, 15);
Just4pLeisure 1:d5452e398b76 1315 }
Just4pLeisure 1:d5452e398b76 1316
Just4pLeisure 1:d5452e398b76 1317 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1318 // EOF
Just4pLeisure 1:d5452e398b76 1319 //-----------------------------------------------------------------------------