Sophie Dexter / Mbed 2 deprecated Just4Trionic

Just4Trionic - CAN and BDM FLASH programmer for Saab cars

Dependencies:   mbed

bdmcpu32.cpp@6:2fbcbebed28c, 2016-04-23 (annotated)

Committer:
Just4pLeisure
Date:
Sat Apr 23 18:31:40 2016 +0000
Revision:
6:2fbcbebed28c
Parent:
5:1775b4b13232 
Version 1.6 Faster T7 P-BUS FLASHing algorithm, longer T8 erase timeout fixed BDM register display function

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 5:1775b4b13232 66 // Bit-Banding memory region constants and macros
Just4pLeisure 5:1775b4b13232 67 #define RAM_BASE 0x20000000
Just4pLeisure 5:1775b4b13232 68 #define RAM_BB_BASE 0x22000000
Just4pLeisure 5:1775b4b13232 69 #define PERIHERALS_BASE 0x40000000
Just4pLeisure 5:1775b4b13232 70 #define PERIHERALS_BB_BASE 0x42000000
Just4pLeisure 5:1775b4b13232 71 #define LPC1768_AHB_BANK_0 0x2007C000
Just4pLeisure 5:1775b4b13232 72 #define LPC1768_AHB_BANK_1 0x20080000
Just4pLeisure 5:1775b4b13232 73 #define LPC1768_AHB_BANK_SIZE 0x00004000
Just4pLeisure 5:1775b4b13232 74 #define LPC1768_PERIPH_BANK 0x2009C000
Just4pLeisure 5:1775b4b13232 75 #define LPC1768_PERIPH_SIZE 0x00004000
Just4pLeisure 5:1775b4b13232 76
Just4pLeisure 5:1775b4b13232 77 #define varBit(Variable,BitNumber) (*(uint32_t *) (RAM_BB_BASE | (((uint32_t)&Variable - RAM_BASE) << 5) | ((BitNumber) << 2)))
Just4pLeisure 5:1775b4b13232 78 #define periphBit(Peripheral,BitNumber) (*(uint32_t *) (PERIHERALS_BB_BASE | (((uint32_t)&Peripheral - PERIHERALS_BASE) << 5) | ((BitNumber) << 2)))
Just4pLeisure 5:1775b4b13232 79 #define bitAlias(Variable,BitNumber) (*(uint32_t *) (RAM_BB_BASE | (((uint32_t)&Variable - RAM_BASE) << 5) | ((BitNumber) << 2)))
Just4pLeisure 5:1775b4b13232 80
Just4pLeisure 1:d5452e398b76 81 // static variables
Just4pLeisure 5:1775b4b13232 82 __attribute__((section("AHBSRAM0"))) static uint32_t bdm_response = 0; ///< result of BDM read/write operation
Just4pLeisure 1:d5452e398b76 83
Just4pLeisure 1:d5452e398b76 84 // private functions
Just4pLeisure 1:d5452e398b76 85 bool bdm_read(uint32_t* result, uint16_t cmd, const uint32_t* addr);
Just4pLeisure 1:d5452e398b76 86 //bool bdm_read_overlap(uint32_t* result, uint16_t cmd, const uint32_t* addr, uint16_t next_cmd);
Just4pLeisure 1:d5452e398b76 87 //bool bdm_read_continue(uint32_t* result, const uint32_t* addr, uint16_t next_cmd);
Just4pLeisure 1:d5452e398b76 88 bool bdm_write(const uint32_t* addr, uint16_t cmd, const uint32_t* value);
Just4pLeisure 1:d5452e398b76 89 //bool bdm_write_overlap(const uint32_t* addr, uint16_t cmd, const uint32_t* value, uint16_t next_cmd);
Just4pLeisure 5:1775b4b13232 90 //
Just4pLeisure 5:1775b4b13232 91 //void bdm_clk(uint16_t value, uint8_t num_bits);
Just4pLeisure 5:1775b4b13232 92 void bdm_clk_slow(uint16_t value, uint8_t num_bits);
Just4pLeisure 2:bf3a2b29259a 93 void bdm_clk_fast(uint16_t value, uint8_t num_bits);
Just4pLeisure 5:1775b4b13232 94 void bdm_clk_turbo(uint16_t value, uint8_t num_bits);
Just4pLeisure 5:1775b4b13232 95 void bdm_clk_nitrous(uint16_t value, uint8_t num_bits);
Just4pLeisure 5:1775b4b13232 96 void (*bdm_clk)(uint16_t value, uint8_t num_bits) = bdm_clk_slow;
Just4pLeisure 5:1775b4b13232 97 //
Just4pLeisure 1:d5452e398b76 98 void bdm_clear();
Just4pLeisure 1:d5452e398b76 99
Just4pLeisure 1:d5452e398b76 100 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 101 /**
Just4pLeisure 1:d5452e398b76 102 Stops target MCU and puts into background debug mode (BDM).
Just4pLeisure 1:d5452e398b76 103
Just4pLeisure 1:d5452e398b76 104 @return status flag
Just4pLeisure 1:d5452e398b76 105 */
Just4pLeisure 5:1775b4b13232 106 uint8_t stop_chip()
Just4pLeisure 5:1775b4b13232 107 {
Just4pLeisure 1:d5452e398b76 108 // not connected
Just4pLeisure 1:d5452e398b76 109 if (!IS_CONNECTED) {
Just4pLeisure 1:d5452e398b76 110 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 111 }
Just4pLeisure 1:d5452e398b76 112
Just4pLeisure 1:d5452e398b76 113 // pull BKPT low to enter background mode (the pin must remain in output mode,
Just4pLeisure 1:d5452e398b76 114 // otherwise the target will pull it high and we'll lose the first DSO bit)
Just4pLeisure 1:d5452e398b76 115 PIN_BKPT.write(0);
Just4pLeisure 1:d5452e398b76 116 // set BPKT pin as output
Just4pLeisure 1:d5452e398b76 117 PIN_BKPT.output();
Just4pLeisure 1:d5452e398b76 118
Just4pLeisure 1:d5452e398b76 119 // wait for target MCU to settle
Just4pLeisure 5:1775b4b13232 120 //wait_ms(MCU_SETTLE_TIME);
Just4pLeisure 5:1775b4b13232 121 timeout.reset();
Just4pLeisure 5:1775b4b13232 122 timeout.start();
Just4pLeisure 5:1775b4b13232 123 while (!IN_BDM & (timeout.read_ms() < MCU_SETTLE_TIME))
Just4pLeisure 5:1775b4b13232 124 timeout.stop();
Just4pLeisure 1:d5452e398b76 125
Just4pLeisure 1:d5452e398b76 126 // check if succeeded
Just4pLeisure 1:d5452e398b76 127 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 128 // set BKPT back as input and fail
Just4pLeisure 1:d5452e398b76 129 PIN_BKPT.input();
Just4pLeisure 1:d5452e398b76 130 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 131 }
Just4pLeisure 1:d5452e398b76 132
Just4pLeisure 1:d5452e398b76 133 return TERM_OK;
Just4pLeisure 1:d5452e398b76 134 }
Just4pLeisure 1:d5452e398b76 135
Just4pLeisure 1:d5452e398b76 136 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 137 /**
Just4pLeisure 1:d5452e398b76 138 Forces hardware reset on target MCU and lets it run.
Just4pLeisure 1:d5452e398b76 139
Just4pLeisure 1:d5452e398b76 140 @return status flag
Just4pLeisure 1:d5452e398b76 141 */
Just4pLeisure 5:1775b4b13232 142 uint8_t reset_chip()
Just4pLeisure 5:1775b4b13232 143 {
Just4pLeisure 1:d5452e398b76 144 // not connected
Just4pLeisure 1:d5452e398b76 145 if (!IS_CONNECTED) {
Just4pLeisure 1:d5452e398b76 146 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 147 }
Just4pLeisure 1:d5452e398b76 148
Just4pLeisure 1:d5452e398b76 149 // BKPT pin as input
Just4pLeisure 1:d5452e398b76 150 PIN_BKPT.input();
Just4pLeisure 1:d5452e398b76 151 // push RESET low
Just4pLeisure 1:d5452e398b76 152 PIN_RESET.write(0);
Just4pLeisure 1:d5452e398b76 153 // RESET pins as output
Just4pLeisure 1:d5452e398b76 154 PIN_RESET.output();
Just4pLeisure 1:d5452e398b76 155 // wait for MCU to settle
Just4pLeisure 1:d5452e398b76 156 wait_ms(MCU_SETTLE_TIME);
Just4pLeisure 1:d5452e398b76 157 // rising edge on RESET line
Just4pLeisure 1:d5452e398b76 158 PIN_RESET.write(1);
Just4pLeisure 1:d5452e398b76 159 // wait for MCU to settle
Just4pLeisure 1:d5452e398b76 160 wait_ms(MCU_SETTLE_TIME);
Just4pLeisure 1:d5452e398b76 161
Just4pLeisure 1:d5452e398b76 162 // set RESET as an input again
Just4pLeisure 1:d5452e398b76 163 PIN_RESET.input();
Just4pLeisure 1:d5452e398b76 164
Just4pLeisure 1:d5452e398b76 165 // check if succeeded
Just4pLeisure 1:d5452e398b76 166 return IS_RUNNING ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 167 }
Just4pLeisure 1:d5452e398b76 168
Just4pLeisure 1:d5452e398b76 169 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 170 /**
Just4pLeisure 1:d5452e398b76 171 Starts target MCU from the specified address. If address is 0, execution
Just4pLeisure 1:d5452e398b76 172 begins at the current address in program counter.
Just4pLeisure 1:d5452e398b76 173
Just4pLeisure 1:d5452e398b76 174 @param addr start address
Just4pLeisure 1:d5452e398b76 175
Just4pLeisure 1:d5452e398b76 176 @return status flag
Just4pLeisure 1:d5452e398b76 177 */
Just4pLeisure 5:1775b4b13232 178 uint8_t run_chip(const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 179 {
Just4pLeisure 1:d5452e398b76 180 // check state
Just4pLeisure 1:d5452e398b76 181 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 182 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 183 }
Just4pLeisure 1:d5452e398b76 184
Just4pLeisure 1:d5452e398b76 185 // set program counter
Just4pLeisure 1:d5452e398b76 186 if ((*addr > 0) && sysreg_write(SREG_RPC, addr) != TERM_OK) {
Just4pLeisure 1:d5452e398b76 187 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 188 }
Just4pLeisure 1:d5452e398b76 189 // resume MCU
Just4pLeisure 1:d5452e398b76 190 bdm_clk(BDM_GO, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 191
Just4pLeisure 1:d5452e398b76 192 // set BKPT back as input
Just4pLeisure 5:1775b4b13232 193 // PIN_BKPT.input();
Just4pLeisure 1:d5452e398b76 194
Just4pLeisure 1:d5452e398b76 195 return TERM_OK;
Just4pLeisure 5:1775b4b13232 196 // wait for target MCU to settle
Just4pLeisure 5:1775b4b13232 197 timeout.reset();
Just4pLeisure 5:1775b4b13232 198 timeout.start();
Just4pLeisure 5:1775b4b13232 199 // while (!IS_RUNNING & (timeout.read_ms() < MCU_SETTLE_TIME))
Just4pLeisure 5:1775b4b13232 200 while (IN_BDM & (timeout.read_ms() < MCU_SETTLE_TIME))
Just4pLeisure 5:1775b4b13232 201 timeout.stop();
Just4pLeisure 5:1775b4b13232 202
Just4pLeisure 5:1775b4b13232 203 // return IS_RUNNING ? TERM_OK : TERM_ERR;
Just4pLeisure 5:1775b4b13232 204 return !IN_BDM ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 205 }
Just4pLeisure 1:d5452e398b76 206
Just4pLeisure 1:d5452e398b76 207 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 208 /**
Just4pLeisure 1:d5452e398b76 209 Resets target MCU and stops execution on first instruction fetch.
Just4pLeisure 1:d5452e398b76 210
Just4pLeisure 1:d5452e398b76 211 @return status flag
Just4pLeisure 1:d5452e398b76 212 */
Just4pLeisure 5:1775b4b13232 213 uint8_t restart_chip()
Just4pLeisure 5:1775b4b13232 214 {
Just4pLeisure 1:d5452e398b76 215 // not connected
Just4pLeisure 1:d5452e398b76 216 if (!IS_CONNECTED) {
Just4pLeisure 1:d5452e398b76 217 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 218 }
Just4pLeisure 1:d5452e398b76 219
Just4pLeisure 1:d5452e398b76 220 // pull BKPT low to enter background mode (the pin must remain an output,
Just4pLeisure 1:d5452e398b76 221 // otherwise the target will pull it high and we'll lose the first DSO bit)
Just4pLeisure 1:d5452e398b76 222 PIN_BKPT.write(0);
Just4pLeisure 1:d5452e398b76 223 // push RESET low
Just4pLeisure 1:d5452e398b76 224 PIN_RESET.write(0);
Just4pLeisure 1:d5452e398b76 225 // RESET, BKPT pins as outputs
Just4pLeisure 1:d5452e398b76 226 PIN_BKPT.output();
Just4pLeisure 1:d5452e398b76 227 PIN_RESET.output();
Just4pLeisure 1:d5452e398b76 228 // wait for target MCU to settle
Just4pLeisure 5:1775b4b13232 229 wait_ms(10*MCU_SETTLE_TIME);
Just4pLeisure 1:d5452e398b76 230 // rising edge on RESET line
Just4pLeisure 1:d5452e398b76 231 PIN_RESET.write(1);
Just4pLeisure 1:d5452e398b76 232 // wait for target MCU to settle
Just4pLeisure 5:1775b4b13232 233 wait_ms(10*MCU_SETTLE_TIME);
Just4pLeisure 1:d5452e398b76 234 // set RESET back as an input
Just4pLeisure 1:d5452e398b76 235 PIN_RESET.input();
Just4pLeisure 1:d5452e398b76 236
Just4pLeisure 1:d5452e398b76 237 // check if succeeded
Just4pLeisure 1:d5452e398b76 238 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 239 // set BKPT back as input and fail
Just4pLeisure 1:d5452e398b76 240 PIN_BKPT.input();
Just4pLeisure 1:d5452e398b76 241 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 242 }
Just4pLeisure 1:d5452e398b76 243
Just4pLeisure 1:d5452e398b76 244 return TERM_OK;
Just4pLeisure 1:d5452e398b76 245 }
Just4pLeisure 1:d5452e398b76 246
Just4pLeisure 1:d5452e398b76 247 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 248 /**
Just4pLeisure 1:d5452e398b76 249 Sends GO command word to target MCU, then triggers breakpoint on first
Just4pLeisure 1:d5452e398b76 250 instruction fetch.
Just4pLeisure 1:d5452e398b76 251
Just4pLeisure 1:d5452e398b76 252 @return status flag
Just4pLeisure 1:d5452e398b76 253 */
Just4pLeisure 5:1775b4b13232 254 uint8_t step_chip()
Just4pLeisure 5:1775b4b13232 255 {
Just4pLeisure 1:d5452e398b76 256 // not connected
Just4pLeisure 1:d5452e398b76 257 if (!IS_CONNECTED) {
Just4pLeisure 1:d5452e398b76 258 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 259 }
Just4pLeisure 1:d5452e398b76 260
Just4pLeisure 1:d5452e398b76 261 // resume MCU
Just4pLeisure 1:d5452e398b76 262 bdm_clk(BDM_GO, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 263
Just4pLeisure 1:d5452e398b76 264 // pull BKPT low to enter background mode (the pin must remain an output,
Just4pLeisure 1:d5452e398b76 265 // otherwise the target pulls it high and we lose the first DSO bit)
Just4pLeisure 1:d5452e398b76 266 PIN_BKPT.write(0);
Just4pLeisure 1:d5452e398b76 267 // set BPKT pin as output
Just4pLeisure 1:d5452e398b76 268 PIN_BKPT.output();
Just4pLeisure 1:d5452e398b76 269
Just4pLeisure 1:d5452e398b76 270 // wait for target MCU to settle
Just4pLeisure 1:d5452e398b76 271 // delay_ms(MCU_SETTLE_TIME);
Just4pLeisure 1:d5452e398b76 272 wait_ms(MCU_SETTLE_TIME);
Just4pLeisure 1:d5452e398b76 273
Just4pLeisure 1:d5452e398b76 274 // check if succeeded
Just4pLeisure 1:d5452e398b76 275 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 276 // set BKPT back as input and fail
Just4pLeisure 1:d5452e398b76 277 PIN_BKPT.input();
Just4pLeisure 1:d5452e398b76 278 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 279 }
Just4pLeisure 1:d5452e398b76 280
Just4pLeisure 1:d5452e398b76 281 return TERM_OK;
Just4pLeisure 1:d5452e398b76 282 }
Just4pLeisure 1:d5452e398b76 283
Just4pLeisure 1:d5452e398b76 284 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 285 /**
Just4pLeisure 1:d5452e398b76 286 Pulls BKPT pin low.
Just4pLeisure 1:d5452e398b76 287 */
Just4pLeisure 5:1775b4b13232 288 uint8_t bkpt_low()
Just4pLeisure 5:1775b4b13232 289 {
Just4pLeisure 1:d5452e398b76 290 PIN_BKPT.write(0);
Just4pLeisure 1:d5452e398b76 291 PIN_BKPT.output();
Just4pLeisure 1:d5452e398b76 292
Just4pLeisure 1:d5452e398b76 293 return TERM_OK;
Just4pLeisure 1:d5452e398b76 294 }
Just4pLeisure 1:d5452e398b76 295
Just4pLeisure 1:d5452e398b76 296 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 297 /**
Just4pLeisure 1:d5452e398b76 298 Pulls BKPT pin high.
Just4pLeisure 1:d5452e398b76 299 */
Just4pLeisure 5:1775b4b13232 300 uint8_t bkpt_high()
Just4pLeisure 5:1775b4b13232 301 {
Just4pLeisure 1:d5452e398b76 302 PIN_BKPT.write(1);
Just4pLeisure 1:d5452e398b76 303 PIN_BKPT.output();
Just4pLeisure 1:d5452e398b76 304
Just4pLeisure 1:d5452e398b76 305 return TERM_OK;
Just4pLeisure 1:d5452e398b76 306 }
Just4pLeisure 1:d5452e398b76 307
Just4pLeisure 1:d5452e398b76 308 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 309 /**
Just4pLeisure 1:d5452e398b76 310 Pulls RESET pin low.
Just4pLeisure 1:d5452e398b76 311 */
Just4pLeisure 5:1775b4b13232 312 uint8_t reset_low()
Just4pLeisure 5:1775b4b13232 313 {
Just4pLeisure 1:d5452e398b76 314 PIN_RESET.write(0);
Just4pLeisure 1:d5452e398b76 315 PIN_RESET.output();
Just4pLeisure 1:d5452e398b76 316
Just4pLeisure 1:d5452e398b76 317 return TERM_OK;
Just4pLeisure 1:d5452e398b76 318 }
Just4pLeisure 1:d5452e398b76 319
Just4pLeisure 1:d5452e398b76 320 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 321 /**
Just4pLeisure 1:d5452e398b76 322 Pulls RESET pin high.
Just4pLeisure 1:d5452e398b76 323 */
Just4pLeisure 5:1775b4b13232 324 uint8_t reset_high()
Just4pLeisure 5:1775b4b13232 325 {
Just4pLeisure 1:d5452e398b76 326 PIN_RESET.write(1);
Just4pLeisure 1:d5452e398b76 327 PIN_RESET.output();
Just4pLeisure 1:d5452e398b76 328
Just4pLeisure 1:d5452e398b76 329 return TERM_OK;
Just4pLeisure 1:d5452e398b76 330 }
Just4pLeisure 1:d5452e398b76 331
Just4pLeisure 1:d5452e398b76 332 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 333 /**
Just4pLeisure 5:1775b4b13232 334 Pulls BERR pin low.
Just4pLeisure 5:1775b4b13232 335 */
Just4pLeisure 5:1775b4b13232 336 uint8_t berr_low()
Just4pLeisure 5:1775b4b13232 337 {
Just4pLeisure 5:1775b4b13232 338 PIN_BERR.write(0);
Just4pLeisure 5:1775b4b13232 339 PIN_BERR.output();
Just4pLeisure 5:1775b4b13232 340
Just4pLeisure 5:1775b4b13232 341 return TERM_OK;
Just4pLeisure 5:1775b4b13232 342 }
Just4pLeisure 5:1775b4b13232 343
Just4pLeisure 5:1775b4b13232 344 //-----------------------------------------------------------------------------
Just4pLeisure 5:1775b4b13232 345 /**
Just4pLeisure 5:1775b4b13232 346 Pulls BERR pin high.
Just4pLeisure 5:1775b4b13232 347 */
Just4pLeisure 5:1775b4b13232 348 uint8_t berr_high()
Just4pLeisure 5:1775b4b13232 349 {
Just4pLeisure 5:1775b4b13232 350 PIN_BERR.write(1);
Just4pLeisure 5:1775b4b13232 351 PIN_BERR.output();
Just4pLeisure 5:1775b4b13232 352
Just4pLeisure 5:1775b4b13232 353 return TERM_OK;
Just4pLeisure 5:1775b4b13232 354 }
Just4pLeisure 5:1775b4b13232 355
Just4pLeisure 5:1775b4b13232 356 //-----------------------------------------------------------------------------
Just4pLeisure 5:1775b4b13232 357 /**
Just4pLeisure 5:1775b4b13232 358 Makes BERR pin an input.
Just4pLeisure 5:1775b4b13232 359 */
Just4pLeisure 5:1775b4b13232 360 uint8_t berr_input()
Just4pLeisure 5:1775b4b13232 361 {
Just4pLeisure 5:1775b4b13232 362 PIN_BERR.write(1);
Just4pLeisure 5:1775b4b13232 363
Just4pLeisure 5:1775b4b13232 364 return TERM_OK;
Just4pLeisure 5:1775b4b13232 365 }
Just4pLeisure 5:1775b4b13232 366
Just4pLeisure 5:1775b4b13232 367 //-----------------------------------------------------------------------------
Just4pLeisure 5:1775b4b13232 368 /**
Just4pLeisure 1:d5452e398b76 369 Returns byte from the specified memory location; MCU must be in
Just4pLeisure 1:d5452e398b76 370 background mode.
Just4pLeisure 1:d5452e398b76 371
Just4pLeisure 1:d5452e398b76 372 @param result value (out)
Just4pLeisure 1:d5452e398b76 373 @param addr source address
Just4pLeisure 1:d5452e398b76 374
Just4pLeisure 1:d5452e398b76 375 @return status flag
Just4pLeisure 1:d5452e398b76 376 */
Just4pLeisure 5:1775b4b13232 377 uint8_t memread_byte(uint8_t* result, const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 378 {
Just4pLeisure 1:d5452e398b76 379 // check state
Just4pLeisure 1:d5452e398b76 380 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 381 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 382 }
Just4pLeisure 1:d5452e398b76 383
Just4pLeisure 1:d5452e398b76 384 // read byte
Just4pLeisure 1:d5452e398b76 385 if (!bdm_read((uint32_t*)result, BDM_READ, addr)) {
Just4pLeisure 1:d5452e398b76 386 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 387 bdm_clear();
Just4pLeisure 1:d5452e398b76 388 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 389 }
Just4pLeisure 1:d5452e398b76 390
Just4pLeisure 1:d5452e398b76 391 return TERM_OK;
Just4pLeisure 1:d5452e398b76 392 }
Just4pLeisure 1:d5452e398b76 393
Just4pLeisure 1:d5452e398b76 394 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 395 /**
Just4pLeisure 1:d5452e398b76 396 Returns word (2 bytes) from the specified memory location. Address must be
Just4pLeisure 1:d5452e398b76 397 word-aligned and MCU must be in background mode.
Just4pLeisure 1:d5452e398b76 398
Just4pLeisure 1:d5452e398b76 399 @param result value (out)
Just4pLeisure 1:d5452e398b76 400 @param addr source address
Just4pLeisure 1:d5452e398b76 401
Just4pLeisure 1:d5452e398b76 402 @return status flag
Just4pLeisure 1:d5452e398b76 403 */
Just4pLeisure 5:1775b4b13232 404 uint8_t memread_word(uint16_t* result, const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 405 {
Just4pLeisure 1:d5452e398b76 406 // check state
Just4pLeisure 1:d5452e398b76 407 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 408 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 409 }
Just4pLeisure 1:d5452e398b76 410
Just4pLeisure 1:d5452e398b76 411 // read word
Just4pLeisure 1:d5452e398b76 412 if (!bdm_read((uint32_t*)result, BDM_READ + BDM_WORDSIZE, addr)) {
Just4pLeisure 1:d5452e398b76 413 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 414 bdm_clear();
Just4pLeisure 1:d5452e398b76 415 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 416 }
Just4pLeisure 1:d5452e398b76 417
Just4pLeisure 1:d5452e398b76 418 return TERM_OK;
Just4pLeisure 1:d5452e398b76 419 }
Just4pLeisure 1:d5452e398b76 420
Just4pLeisure 1:d5452e398b76 421 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 422 /**
Just4pLeisure 1:d5452e398b76 423 Returns long word (4 bytes) from the specified memory location. Address
Just4pLeisure 1:d5452e398b76 424 must be word-aligned and target MCU must be in background mode.
Just4pLeisure 1:d5452e398b76 425
Just4pLeisure 1:d5452e398b76 426 @param result value
Just4pLeisure 1:d5452e398b76 427 @param addr source address
Just4pLeisure 1:d5452e398b76 428
Just4pLeisure 1:d5452e398b76 429 @return status flag
Just4pLeisure 1:d5452e398b76 430 */
Just4pLeisure 5:1775b4b13232 431 uint8_t memread_long(uint32_t* result, const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 432 {
Just4pLeisure 1:d5452e398b76 433 // check state
Just4pLeisure 1:d5452e398b76 434 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 435 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 436 }
Just4pLeisure 1:d5452e398b76 437
Just4pLeisure 1:d5452e398b76 438 // read long word
Just4pLeisure 1:d5452e398b76 439 if (!bdm_read(result, BDM_READ + BDM_LONGSIZE, addr)) {
Just4pLeisure 1:d5452e398b76 440 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 441 bdm_clear();
Just4pLeisure 1:d5452e398b76 442 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 443 }
Just4pLeisure 1:d5452e398b76 444
Just4pLeisure 1:d5452e398b76 445 return TERM_OK;
Just4pLeisure 1:d5452e398b76 446 }
Just4pLeisure 1:d5452e398b76 447
Just4pLeisure 1:d5452e398b76 448 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 449 /**
Just4pLeisure 1:d5452e398b76 450 Dumps byte from the specified memory location; MCU must be in background
Just4pLeisure 1:d5452e398b76 451 mode. Any memread_*() function must be called beforehand to set the
Just4pLeisure 1:d5452e398b76 452 initial address.
Just4pLeisure 1:d5452e398b76 453
Just4pLeisure 1:d5452e398b76 454 @param value result (out)
Just4pLeisure 1:d5452e398b76 455
Just4pLeisure 1:d5452e398b76 456 @return status flag
Just4pLeisure 1:d5452e398b76 457 */
Just4pLeisure 5:1775b4b13232 458 uint8_t memdump_byte(uint8_t* result)
Just4pLeisure 5:1775b4b13232 459 {
Just4pLeisure 1:d5452e398b76 460 // check state
Just4pLeisure 1:d5452e398b76 461 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 462 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 463 }
Just4pLeisure 1:d5452e398b76 464
Just4pLeisure 1:d5452e398b76 465 // dump byte
Just4pLeisure 1:d5452e398b76 466 if (!bdm_read((uint32_t*)result, BDM_DUMP, NULL)) {
Just4pLeisure 1:d5452e398b76 467 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 468 bdm_clear();
Just4pLeisure 1:d5452e398b76 469 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 470 }
Just4pLeisure 1:d5452e398b76 471
Just4pLeisure 1:d5452e398b76 472 return TERM_OK;
Just4pLeisure 1:d5452e398b76 473 }
Just4pLeisure 1:d5452e398b76 474
Just4pLeisure 1:d5452e398b76 475 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 476 /**
Just4pLeisure 1:d5452e398b76 477 dumps word from the specified memory location; MCU must be in background
Just4pLeisure 1:d5452e398b76 478 mode. Any memread_*() function must be called beforehand to set the
Just4pLeisure 1:d5452e398b76 479 initial address.
Just4pLeisure 1:d5452e398b76 480
Just4pLeisure 1:d5452e398b76 481 @param value result (out)
Just4pLeisure 1:d5452e398b76 482
Just4pLeisure 1:d5452e398b76 483 @return status flag
Just4pLeisure 1:d5452e398b76 484 */
Just4pLeisure 5:1775b4b13232 485 uint8_t memdump_word(uint16_t* result)
Just4pLeisure 5:1775b4b13232 486 {
Just4pLeisure 1:d5452e398b76 487 // check state
Just4pLeisure 1:d5452e398b76 488 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 489 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 490 }
Just4pLeisure 1:d5452e398b76 491
Just4pLeisure 1:d5452e398b76 492 // dump word
Just4pLeisure 1:d5452e398b76 493 if (!bdm_read((uint32_t*)result, BDM_DUMP + BDM_WORDSIZE, NULL)) {
Just4pLeisure 1:d5452e398b76 494 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 495 bdm_clear();
Just4pLeisure 1:d5452e398b76 496 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 497 }
Just4pLeisure 1:d5452e398b76 498
Just4pLeisure 1:d5452e398b76 499 return TERM_OK;
Just4pLeisure 1:d5452e398b76 500 }
Just4pLeisure 1:d5452e398b76 501
Just4pLeisure 1:d5452e398b76 502 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 503 /**
Just4pLeisure 1:d5452e398b76 504 Dumps long word from the specified memory location; MCU must be in
Just4pLeisure 1:d5452e398b76 505 background mode. Any memread_*() function must be called beforehand to set
Just4pLeisure 1:d5452e398b76 506 the initial address.
Just4pLeisure 1:d5452e398b76 507
Just4pLeisure 1:d5452e398b76 508 @param value result (out)
Just4pLeisure 1:d5452e398b76 509
Just4pLeisure 1:d5452e398b76 510 @return status flag
Just4pLeisure 1:d5452e398b76 511 */
Just4pLeisure 5:1775b4b13232 512 uint8_t memdump_long(uint32_t* result)
Just4pLeisure 5:1775b4b13232 513 {
Just4pLeisure 1:d5452e398b76 514 // check state
Just4pLeisure 1:d5452e398b76 515 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 516 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 517 }
Just4pLeisure 1:d5452e398b76 518
Just4pLeisure 1:d5452e398b76 519 // dump long word
Just4pLeisure 1:d5452e398b76 520 if (!bdm_read(result, BDM_DUMP + BDM_LONGSIZE, NULL)) {
Just4pLeisure 1:d5452e398b76 521 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 522 bdm_clear();
Just4pLeisure 1:d5452e398b76 523 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 524 }
Just4pLeisure 1:d5452e398b76 525
Just4pLeisure 1:d5452e398b76 526 return TERM_OK;
Just4pLeisure 1:d5452e398b76 527 }
Just4pLeisure 1:d5452e398b76 528
Just4pLeisure 1:d5452e398b76 529 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 530 /**
Just4pLeisure 1:d5452e398b76 531 Writes byte to the specified memory location; MCU must be in background
Just4pLeisure 1:d5452e398b76 532 mode.
Just4pLeisure 1:d5452e398b76 533
Just4pLeisure 1:d5452e398b76 534 @param addr destination address
Just4pLeisure 1:d5452e398b76 535 @param value value
Just4pLeisure 1:d5452e398b76 536
Just4pLeisure 1:d5452e398b76 537 @return status flag
Just4pLeisure 1:d5452e398b76 538 */
Just4pLeisure 5:1775b4b13232 539 uint8_t memwrite_byte(const uint32_t* addr, uint8_t value)
Just4pLeisure 5:1775b4b13232 540 {
Just4pLeisure 1:d5452e398b76 541 // check state
Just4pLeisure 1:d5452e398b76 542 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 543 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 544 }
Just4pLeisure 1:d5452e398b76 545
Just4pLeisure 1:d5452e398b76 546 // write byte
Just4pLeisure 1:d5452e398b76 547 if (!bdm_write(addr, BDM_WRITE, (uint32_t*)&value)) {
Just4pLeisure 1:d5452e398b76 548 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 549 bdm_clear();
Just4pLeisure 1:d5452e398b76 550 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 551 }
Just4pLeisure 1:d5452e398b76 552
Just4pLeisure 1:d5452e398b76 553 return TERM_OK;
Just4pLeisure 1:d5452e398b76 554 }
Just4pLeisure 1:d5452e398b76 555
Just4pLeisure 1:d5452e398b76 556 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 557 /**
Just4pLeisure 1:d5452e398b76 558 Writes word to the specified memory location. Address must be word-aligned
Just4pLeisure 1:d5452e398b76 559 and MCU must be in background mode.
Just4pLeisure 1:d5452e398b76 560
Just4pLeisure 1:d5452e398b76 561 @param addr memory address
Just4pLeisure 1:d5452e398b76 562 @param value value
Just4pLeisure 1:d5452e398b76 563
Just4pLeisure 1:d5452e398b76 564 @return status flag
Just4pLeisure 1:d5452e398b76 565 */
Just4pLeisure 5:1775b4b13232 566 uint8_t memwrite_word(const uint32_t* addr, uint16_t value)
Just4pLeisure 5:1775b4b13232 567 {
Just4pLeisure 1:d5452e398b76 568 // check state
Just4pLeisure 1:d5452e398b76 569 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 570 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 571 }
Just4pLeisure 1:d5452e398b76 572
Just4pLeisure 1:d5452e398b76 573 // write word
Just4pLeisure 1:d5452e398b76 574 if (!bdm_write(addr, BDM_WRITE + BDM_WORDSIZE, (uint32_t*)&value)) {
Just4pLeisure 1:d5452e398b76 575 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 576 bdm_clear();
Just4pLeisure 1:d5452e398b76 577 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 578 }
Just4pLeisure 1:d5452e398b76 579
Just4pLeisure 1:d5452e398b76 580 return TERM_OK;
Just4pLeisure 1:d5452e398b76 581 }
Just4pLeisure 1:d5452e398b76 582
Just4pLeisure 1:d5452e398b76 583 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 584 /**
Just4pLeisure 1:d5452e398b76 585 Writes long word to the specified memory location. Address must be
Just4pLeisure 1:d5452e398b76 586 word-aligned and target MCU must be in background mode.
Just4pLeisure 1:d5452e398b76 587
Just4pLeisure 1:d5452e398b76 588 @param addr memory address
Just4pLeisure 1:d5452e398b76 589 @param value value
Just4pLeisure 1:d5452e398b76 590
Just4pLeisure 1:d5452e398b76 591 @return status flag
Just4pLeisure 1:d5452e398b76 592 */
Just4pLeisure 5:1775b4b13232 593 uint8_t memwrite_long(const uint32_t* addr, const uint32_t* value)
Just4pLeisure 5:1775b4b13232 594 {
Just4pLeisure 1:d5452e398b76 595 // check state
Just4pLeisure 1:d5452e398b76 596 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 597 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 598 }
Just4pLeisure 1:d5452e398b76 599
Just4pLeisure 1:d5452e398b76 600 // write long word
Just4pLeisure 1:d5452e398b76 601 if (!bdm_write(addr, BDM_WRITE + BDM_LONGSIZE, value)) {
Just4pLeisure 1:d5452e398b76 602 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 603 bdm_clear();
Just4pLeisure 1:d5452e398b76 604 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 605 }
Just4pLeisure 1:d5452e398b76 606
Just4pLeisure 1:d5452e398b76 607 return TERM_OK;
Just4pLeisure 1:d5452e398b76 608 }
Just4pLeisure 1:d5452e398b76 609
Just4pLeisure 1:d5452e398b76 610 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 611 /**
Just4pLeisure 1:d5452e398b76 612 Writes byte to the current memory location; MCU must be in background
Just4pLeisure 1:d5452e398b76 613 mode. Any memwrite_*() function must be called beforehand to set the
Just4pLeisure 1:d5452e398b76 614 current address.
Just4pLeisure 1:d5452e398b76 615
Just4pLeisure 1:d5452e398b76 616 @param value value
Just4pLeisure 1:d5452e398b76 617
Just4pLeisure 1:d5452e398b76 618 @return status flag
Just4pLeisure 1:d5452e398b76 619 */
Just4pLeisure 5:1775b4b13232 620 uint8_t memfill_byte(uint8_t value)
Just4pLeisure 5:1775b4b13232 621 {
Just4pLeisure 1:d5452e398b76 622 // check state
Just4pLeisure 1:d5452e398b76 623 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 624 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 625 }
Just4pLeisure 1:d5452e398b76 626
Just4pLeisure 1:d5452e398b76 627 // fill byte
Just4pLeisure 1:d5452e398b76 628 if (!bdm_write(NULL, BDM_FILL, (uint32_t*)&value)) {
Just4pLeisure 1:d5452e398b76 629 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 630 bdm_clear();
Just4pLeisure 1:d5452e398b76 631 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 632 }
Just4pLeisure 1:d5452e398b76 633
Just4pLeisure 1:d5452e398b76 634 return TERM_OK;
Just4pLeisure 1:d5452e398b76 635 }
Just4pLeisure 1:d5452e398b76 636
Just4pLeisure 1:d5452e398b76 637 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 638 /**
Just4pLeisure 1:d5452e398b76 639 Writes word to the specified memory location; MCU must be in background
Just4pLeisure 1:d5452e398b76 640 mode. Any memwrite_*() function must be called beforehand to set the
Just4pLeisure 1:d5452e398b76 641 initial address.
Just4pLeisure 1:d5452e398b76 642
Just4pLeisure 1:d5452e398b76 643 @param value value
Just4pLeisure 1:d5452e398b76 644
Just4pLeisure 1:d5452e398b76 645 @return status flag
Just4pLeisure 1:d5452e398b76 646 */
Just4pLeisure 5:1775b4b13232 647 uint8_t memfill_word(uint16_t value)
Just4pLeisure 5:1775b4b13232 648 {
Just4pLeisure 1:d5452e398b76 649 // check state
Just4pLeisure 1:d5452e398b76 650 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 651 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 652 }
Just4pLeisure 1:d5452e398b76 653
Just4pLeisure 1:d5452e398b76 654 // fill word
Just4pLeisure 1:d5452e398b76 655 if (!IN_BDM || !bdm_write(NULL, BDM_FILL + BDM_WORDSIZE, (uint32_t*)&value)) {
Just4pLeisure 1:d5452e398b76 656 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 657 bdm_clear();
Just4pLeisure 1:d5452e398b76 658 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 659 }
Just4pLeisure 1:d5452e398b76 660
Just4pLeisure 1:d5452e398b76 661 return TERM_OK;
Just4pLeisure 1:d5452e398b76 662 }
Just4pLeisure 1:d5452e398b76 663
Just4pLeisure 1:d5452e398b76 664 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 665 /**
Just4pLeisure 1:d5452e398b76 666 Writes long word to the specified memory location; MCU must be in background
Just4pLeisure 1:d5452e398b76 667 mode. Any memwrite_*() function must be called beforehand to set the
Just4pLeisure 1:d5452e398b76 668 initial address.
Just4pLeisure 1:d5452e398b76 669
Just4pLeisure 1:d5452e398b76 670 @param value value
Just4pLeisure 1:d5452e398b76 671
Just4pLeisure 1:d5452e398b76 672 @return status flag
Just4pLeisure 1:d5452e398b76 673 */
Just4pLeisure 5:1775b4b13232 674 uint8_t memfill_long(const uint32_t* value)
Just4pLeisure 5:1775b4b13232 675 {
Just4pLeisure 1:d5452e398b76 676 // check state
Just4pLeisure 1:d5452e398b76 677 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 678 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 679 }
Just4pLeisure 1:d5452e398b76 680
Just4pLeisure 1:d5452e398b76 681 // fill long word
Just4pLeisure 1:d5452e398b76 682 if (!bdm_write(NULL, BDM_FILL + BDM_LONGSIZE, value)) {
Just4pLeisure 1:d5452e398b76 683 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 684 bdm_clear();
Just4pLeisure 1:d5452e398b76 685 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 686 }
Just4pLeisure 1:d5452e398b76 687
Just4pLeisure 1:d5452e398b76 688 return TERM_OK;
Just4pLeisure 1:d5452e398b76 689 }
Just4pLeisure 1:d5452e398b76 690
Just4pLeisure 1:d5452e398b76 691 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 692 /**
Just4pLeisure 1:d5452e398b76 693 Issues a read byte command to MCU.
Just4pLeisure 1:d5452e398b76 694
Just4pLeisure 1:d5452e398b76 695 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 696
Just4pLeisure 1:d5452e398b76 697 @return status flag
Just4pLeisure 1:d5452e398b76 698 */
Just4pLeisure 5:1775b4b13232 699 uint8_t memread_byte_cmd(const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 700 {
Just4pLeisure 1:d5452e398b76 701
Just4pLeisure 1:d5452e398b76 702 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 703
Just4pLeisure 1:d5452e398b76 704 // write command code
Just4pLeisure 1:d5452e398b76 705 if (!bdm_command(BDM_READ + BDM_BYTESIZE)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 706 // write the optional address
Just4pLeisure 1:d5452e398b76 707 if (addr) {
Just4pLeisure 2:bf3a2b29259a 708 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 709 }
Just4pLeisure 1:d5452e398b76 710
Just4pLeisure 1:d5452e398b76 711 return TERM_OK;
Just4pLeisure 1:d5452e398b76 712 }
Just4pLeisure 1:d5452e398b76 713
Just4pLeisure 1:d5452e398b76 714 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 715 /**
Just4pLeisure 1:d5452e398b76 716 Issues a read word command to MCU.
Just4pLeisure 1:d5452e398b76 717
Just4pLeisure 1:d5452e398b76 718 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 719
Just4pLeisure 1:d5452e398b76 720 @return status flag
Just4pLeisure 1:d5452e398b76 721 */
Just4pLeisure 5:1775b4b13232 722 uint8_t memread_word_cmd(const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 723 {
Just4pLeisure 1:d5452e398b76 724
Just4pLeisure 1:d5452e398b76 725 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 726
Just4pLeisure 1:d5452e398b76 727 // write command code
Just4pLeisure 1:d5452e398b76 728 bdm_clk(BDM_READ + BDM_WORDSIZE, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 729 if (bdm_response > BDM_CMDCMPLTE) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 730 // write the optional address
Just4pLeisure 1:d5452e398b76 731 if (addr) {
Just4pLeisure 2:bf3a2b29259a 732 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 733 }
Just4pLeisure 1:d5452e398b76 734
Just4pLeisure 1:d5452e398b76 735 return TERM_OK;
Just4pLeisure 1:d5452e398b76 736 }
Just4pLeisure 1:d5452e398b76 737
Just4pLeisure 1:d5452e398b76 738 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 739 /**
Just4pLeisure 1:d5452e398b76 740 Issues a read long command to MCU.
Just4pLeisure 1:d5452e398b76 741
Just4pLeisure 1:d5452e398b76 742 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 743
Just4pLeisure 1:d5452e398b76 744 @return status flag
Just4pLeisure 1:d5452e398b76 745 */
Just4pLeisure 5:1775b4b13232 746 uint8_t memread_long_cmd(const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 747 {
Just4pLeisure 1:d5452e398b76 748
Just4pLeisure 1:d5452e398b76 749 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 750
Just4pLeisure 1:d5452e398b76 751 // write command code
Just4pLeisure 1:d5452e398b76 752 bdm_clk(BDM_READ + BDM_LONGSIZE, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 753 if (bdm_response > BDM_CMDCMPLTE) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 754 // write the optional address
Just4pLeisure 1:d5452e398b76 755 if (addr) {
Just4pLeisure 2:bf3a2b29259a 756 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 757 }
Just4pLeisure 1:d5452e398b76 758
Just4pLeisure 1:d5452e398b76 759 return TERM_OK;
Just4pLeisure 1:d5452e398b76 760 }
Just4pLeisure 1:d5452e398b76 761 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 762 /**
Just4pLeisure 1:d5452e398b76 763 Issues a write byte command to MCU.
Just4pLeisure 1:d5452e398b76 764
Just4pLeisure 1:d5452e398b76 765 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 766
Just4pLeisure 1:d5452e398b76 767 @return status flag
Just4pLeisure 1:d5452e398b76 768 */
Just4pLeisure 5:1775b4b13232 769 uint8_t memwrite_byte_cmd(const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 770 {
Just4pLeisure 1:d5452e398b76 771
Just4pLeisure 1:d5452e398b76 772 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 2:bf3a2b29259a 773
Just4pLeisure 1:d5452e398b76 774 // write command code
Just4pLeisure 1:d5452e398b76 775 if (!bdm_command(BDM_WRITE + BDM_BYTESIZE)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 776 // write the optional address
Just4pLeisure 1:d5452e398b76 777 if (addr) {
Just4pLeisure 2:bf3a2b29259a 778 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 779 }
Just4pLeisure 1:d5452e398b76 780
Just4pLeisure 1:d5452e398b76 781 return TERM_OK;
Just4pLeisure 1:d5452e398b76 782 }
Just4pLeisure 1:d5452e398b76 783
Just4pLeisure 1:d5452e398b76 784 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 785 /**
Just4pLeisure 1:d5452e398b76 786 Issues a write word command to MCU.
Just4pLeisure 1:d5452e398b76 787
Just4pLeisure 1:d5452e398b76 788 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 789
Just4pLeisure 1:d5452e398b76 790 @return status flag
Just4pLeisure 1:d5452e398b76 791 */
Just4pLeisure 5:1775b4b13232 792 uint8_t memwrite_word_cmd(const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 793 {
Just4pLeisure 1:d5452e398b76 794
Just4pLeisure 1:d5452e398b76 795 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 796
Just4pLeisure 1:d5452e398b76 797 // write command code
Just4pLeisure 1:d5452e398b76 798 bdm_clk(BDM_WRITE + BDM_WORDSIZE, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 799 if (bdm_response > BDM_CMDCMPLTE) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 800 // write the optional address
Just4pLeisure 1:d5452e398b76 801 if (addr) {
Just4pLeisure 2:bf3a2b29259a 802 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 803 }
Just4pLeisure 1:d5452e398b76 804
Just4pLeisure 1:d5452e398b76 805 return TERM_OK;
Just4pLeisure 1:d5452e398b76 806 }
Just4pLeisure 1:d5452e398b76 807
Just4pLeisure 1:d5452e398b76 808 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 809 /**
Just4pLeisure 1:d5452e398b76 810 Issues a write long command to MCU.
Just4pLeisure 1:d5452e398b76 811
Just4pLeisure 1:d5452e398b76 812 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 813
Just4pLeisure 1:d5452e398b76 814 @return status flag
Just4pLeisure 1:d5452e398b76 815 */
Just4pLeisure 5:1775b4b13232 816 uint8_t memwrite_long_cmd(const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 817 {
Just4pLeisure 1:d5452e398b76 818
Just4pLeisure 1:d5452e398b76 819 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 820
Just4pLeisure 1:d5452e398b76 821 // write command code
Just4pLeisure 1:d5452e398b76 822 bdm_clk(BDM_WRITE + BDM_LONGSIZE, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 823 if (bdm_response > BDM_CMDCMPLTE) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 824 // write the optional address
Just4pLeisure 1:d5452e398b76 825 if (addr) {
Just4pLeisure 2:bf3a2b29259a 826 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 827 }
Just4pLeisure 1:d5452e398b76 828
Just4pLeisure 1:d5452e398b76 829 return TERM_OK;
Just4pLeisure 1:d5452e398b76 830 }
Just4pLeisure 1:d5452e398b76 831
Just4pLeisure 1:d5452e398b76 832 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 833 /**
Just4pLeisure 1:d5452e398b76 834 Gets a byte from the MCU (follows a previously sent read or dump word cmd)
Just4pLeisure 1:d5452e398b76 835 Sends a READ_BYTE command so that commands overlap
Just4pLeisure 1:d5452e398b76 836
Just4pLeisure 1:d5452e398b76 837 @param result read result (out)
Just4pLeisure 1:d5452e398b76 838 addr address (optional)
Just4pLeisure 1:d5452e398b76 839
Just4pLeisure 1:d5452e398b76 840 @return status flag
Just4pLeisure 1:d5452e398b76 841 */
Just4pLeisure 5:1775b4b13232 842 uint8_t memread_read_byte(uint8_t* result, const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 843 {
Just4pLeisure 1:d5452e398b76 844
Just4pLeisure 1:d5452e398b76 845 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 846 // write the optional address
Just4pLeisure 1:d5452e398b76 847 if (addr) {
Just4pLeisure 2:bf3a2b29259a 848 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 849 }
Just4pLeisure 1:d5452e398b76 850 // receive the response byte
Just4pLeisure 1:d5452e398b76 851 return (bdm_get ((uint32_t*)result, BDM_BYTESIZE, BDM_READ + BDM_BYTESIZE)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 852 }
Just4pLeisure 1:d5452e398b76 853
Just4pLeisure 1:d5452e398b76 854 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 855 /**
Just4pLeisure 1:d5452e398b76 856 Gets a byte from the MCU (follows a previously sent read or dump word cmd)
Just4pLeisure 1:d5452e398b76 857 Sends a WRITE_BYTE command so that commands overlap
Just4pLeisure 1:d5452e398b76 858
Just4pLeisure 1:d5452e398b76 859 @param result read result (out)
Just4pLeisure 1:d5452e398b76 860 addr address (optional)
Just4pLeisure 1:d5452e398b76 861
Just4pLeisure 1:d5452e398b76 862 @return status flag
Just4pLeisure 1:d5452e398b76 863 */
Just4pLeisure 5:1775b4b13232 864 uint8_t memread_write_byte(uint8_t* result, const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 865 {
Just4pLeisure 1:d5452e398b76 866
Just4pLeisure 1:d5452e398b76 867 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 868 // write the optional address
Just4pLeisure 1:d5452e398b76 869 if (addr) {
Just4pLeisure 2:bf3a2b29259a 870 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 871 }
Just4pLeisure 1:d5452e398b76 872 // receive the response byte
Just4pLeisure 1:d5452e398b76 873 return (bdm_get((uint32_t*)result, BDM_BYTESIZE, BDM_WRITE + BDM_BYTESIZE)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 874 }
Just4pLeisure 1:d5452e398b76 875
Just4pLeisure 1:d5452e398b76 876 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 877 /**
Just4pLeisure 1:d5452e398b76 878 Gets a byte from the MCU (follows a previously sent read or dump word cmd)
Just4pLeisure 1:d5452e398b76 879 Sends a BDM_NOP command to end a sequence of overlapping commands
Just4pLeisure 1:d5452e398b76 880
Just4pLeisure 1:d5452e398b76 881 @param result read result (out)
Just4pLeisure 1:d5452e398b76 882 addr address (optional)
Just4pLeisure 1:d5452e398b76 883
Just4pLeisure 1:d5452e398b76 884 @return status flag
Just4pLeisure 1:d5452e398b76 885 */
Just4pLeisure 5:1775b4b13232 886 uint8_t memread_nop_byte(uint8_t* result, const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 887 {
Just4pLeisure 1:d5452e398b76 888
Just4pLeisure 1:d5452e398b76 889 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 890 // write the optional address
Just4pLeisure 1:d5452e398b76 891 if (addr) {
Just4pLeisure 2:bf3a2b29259a 892 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 893 }
Just4pLeisure 1:d5452e398b76 894 // receive the response byte
Just4pLeisure 1:d5452e398b76 895 return (bdm_get((uint32_t*)result, BDM_BYTESIZE, BDM_NOP)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 896 }
Just4pLeisure 1:d5452e398b76 897
Just4pLeisure 1:d5452e398b76 898 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 899 /**
Just4pLeisure 1:d5452e398b76 900 Writes a byte to the MCU (follows a previously sent write or fill word cmd)
Just4pLeisure 1:d5452e398b76 901 Sends a WRITE_BYTE command so that commands overlap
Just4pLeisure 1:d5452e398b76 902
Just4pLeisure 1:d5452e398b76 903 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 904 value value to write
Just4pLeisure 1:d5452e398b76 905
Just4pLeisure 1:d5452e398b76 906 @return status flag
Just4pLeisure 1:d5452e398b76 907 */
Just4pLeisure 5:1775b4b13232 908 uint8_t memwrite_write_byte(const uint32_t* addr, uint8_t value)
Just4pLeisure 5:1775b4b13232 909 {
Just4pLeisure 1:d5452e398b76 910
Just4pLeisure 1:d5452e398b76 911 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 912 // write the optional address
Just4pLeisure 1:d5452e398b76 913 if (addr) {
Just4pLeisure 2:bf3a2b29259a 914 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 915 }
Just4pLeisure 1:d5452e398b76 916 // write the value
Just4pLeisure 1:d5452e398b76 917 if (!bdm_put((uint32_t*)&value, BDM_BYTESIZE)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 918 // wait until MCU responds
Just4pLeisure 1:d5452e398b76 919 return (bdm_ready(BDM_WRITE + BDM_BYTESIZE)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 920 }
Just4pLeisure 1:d5452e398b76 921
Just4pLeisure 1:d5452e398b76 922 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 923 /**
Just4pLeisure 1:d5452e398b76 924 Writes a byte to the MCU (follows a previously sent write or fill word cmd)
Just4pLeisure 1:d5452e398b76 925 Sends a READ_BYTE command so that commands overlap
Just4pLeisure 1:d5452e398b76 926
Just4pLeisure 1:d5452e398b76 927 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 928 value value to write
Just4pLeisure 1:d5452e398b76 929
Just4pLeisure 1:d5452e398b76 930 @return status flag
Just4pLeisure 1:d5452e398b76 931 */
Just4pLeisure 5:1775b4b13232 932 uint8_t memwrite_read_byte(const uint32_t* addr, uint8_t value)
Just4pLeisure 5:1775b4b13232 933 {
Just4pLeisure 1:d5452e398b76 934
Just4pLeisure 1:d5452e398b76 935 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 936 // write the optional address
Just4pLeisure 1:d5452e398b76 937 if (addr) {
Just4pLeisure 2:bf3a2b29259a 938 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 939 }
Just4pLeisure 1:d5452e398b76 940 // write the value
Just4pLeisure 1:d5452e398b76 941 if (!bdm_put((uint32_t*)&value, BDM_BYTESIZE)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 942 // wait until MCU responds
Just4pLeisure 1:d5452e398b76 943 return (bdm_ready(BDM_READ + BDM_BYTESIZE)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 944 }
Just4pLeisure 1:d5452e398b76 945
Just4pLeisure 1:d5452e398b76 946 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 947 /**
Just4pLeisure 1:d5452e398b76 948 Writes a byte to the MCU (follows a previously sent write or fill word cmd)
Just4pLeisure 1:d5452e398b76 949 Sends a BDM_NOP command to end a sequence of overlapping commands
Just4pLeisure 1:d5452e398b76 950
Just4pLeisure 1:d5452e398b76 951 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 952 value value to write
Just4pLeisure 1:d5452e398b76 953
Just4pLeisure 1:d5452e398b76 954 @return status flag
Just4pLeisure 1:d5452e398b76 955 */
Just4pLeisure 5:1775b4b13232 956 uint8_t memwrite_nop_byte(const uint32_t* addr, uint8_t value)
Just4pLeisure 5:1775b4b13232 957 {
Just4pLeisure 1:d5452e398b76 958
Just4pLeisure 1:d5452e398b76 959 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 960 // write the optional address
Just4pLeisure 1:d5452e398b76 961 if (addr) {
Just4pLeisure 2:bf3a2b29259a 962 if (!bdm_address(addr)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 963 }
Just4pLeisure 1:d5452e398b76 964 // write the value
Just4pLeisure 1:d5452e398b76 965 if (!bdm_put((uint32_t*)&value, BDM_BYTESIZE)) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 966 // wait until MCU responds
Just4pLeisure 1:d5452e398b76 967 return (bdm_ready(BDM_NOP)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 968 }
Just4pLeisure 1:d5452e398b76 969
Just4pLeisure 1:d5452e398b76 970
Just4pLeisure 1:d5452e398b76 971 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 972 /**
Just4pLeisure 1:d5452e398b76 973 Writes 2 words to the same address
Just4pLeisure 1:d5452e398b76 974 The BDM commands are overlapped to make things a bit faster
Just4pLeisure 1:d5452e398b76 975 A BDM_NOP command is then sent to end the sequence of overlapping commands
Just4pLeisure 2:bf3a2b29259a 976
Just4pLeisure 1:d5452e398b76 977 @param addr address
Just4pLeisure 1:d5452e398b76 978 value1, 2 values to write
Just4pLeisure 1:d5452e398b76 979
Just4pLeisure 1:d5452e398b76 980 @return status flag
Just4pLeisure 1:d5452e398b76 981 */
Just4pLeisure 5:1775b4b13232 982 uint8_t memwrite_word_write_word(const uint32_t* addr, const uint16_t value1, const uint16_t value2)
Just4pLeisure 5:1775b4b13232 983 {
Just4pLeisure 2:bf3a2b29259a 984 return (IN_BDM &&
Just4pLeisure 5:1775b4b13232 985 bdm_command(BDM_WRITE + BDM_WORDSIZE) && // write command code
Just4pLeisure 5:1775b4b13232 986 bdm_address(addr) && // write the address
Just4pLeisure 5:1775b4b13232 987 bdm_put((uint32_t*)&value1, BDM_WORDSIZE) && // write the first value
Just4pLeisure 5:1775b4b13232 988 bdm_ready(BDM_WRITE + BDM_WORDSIZE) && // wait until MCU responds and overlap the next write command
Just4pLeisure 5:1775b4b13232 989 bdm_address(addr) && // write the address (same address for second word)
Just4pLeisure 5:1775b4b13232 990 bdm_put((uint32_t*)&value2, BDM_WORDSIZE) && // write the second value
Just4pLeisure 5:1775b4b13232 991 bdm_ready(BDM_NOP)) ? TERM_OK : TERM_ERR; // wait until MCU responds
Just4pLeisure 1:d5452e398b76 992 }
Just4pLeisure 1:d5452e398b76 993
Just4pLeisure 1:d5452e398b76 994 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 995 /**
Just4pLeisure 1:d5452e398b76 996 Writes a word then reads back a result from the same address
Just4pLeisure 1:d5452e398b76 997 The BDM commands are overlapped to make things a bit faster
Just4pLeisure 1:d5452e398b76 998 A BDM_NOP command is then sent to end the sequence of overlapping commands
Just4pLeisure 1:d5452e398b76 999
Just4pLeisure 1:d5452e398b76 1000 @param result read result (out)
Just4pLeisure 1:d5452e398b76 1001 addr address
Just4pLeisure 1:d5452e398b76 1002 value value to write
Just4pLeisure 1:d5452e398b76 1003
Just4pLeisure 1:d5452e398b76 1004 @return status flag
Just4pLeisure 1:d5452e398b76 1005 */
Just4pLeisure 1:d5452e398b76 1006
Just4pLeisure 5:1775b4b13232 1007 uint8_t memwrite_word_read_word(uint16_t* result, const uint32_t* addr, const uint16_t value)
Just4pLeisure 5:1775b4b13232 1008 {
Just4pLeisure 2:bf3a2b29259a 1009 return (IN_BDM &&
Just4pLeisure 5:1775b4b13232 1010 bdm_command(BDM_WRITE + BDM_WORDSIZE) && // write command code
Just4pLeisure 5:1775b4b13232 1011 bdm_address(addr) && // write the address
Just4pLeisure 5:1775b4b13232 1012 bdm_put((uint32_t*)&value, BDM_WORDSIZE) && // write the value
Just4pLeisure 5:1775b4b13232 1013 bdm_ready(BDM_READ + BDM_WORDSIZE) && // wait until MCU responds and overlap the next read command
Just4pLeisure 5:1775b4b13232 1014 bdm_address(addr) && // write the address (same address for reading the result)
Just4pLeisure 5:1775b4b13232 1015 bdm_get((uint32_t*)result, BDM_WORDSIZE, BDM_NOP)) ? TERM_OK : TERM_ERR; // receive the response word
Just4pLeisure 1:d5452e398b76 1016 }
Just4pLeisure 1:d5452e398b76 1017
Just4pLeisure 1:d5452e398b76 1018 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1019 /**
Just4pLeisure 1:d5452e398b76 1020 Gets a word from the MCU (follows a previously sent read or dump word cmd)
Just4pLeisure 1:d5452e398b76 1021 Sends a DUMP_WORD command so that dump commands overlap
Just4pLeisure 1:d5452e398b76 1022
Just4pLeisure 1:d5452e398b76 1023 @param result read result (out)
Just4pLeisure 1:d5452e398b76 1024
Just4pLeisure 1:d5452e398b76 1025 @return status flag
Just4pLeisure 1:d5452e398b76 1026 */
Just4pLeisure 5:1775b4b13232 1027 uint8_t memget_word(uint16_t* result)
Just4pLeisure 5:1775b4b13232 1028 {
Just4pLeisure 1:d5452e398b76 1029
Just4pLeisure 1:d5452e398b76 1030 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1031 // receive the response word
Just4pLeisure 1:d5452e398b76 1032 return (bdm_get((uint32_t*)result, BDM_WORDSIZE, BDM_DUMP + BDM_WORDSIZE)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 1033 }
Just4pLeisure 1:d5452e398b76 1034
Just4pLeisure 1:d5452e398b76 1035 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1036 /**
Just4pLeisure 1:d5452e398b76 1037 Gets a long from the MCU (follows a previously sent read or dump long cmd)
Just4pLeisure 1:d5452e398b76 1038 Sends a DUMP_LONG command so that dump commands overlap
Just4pLeisure 1:d5452e398b76 1039
Just4pLeisure 1:d5452e398b76 1040 @param result read result (out)
Just4pLeisure 1:d5452e398b76 1041
Just4pLeisure 1:d5452e398b76 1042 @return status flag
Just4pLeisure 1:d5452e398b76 1043 */
Just4pLeisure 5:1775b4b13232 1044 uint8_t memget_long(uint32_t* result)
Just4pLeisure 5:1775b4b13232 1045 {
Just4pLeisure 1:d5452e398b76 1046
Just4pLeisure 1:d5452e398b76 1047 if (!IN_BDM) return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1048 // receive the response words
Just4pLeisure 1:d5452e398b76 1049 return (bdm_get(result, BDM_LONGSIZE, BDM_DUMP + BDM_LONGSIZE)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 1050 }
Just4pLeisure 1:d5452e398b76 1051
Just4pLeisure 1:d5452e398b76 1052 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1053 /**
Just4pLeisure 1:d5452e398b76 1054 Reads value from system register.
Just4pLeisure 1:d5452e398b76 1055
Just4pLeisure 1:d5452e398b76 1056 @param result register value (out)
Just4pLeisure 1:d5452e398b76 1057 @param reg register
Just4pLeisure 1:d5452e398b76 1058
Just4pLeisure 1:d5452e398b76 1059 @return status flag
Just4pLeisure 1:d5452e398b76 1060 */
Just4pLeisure 5:1775b4b13232 1061 uint8_t sysreg_read(uint32_t* result, uint8_t reg)
Just4pLeisure 5:1775b4b13232 1062 {
Just4pLeisure 1:d5452e398b76 1063 // check state
Just4pLeisure 1:d5452e398b76 1064 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 1065 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1066 }
Just4pLeisure 1:d5452e398b76 1067
Just4pLeisure 1:d5452e398b76 1068 // read register
Just4pLeisure 1:d5452e398b76 1069 if (!bdm_read(result, BDM_RSREG + reg, NULL)) {
Just4pLeisure 1:d5452e398b76 1070 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 1071 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1072 }
Just4pLeisure 1:d5452e398b76 1073
Just4pLeisure 1:d5452e398b76 1074 return TERM_OK;
Just4pLeisure 1:d5452e398b76 1075 }
Just4pLeisure 1:d5452e398b76 1076
Just4pLeisure 1:d5452e398b76 1077 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1078 /**
Just4pLeisure 1:d5452e398b76 1079 Writes value to system register.
Just4pLeisure 1:d5452e398b76 1080
Just4pLeisure 1:d5452e398b76 1081 @param reg register
Just4pLeisure 1:d5452e398b76 1082 @param value register value
Just4pLeisure 1:d5452e398b76 1083
Just4pLeisure 1:d5452e398b76 1084 @return status flag
Just4pLeisure 1:d5452e398b76 1085 */
Just4pLeisure 5:1775b4b13232 1086 uint8_t sysreg_write(uint8_t reg, const uint32_t* value)
Just4pLeisure 5:1775b4b13232 1087 {
Just4pLeisure 1:d5452e398b76 1088 // check state
Just4pLeisure 1:d5452e398b76 1089 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 1090 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1091 }
Just4pLeisure 1:d5452e398b76 1092
Just4pLeisure 1:d5452e398b76 1093 // write register
Just4pLeisure 1:d5452e398b76 1094 if (!bdm_write(NULL, BDM_WSREG + reg, value)) {
Just4pLeisure 1:d5452e398b76 1095 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 1096 bdm_clear();
Just4pLeisure 1:d5452e398b76 1097 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1098 }
Just4pLeisure 1:d5452e398b76 1099
Just4pLeisure 1:d5452e398b76 1100 return TERM_OK;
Just4pLeisure 1:d5452e398b76 1101 }
Just4pLeisure 1:d5452e398b76 1102
Just4pLeisure 1:d5452e398b76 1103 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1104 /**
Just4pLeisure 1:d5452e398b76 1105 Reads value from A/D register.
Just4pLeisure 1:d5452e398b76 1106
Just4pLeisure 1:d5452e398b76 1107 @param result register value (out)
Just4pLeisure 1:d5452e398b76 1108 @param reg register
Just4pLeisure 1:d5452e398b76 1109
Just4pLeisure 1:d5452e398b76 1110 @return status flag
Just4pLeisure 1:d5452e398b76 1111 */
Just4pLeisure 5:1775b4b13232 1112 uint8_t adreg_read(uint32_t* result, uint8_t reg)
Just4pLeisure 5:1775b4b13232 1113 {
Just4pLeisure 1:d5452e398b76 1114 // check state
Just4pLeisure 1:d5452e398b76 1115 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 1116 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1117 }
Just4pLeisure 1:d5452e398b76 1118
Just4pLeisure 1:d5452e398b76 1119 // read register
Just4pLeisure 1:d5452e398b76 1120 if (!bdm_read(result, BDM_RDREG + reg, NULL)) {
Just4pLeisure 1:d5452e398b76 1121 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 1122 bdm_clear();
Just4pLeisure 1:d5452e398b76 1123 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1124 }
Just4pLeisure 1:d5452e398b76 1125 return TERM_OK;
Just4pLeisure 1:d5452e398b76 1126 }
Just4pLeisure 1:d5452e398b76 1127
Just4pLeisure 1:d5452e398b76 1128 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1129 /**
Just4pLeisure 1:d5452e398b76 1130 Writes value to A/D register.
Just4pLeisure 1:d5452e398b76 1131
Just4pLeisure 1:d5452e398b76 1132 @param reg register
Just4pLeisure 1:d5452e398b76 1133 @param value register value
Just4pLeisure 1:d5452e398b76 1134
Just4pLeisure 1:d5452e398b76 1135 @return status flag
Just4pLeisure 1:d5452e398b76 1136 */
Just4pLeisure 5:1775b4b13232 1137 uint8_t adreg_write(uint8_t reg, const uint32_t* value)
Just4pLeisure 5:1775b4b13232 1138 {
Just4pLeisure 1:d5452e398b76 1139 // check state
Just4pLeisure 1:d5452e398b76 1140 if (!IN_BDM) {
Just4pLeisure 1:d5452e398b76 1141 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1142 }
Just4pLeisure 1:d5452e398b76 1143
Just4pLeisure 1:d5452e398b76 1144 // write register
Just4pLeisure 1:d5452e398b76 1145 if (!bdm_write(NULL, BDM_WRREG + reg, value)) {
Just4pLeisure 1:d5452e398b76 1146 // clear the interface and fail
Just4pLeisure 1:d5452e398b76 1147 bdm_clear();
Just4pLeisure 1:d5452e398b76 1148 return TERM_ERR;
Just4pLeisure 1:d5452e398b76 1149 }
Just4pLeisure 1:d5452e398b76 1150
Just4pLeisure 1:d5452e398b76 1151 return TERM_OK;
Just4pLeisure 1:d5452e398b76 1152 }
Just4pLeisure 1:d5452e398b76 1153
Just4pLeisure 1:d5452e398b76 1154 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1155 /**
Just4pLeisure 1:d5452e398b76 1156 Issues a read command to MCU.
Just4pLeisure 1:d5452e398b76 1157
Just4pLeisure 1:d5452e398b76 1158 @param result read result (out)
Just4pLeisure 1:d5452e398b76 1159 @param cmd command sequence
Just4pLeisure 1:d5452e398b76 1160 @param addr address (optional)
Just4pLeisure 1:d5452e398b76 1161
Just4pLeisure 1:d5452e398b76 1162 @return succ / fail
Just4pLeisure 1:d5452e398b76 1163 */
Just4pLeisure 5:1775b4b13232 1164 bool bdm_read(uint32_t* result, uint16_t cmd, const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 1165 {
Just4pLeisure 1:d5452e398b76 1166 *result = 0;
Just4pLeisure 1:d5452e398b76 1167
Just4pLeisure 1:d5452e398b76 1168 // write command code
Just4pLeisure 1:d5452e398b76 1169 bdm_clk(cmd, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1170 if (bdm_response > BDM_CMDCMPLTE) {
Just4pLeisure 1:d5452e398b76 1171 return false;
Just4pLeisure 1:d5452e398b76 1172 }
Just4pLeisure 1:d5452e398b76 1173
Just4pLeisure 1:d5452e398b76 1174 // write the optional address
Just4pLeisure 1:d5452e398b76 1175 if (addr) {
Just4pLeisure 1:d5452e398b76 1176 // first word
Just4pLeisure 1:d5452e398b76 1177 bdm_clk((uint16_t)(*addr >> 16), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1178 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1179 return false;
Just4pLeisure 1:d5452e398b76 1180 }
Just4pLeisure 1:d5452e398b76 1181 // second word
Just4pLeisure 1:d5452e398b76 1182 bdm_clk((uint16_t)(*addr), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1183 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1184 return false;
Just4pLeisure 1:d5452e398b76 1185 }
Just4pLeisure 1:d5452e398b76 1186 }
Just4pLeisure 1:d5452e398b76 1187
Just4pLeisure 1:d5452e398b76 1188 // receive response words
Just4pLeisure 1:d5452e398b76 1189 uint8_t wait_cnt;
Just4pLeisure 1:d5452e398b76 1190 for (uint8_t curr_word = 0; curr_word < ((cmd & BDM_LONGSIZE) ? 2 : 1);
Just4pLeisure 1:d5452e398b76 1191 ++curr_word) {
Just4pLeisure 1:d5452e398b76 1192 // wait while MCU prepares the response
Just4pLeisure 1:d5452e398b76 1193 wait_cnt = ERR_COUNT;
Just4pLeisure 1:d5452e398b76 1194 do {
Just4pLeisure 1:d5452e398b76 1195 bdm_clk(BDM_NOP, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1196 } while (bdm_response == BDM_NOTREADY && --wait_cnt > 0);
Just4pLeisure 1:d5452e398b76 1197
Just4pLeisure 1:d5452e398b76 1198 // save the result
Just4pLeisure 1:d5452e398b76 1199 if (bdm_response < BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1200 (*result) <<= 16;
Just4pLeisure 1:d5452e398b76 1201 (*result) |= bdm_response;
Just4pLeisure 1:d5452e398b76 1202 } else {
Just4pLeisure 1:d5452e398b76 1203 // result was not received
Just4pLeisure 1:d5452e398b76 1204 return false;
Just4pLeisure 1:d5452e398b76 1205 }
Just4pLeisure 1:d5452e398b76 1206 }
Just4pLeisure 1:d5452e398b76 1207
Just4pLeisure 1:d5452e398b76 1208 return true;
Just4pLeisure 1:d5452e398b76 1209 }
Just4pLeisure 1:d5452e398b76 1210
Just4pLeisure 1:d5452e398b76 1211 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1212 /**
Just4pLeisure 1:d5452e398b76 1213 Issues a write command to MCU.
Just4pLeisure 1:d5452e398b76 1214
Just4pLeisure 1:d5452e398b76 1215 @param num_words number of additional command words
Just4pLeisure 1:d5452e398b76 1216 @param cmd command sequence
Just4pLeisure 1:d5452e398b76 1217
Just4pLeisure 1:d5452e398b76 1218 @return succ / fail
Just4pLeisure 1:d5452e398b76 1219 */
Just4pLeisure 5:1775b4b13232 1220 bool bdm_write(const uint32_t* addr, uint16_t cmd, const uint32_t* value)
Just4pLeisure 5:1775b4b13232 1221 {
Just4pLeisure 1:d5452e398b76 1222 // write command code
Just4pLeisure 1:d5452e398b76 1223 bdm_clk(cmd, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1224 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1225 return false;
Just4pLeisure 1:d5452e398b76 1226 }
Just4pLeisure 1:d5452e398b76 1227
Just4pLeisure 1:d5452e398b76 1228 // write the optional address
Just4pLeisure 1:d5452e398b76 1229 if (addr) {
Just4pLeisure 1:d5452e398b76 1230 // first word
Just4pLeisure 1:d5452e398b76 1231 bdm_clk((uint16_t)((*addr) >> 16), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1232 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1233 return false;
Just4pLeisure 1:d5452e398b76 1234 }
Just4pLeisure 1:d5452e398b76 1235 // second word
Just4pLeisure 1:d5452e398b76 1236 bdm_clk((uint16_t)(*addr), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1237 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1238 return false;
Just4pLeisure 1:d5452e398b76 1239 }
Just4pLeisure 1:d5452e398b76 1240 }
Just4pLeisure 1:d5452e398b76 1241
Just4pLeisure 1:d5452e398b76 1242 // write the value
Just4pLeisure 1:d5452e398b76 1243 if (cmd & BDM_LONGSIZE) {
Just4pLeisure 1:d5452e398b76 1244 bdm_clk((uint16_t)((*value) >> 16), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1245 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1246 return false;
Just4pLeisure 1:d5452e398b76 1247 }
Just4pLeisure 1:d5452e398b76 1248 }
Just4pLeisure 1:d5452e398b76 1249 bdm_clk((uint16_t)(*value), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1250 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1251 return false;
Just4pLeisure 1:d5452e398b76 1252 }
Just4pLeisure 1:d5452e398b76 1253
Just4pLeisure 1:d5452e398b76 1254 // wait until MCU responds
Just4pLeisure 1:d5452e398b76 1255 uint8_t wait_cnt = ERR_COUNT;
Just4pLeisure 1:d5452e398b76 1256 do {
Just4pLeisure 1:d5452e398b76 1257 // read response
Just4pLeisure 1:d5452e398b76 1258 bdm_clk(BDM_NOP, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1259 } while (bdm_response == BDM_NOTREADY && --wait_cnt > 0);
Just4pLeisure 1:d5452e398b76 1260
Just4pLeisure 1:d5452e398b76 1261 // check if command succeeded
Just4pLeisure 1:d5452e398b76 1262 return (bdm_response == BDM_CMDCMPLTE);
Just4pLeisure 1:d5452e398b76 1263 }
Just4pLeisure 1:d5452e398b76 1264
Just4pLeisure 5:1775b4b13232 1265 bool bdm_command (uint16_t cmd)
Just4pLeisure 5:1775b4b13232 1266 {
Just4pLeisure 1:d5452e398b76 1267 // write command code
Just4pLeisure 5:1775b4b13232 1268 bdm_clk(cmd, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1269 return (bdm_response > BDM_NOTREADY) ? false : true;
Just4pLeisure 1:d5452e398b76 1270 }
Just4pLeisure 1:d5452e398b76 1271
Just4pLeisure 5:1775b4b13232 1272 bool bdm_address (const uint32_t* addr)
Just4pLeisure 5:1775b4b13232 1273 {
Just4pLeisure 1:d5452e398b76 1274 // write an address
Just4pLeisure 1:d5452e398b76 1275 // first word
Just4pLeisure 5:1775b4b13232 1276 bdm_clk((uint16_t)((*addr) >> 16), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1277 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1278 return false;
Just4pLeisure 1:d5452e398b76 1279 }
Just4pLeisure 1:d5452e398b76 1280 // second word
Just4pLeisure 5:1775b4b13232 1281 bdm_clk((uint16_t)(*addr), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1282 return (bdm_response > BDM_NOTREADY) ? false : true;
Just4pLeisure 1:d5452e398b76 1283 }
Just4pLeisure 1:d5452e398b76 1284
Just4pLeisure 5:1775b4b13232 1285 bool bdm_get (uint32_t* result, uint8_t size, uint16_t next_cmd)
Just4pLeisure 5:1775b4b13232 1286 {
Just4pLeisure 1:d5452e398b76 1287 // receive response words
Just4pLeisure 1:d5452e398b76 1288 *result = 0;
Just4pLeisure 1:d5452e398b76 1289 uint8_t wait_cnt;
Just4pLeisure 1:d5452e398b76 1290 for (uint8_t curr_word = 0; curr_word < ((size & BDM_LONGSIZE) ? 2 : 1);
Just4pLeisure 1:d5452e398b76 1291 ++curr_word) {
Just4pLeisure 1:d5452e398b76 1292 // wait while MCU prepares the response
Just4pLeisure 1:d5452e398b76 1293 wait_cnt = ERR_COUNT;
Just4pLeisure 1:d5452e398b76 1294 do {
Just4pLeisure 5:1775b4b13232 1295 bdm_clk(next_cmd, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1296 } while (bdm_response == BDM_NOTREADY && --wait_cnt > 0);
Just4pLeisure 1:d5452e398b76 1297
Just4pLeisure 1:d5452e398b76 1298 // save the result
Just4pLeisure 1:d5452e398b76 1299 if (bdm_response < BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1300 (*result) <<= 16;
Just4pLeisure 1:d5452e398b76 1301 (*result) |= bdm_response;
Just4pLeisure 1:d5452e398b76 1302 } else {
Just4pLeisure 1:d5452e398b76 1303 // result was not received
Just4pLeisure 1:d5452e398b76 1304 return false;
Just4pLeisure 1:d5452e398b76 1305 }
Just4pLeisure 1:d5452e398b76 1306 }
Just4pLeisure 1:d5452e398b76 1307 return true;
Just4pLeisure 1:d5452e398b76 1308 }
Just4pLeisure 1:d5452e398b76 1309
Just4pLeisure 5:1775b4b13232 1310 bool bdm_put (const uint32_t* value, uint8_t size)
Just4pLeisure 5:1775b4b13232 1311 {
Just4pLeisure 1:d5452e398b76 1312 // write the value
Just4pLeisure 1:d5452e398b76 1313 if (size & BDM_LONGSIZE) {
Just4pLeisure 5:1775b4b13232 1314 bdm_clk((uint16_t)((*value) >> 16), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1315 if (bdm_response > BDM_NOTREADY) {
Just4pLeisure 1:d5452e398b76 1316 return false;
Just4pLeisure 1:d5452e398b76 1317 }
Just4pLeisure 1:d5452e398b76 1318 }
Just4pLeisure 5:1775b4b13232 1319 bdm_clk((uint16_t)(*value), CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1320 return (bdm_response > BDM_NOTREADY) ? false : true;
Just4pLeisure 1:d5452e398b76 1321 }
Just4pLeisure 1:d5452e398b76 1322
Just4pLeisure 5:1775b4b13232 1323 bool bdm_ready (uint16_t next_cmd)
Just4pLeisure 5:1775b4b13232 1324 {
Just4pLeisure 1:d5452e398b76 1325 // wait until MCU responds
Just4pLeisure 1:d5452e398b76 1326 uint8_t wait_cnt = ERR_COUNT;
Just4pLeisure 1:d5452e398b76 1327 do {
Just4pLeisure 1:d5452e398b76 1328 // read response
Just4pLeisure 5:1775b4b13232 1329 bdm_clk(next_cmd, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1330 } while (bdm_response == BDM_NOTREADY && --wait_cnt > 0);
Just4pLeisure 1:d5452e398b76 1331
Just4pLeisure 1:d5452e398b76 1332 // check if command succeeded
Just4pLeisure 1:d5452e398b76 1333 return (bdm_response == BDM_CMDCMPLTE);
Just4pLeisure 1:d5452e398b76 1334 }
Just4pLeisure 1:d5452e398b76 1335
Just4pLeisure 4:682d96ff6d79 1336
Just4pLeisure 1:d5452e398b76 1337 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1338 /**
Just4pLeisure 5:1775b4b13232 1339 Sets the speed at which BDM data is trransferred.
Just4pLeisure 5:1775b4b13232 1340
Just4pLeisure 5:1775b4b13232 1341 @param mode SLOW, FAST, TURBO, NITROUS
Just4pLeisure 5:1775b4b13232 1342 */
Just4pLeisure 5:1775b4b13232 1343 void bdm_clk_mode(bdm_speed mode)
Just4pLeisure 5:1775b4b13232 1344 {
Just4pLeisure 5:1775b4b13232 1345 switch (mode) {
Just4pLeisure 5:1775b4b13232 1346 case NITROUS:
Just4pLeisure 5:1775b4b13232 1347 bdm_clk = &bdm_clk_nitrous;
Just4pLeisure 5:1775b4b13232 1348 break;
Just4pLeisure 5:1775b4b13232 1349 case TURBO:
Just4pLeisure 5:1775b4b13232 1350 bdm_clk = &bdm_clk_turbo;
Just4pLeisure 5:1775b4b13232 1351 break;
Just4pLeisure 5:1775b4b13232 1352 case FAST:
Just4pLeisure 5:1775b4b13232 1353 bdm_clk = &bdm_clk_fast;
Just4pLeisure 5:1775b4b13232 1354 break;
Just4pLeisure 5:1775b4b13232 1355 case SLOW:
Just4pLeisure 5:1775b4b13232 1356 default:
Just4pLeisure 5:1775b4b13232 1357 bdm_clk = &bdm_clk_slow;
Just4pLeisure 5:1775b4b13232 1358 break;
Just4pLeisure 5:1775b4b13232 1359 }
Just4pLeisure 5:1775b4b13232 1360 return;
Just4pLeisure 5:1775b4b13232 1361 }
Just4pLeisure 5:1775b4b13232 1362
Just4pLeisure 5:1775b4b13232 1363 //-----------------------------------------------------------------------------
Just4pLeisure 5:1775b4b13232 1364 /**
Just4pLeisure 1:d5452e398b76 1365 Writes a word to target MCU via BDM line and gets the response.
Just4pLeisure 1:d5452e398b76 1366
Just4pLeisure 1:d5452e398b76 1367 @param value value to write
Just4pLeisure 1:d5452e398b76 1368 @param num_bits value size, bits
Just4pLeisure 1:d5452e398b76 1369 */
Just4pLeisure 5:1775b4b13232 1370 /*
Just4pLeisure 5:1775b4b13232 1371 void bdm_clk(uint16_t value, uint8_t num_bits)
Just4pLeisure 5:1775b4b13232 1372 {
Just4pLeisure 5:1775b4b13232 1373 // PIN_BKPT.output();
Just4pLeisure 5:1775b4b13232 1374 PIN_DSI.output();
Just4pLeisure 5:1775b4b13232 1375 // clock the value via BDM
Just4pLeisure 5:1775b4b13232 1376 bdm_response = ((uint32_t)value) << (32 - num_bits);
Just4pLeisure 5:1775b4b13232 1377 while (num_bits--) {
Just4pLeisure 5:1775b4b13232 1378 // falling edge on BKPT/DSCLK
Just4pLeisure 5:1775b4b13232 1379 PIN_BKPT.write(0);
Just4pLeisure 5:1775b4b13232 1380 // set DSI bit
Just4pLeisure 5:1775b4b13232 1381 PIN_DSI.write(bdm_response & 0x80000000);
Just4pLeisure 5:1775b4b13232 1382 bdm_response <<= 1;
Just4pLeisure 5:1775b4b13232 1383 // read DSO bit
Just4pLeisure 5:1775b4b13232 1384 bdm_response |= PIN_DSO.read();
Just4pLeisure 5:1775b4b13232 1385 // short delay
Just4pLeisure 5:1775b4b13232 1386 // for (uint8_t c = 1; c; c--);
Just4pLeisure 5:1775b4b13232 1387 // wait_us(1);
Just4pLeisure 5:1775b4b13232 1388 // rising edge on BKPT/DSCLK
Just4pLeisure 5:1775b4b13232 1389 PIN_BKPT.write(1);
Just4pLeisure 5:1775b4b13232 1390 // short delay
Just4pLeisure 5:1775b4b13232 1391 // for (uint8_t c = 1; c; c--);
Just4pLeisure 5:1775b4b13232 1392 // wait_us(1);
Just4pLeisure 5:1775b4b13232 1393 }
Just4pLeisure 5:1775b4b13232 1394 PIN_DSI.input();
Just4pLeisure 5:1775b4b13232 1395 }
Just4pLeisure 5:1775b4b13232 1396 */
Just4pLeisure 5:1775b4b13232 1397
Just4pLeisure 5:1775b4b13232 1398 //-----------------------------------------------------------------------------
Just4pLeisure 5:1775b4b13232 1399 /**
Just4pLeisure 5:1775b4b13232 1400 Writes a word to target MCU via BDM line and gets the response.
Just4pLeisure 5:1775b4b13232 1401
Just4pLeisure 5:1775b4b13232 1402 @param value value to write
Just4pLeisure 5:1775b4b13232 1403 @param num_bits value size, bits
Just4pLeisure 5:1775b4b13232 1404 */
Just4pLeisure 5:1775b4b13232 1405
Just4pLeisure 5:1775b4b13232 1406 void bdm_clk_slow(uint16_t value, uint8_t num_bits) {
Just4pLeisure 1:d5452e398b76 1407 // PIN_BKPT.output();
Just4pLeisure 2:bf3a2b29259a 1408 PIN_DSI.output();
Just4pLeisure 1:d5452e398b76 1409 // clock the value via BDM
Just4pLeisure 1:d5452e398b76 1410 bdm_response = ((uint32_t)value) << (32 - num_bits);
Just4pLeisure 1:d5452e398b76 1411 // bool dsi;
Just4pLeisure 1:d5452e398b76 1412 while (num_bits--) {
Just4pLeisure 1:d5452e398b76 1413
Just4pLeisure 1:d5452e398b76 1414 // falling edge on BKPT/DSCLK
Just4pLeisure 1:d5452e398b76 1415 PIN_BKPT.write(0);
Just4pLeisure 1:d5452e398b76 1416 // set DSI bit
Just4pLeisure 1:d5452e398b76 1417 PIN_DSI.write(bdm_response & 0x80000000);
Just4pLeisure 1:d5452e398b76 1418 bdm_response <<= 1;
Just4pLeisure 1:d5452e398b76 1419 // read DSO bit
Just4pLeisure 1:d5452e398b76 1420 bdm_response |= PIN_DSO.read();
Just4pLeisure 1:d5452e398b76 1421 // short delay
Just4pLeisure 1:d5452e398b76 1422 // for (uint8_t c = 1; c; c--);
Just4pLeisure 1:d5452e398b76 1423 // wait_us(1);
Just4pLeisure 1:d5452e398b76 1424 // rising edge on BKPT/DSCLK
Just4pLeisure 1:d5452e398b76 1425 PIN_BKPT.write(1);
Just4pLeisure 1:d5452e398b76 1426 // short delay
Just4pLeisure 5:1775b4b13232 1427 // for (uint8_t c = 1; c; c--);
Just4pLeisure 1:d5452e398b76 1428 // wait_us(1);
Just4pLeisure 1:d5452e398b76 1429 }
Just4pLeisure 1:d5452e398b76 1430 PIN_DSI.input();
Just4pLeisure 1:d5452e398b76 1431 }
Just4pLeisure 5:1775b4b13232 1432 //
Just4pLeisure 4:682d96ff6d79 1433
Just4pLeisure 4:682d96ff6d79 1434 //-----------------------------------------------------------------------------
Just4pLeisure 4:682d96ff6d79 1435 /**
Just4pLeisure 4:682d96ff6d79 1436 Writes a word to target MCU via BDM line and gets the response.
Just4pLeisure 2:bf3a2b29259a 1437 This 'fast' version can be used once the 68332 has been 'prepped'
Just4pLeisure 2:bf3a2b29259a 1438 because the BDM interface can go twice as fast once the 68332
Just4pLeisure 2:bf3a2b29259a 1439 clock is increased from 8 MHz to 16 MHz
Just4pLeisure 2:bf3a2b29259a 1440
Just4pLeisure 2:bf3a2b29259a 1441 @param value value to write
Just4pLeisure 2:bf3a2b29259a 1442 @param num_bits value size, bits
Just4pLeisure 2:bf3a2b29259a 1443 */
Just4pLeisure 4:682d96ff6d79 1444
Just4pLeisure 5:1775b4b13232 1445 void bdm_clk_fast(uint16_t value, uint8_t num_bits)
Just4pLeisure 5:1775b4b13232 1446 {
Just4pLeisure 2:bf3a2b29259a 1447
Just4pLeisure 2:bf3a2b29259a 1448 //Make DSI an output
Just4pLeisure 2:bf3a2b29259a 1449 LPC_GPIO2->FIODIR |= (1 << 2);
Just4pLeisure 2:bf3a2b29259a 1450 // clock the value via BDM
Just4pLeisure 2:bf3a2b29259a 1451 bdm_response = ((uint32_t)value) << (32 - num_bits);
Just4pLeisure 5:1775b4b13232 1452 // Clock BDM Data in from DSO and out to DSI
Just4pLeisure 2:bf3a2b29259a 1453 while (num_bits--) {
Just4pLeisure 2:bf3a2b29259a 1454 // set DSI bit
Just4pLeisure 4:682d96ff6d79 1455 (bdm_response & 0x80000000) ? LPC_GPIO2->FIOSET = (1 << 2) : LPC_GPIO2->FIOCLR = (1 << 2);
Just4pLeisure 5:1775b4b13232 1456 // falling edge on BKPT/DSCLK
Just4pLeisure 2:bf3a2b29259a 1457 LPC_GPIO2->FIOCLR = (1 << 4);
Just4pLeisure 5:1775b4b13232 1458 // read DSO bit
Just4pLeisure 2:bf3a2b29259a 1459 // (bdm_response <<= 1) |= (bool)((LPC_GPIO0->FIOPIN) & (1 << 11)); -- OLD CONNECTION to PIN 27
Just4pLeisure 2:bf3a2b29259a 1460 (bdm_response <<= 1) |= (bool)((LPC_GPIO2->FIOPIN) & (1 << 1));
Just4pLeisure 2:bf3a2b29259a 1461 // rising edge on BKPT/DSCLK
Just4pLeisure 2:bf3a2b29259a 1462 LPC_GPIO2->FIOSET = (1 << 4);
Just4pLeisure 5:1775b4b13232 1463 // introduce a delay to insure that BDM clock isn't too fast
Just4pLeisure 5:1775b4b13232 1464 for (uint8_t c = 9; c; c--); // was 5
Just4pLeisure 5:1775b4b13232 1465 }
Just4pLeisure 5:1775b4b13232 1466 //Make DSI an input
Just4pLeisure 5:1775b4b13232 1467 LPC_GPIO2->FIODIR &= ~(1 << 2);
Just4pLeisure 5:1775b4b13232 1468 }
Just4pLeisure 5:1775b4b13232 1469 //-----------------------------------------------------------------------------
Just4pLeisure 5:1775b4b13232 1470
Just4pLeisure 5:1775b4b13232 1471 /**
Just4pLeisure 5:1775b4b13232 1472 Writes a word to target MCU via BDM line and gets the response.
Just4pLeisure 5:1775b4b13232 1473 This 'turbo' version uses 'bit-banding' to read and write individual
Just4pLeisure 5:1775b4b13232 1474 bits directly. This should be faster than the 'fast' version because
Just4pLeisure 5:1775b4b13232 1475 the complex calculation to find the address of the BDM word 'bit-band'
Just4pLeisure 5:1775b4b13232 1476 region is only done once per call rather than several, simpler,
Just4pLeisure 5:1775b4b13232 1477 calculations and bit-shifts that the slow and fast functions do for
Just4pLeisure 5:1775b4b13232 1478 each bit.
Just4pLeisure 5:1775b4b13232 1479
Just4pLeisure 5:1775b4b13232 1480 The 68332 must have been 'prepped' before using the 'turbo' version
Just4pLeisure 5:1775b4b13232 1481 because the BDM interface can go twice as fast once the 68332
Just4pLeisure 5:1775b4b13232 1482 clock is increased from 8 MHz to 16 MHz
Just4pLeisure 5:1775b4b13232 1483
Just4pLeisure 5:1775b4b13232 1484 @param value value to write
Just4pLeisure 5:1775b4b13232 1485 @param num_bits value size, bits
Just4pLeisure 5:1775b4b13232 1486 */
Just4pLeisure 5:1775b4b13232 1487
Just4pLeisure 5:1775b4b13232 1488 void bdm_clk_turbo(uint16_t value, uint8_t num_bits)
Just4pLeisure 5:1775b4b13232 1489 {
Just4pLeisure 5:1775b4b13232 1490 //Make DSI an output
Just4pLeisure 5:1775b4b13232 1491 LPC_GPIO2->FIODIR |= (1 << 2);
Just4pLeisure 5:1775b4b13232 1492 bdm_response = (uint32_t)value;
Just4pLeisure 5:1775b4b13232 1493 // calculate a pointer to the bitband alias region address of the most significant bit of the BDM word (NOTE num_bits-1)
Just4pLeisure 5:1775b4b13232 1494 uint32_t *bdm_response_bit_alias = &bitAlias(bdm_response,num_bits-1);
Just4pLeisure 5:1775b4b13232 1495 // Clock BDM Data in from DSO and out to DSI
Just4pLeisure 5:1775b4b13232 1496 while (num_bits--) {
Just4pLeisure 5:1775b4b13232 1497 // set DSI bit (port 2, bit 2)
Just4pLeisure 5:1775b4b13232 1498 bitAlias(LPC_GPIO2->FIOPIN,2) = *bdm_response_bit_alias;
Just4pLeisure 5:1775b4b13232 1499 // falling edge on BKPT/DSCLK
Just4pLeisure 5:1775b4b13232 1500 LPC_GPIO2->FIOCLR = (1 << 4);
Just4pLeisure 5:1775b4b13232 1501 // read DSO bit (port 2, bit 1) ( -- OLD CONNECTION WAS to PIN 27 -- port 2, bit 11)
Just4pLeisure 5:1775b4b13232 1502 *bdm_response_bit_alias = bitAlias(LPC_GPIO2->FIOPIN,1);
Just4pLeisure 5:1775b4b13232 1503 // introduce a delay to insure that BDM clock isn't too fast
Just4pLeisure 5:1775b4b13232 1504 for (uint8_t c = 2; c; c--); // was 2
Just4pLeisure 5:1775b4b13232 1505 // rising edge on BKPT/DSCLK
Just4pLeisure 5:1775b4b13232 1506 LPC_GPIO2->FIOSET = (1 << 4);
Just4pLeisure 5:1775b4b13232 1507 // point to the next bit (pointer will be decremented by sizeof pointer)
Just4pLeisure 5:1775b4b13232 1508 bdm_response_bit_alias--;
Just4pLeisure 5:1775b4b13232 1509 // introduce a delay to insure that BDM clock isn't too fast
Just4pLeisure 5:1775b4b13232 1510 for (uint8_t c = 7; c; c--); // was 2
Just4pLeisure 5:1775b4b13232 1511 }
Just4pLeisure 5:1775b4b13232 1512 //Make DSI an input
Just4pLeisure 5:1775b4b13232 1513 LPC_GPIO2->FIODIR &= ~(1 << 2);
Just4pLeisure 5:1775b4b13232 1514 }
Just4pLeisure 5:1775b4b13232 1515 //-----------------------------------------------------------------------------
Just4pLeisure 5:1775b4b13232 1516
Just4pLeisure 5:1775b4b13232 1517 /**
Just4pLeisure 5:1775b4b13232 1518 Writes a word to target MCU via BDM line and gets the response.
Just4pLeisure 5:1775b4b13232 1519
Just4pLeisure 5:1775b4b13232 1520 This 'nitrous' version uses is the same as the 'turbo' version but
Just4pLeisure 5:1775b4b13232 1521 without minimal delays and will only work with the faster CPU in T8
Just4pLeisure 5:1775b4b13232 1522 once the ECU has been 'prepped'
Just4pLeisure 5:1775b4b13232 1523
Just4pLeisure 5:1775b4b13232 1524 @param value value to write
Just4pLeisure 5:1775b4b13232 1525 @param num_bits value size, bits
Just4pLeisure 5:1775b4b13232 1526 */
Just4pLeisure 5:1775b4b13232 1527
Just4pLeisure 5:1775b4b13232 1528 void bdm_clk_nitrous(uint16_t value, uint8_t num_bits)
Just4pLeisure 5:1775b4b13232 1529 {
Just4pLeisure 5:1775b4b13232 1530 //Make DSI an output
Just4pLeisure 5:1775b4b13232 1531 LPC_GPIO2->FIODIR |= (1 << 2);
Just4pLeisure 5:1775b4b13232 1532 bdm_response = (uint32_t)value;
Just4pLeisure 5:1775b4b13232 1533 // calculate a pointer to the bitband alias region address of the most significant bit of the BDM word (NOTE num_bits-1)
Just4pLeisure 5:1775b4b13232 1534 uint32_t *bdm_response_bit_alias = &bitAlias(bdm_response,num_bits-1);
Just4pLeisure 5:1775b4b13232 1535 // Clock BDM Data in from DSO and out to DSI
Just4pLeisure 5:1775b4b13232 1536 while (num_bits--) {
Just4pLeisure 5:1775b4b13232 1537 // set DSI bit (port 2, bit 2)
Just4pLeisure 5:1775b4b13232 1538 bitAlias(LPC_GPIO2->FIOPIN,2) = *bdm_response_bit_alias;
Just4pLeisure 5:1775b4b13232 1539 // falling edge on BKPT/DSCLK
Just4pLeisure 5:1775b4b13232 1540 LPC_GPIO2->FIOCLR = (1 << 4);
Just4pLeisure 5:1775b4b13232 1541 // read DSO bit (port 2, bit 1) ( -- OLD CONNECTION WAS to PIN 27 -- port 2, bit 11)
Just4pLeisure 5:1775b4b13232 1542 *bdm_response_bit_alias = bitAlias(LPC_GPIO2->FIOPIN,1);
Just4pLeisure 5:1775b4b13232 1543 // introduce a delay to insure that BDM clock isn't too fast
Just4pLeisure 5:1775b4b13232 1544 //for (uint8_t c = 2; c; c--);
Just4pLeisure 5:1775b4b13232 1545 // rising edge on BKPT/DSCLK
Just4pLeisure 5:1775b4b13232 1546 LPC_GPIO2->FIOSET = (1 << 4);
Just4pLeisure 5:1775b4b13232 1547 // point to the next bit (pointer will be decremented by sizeof pointer)
Just4pLeisure 5:1775b4b13232 1548 bdm_response_bit_alias--;
Just4pLeisure 5:1775b4b13232 1549 // introduce a delay to insure that BDM clock isn't too fast
Just4pLeisure 2:bf3a2b29259a 1550 for (uint8_t c = 1; c; c--);
Just4pLeisure 2:bf3a2b29259a 1551 }
Just4pLeisure 2:bf3a2b29259a 1552 //Make DSI an input
Just4pLeisure 2:bf3a2b29259a 1553 LPC_GPIO2->FIODIR &= ~(1 << 2);
Just4pLeisure 2:bf3a2b29259a 1554 }
Just4pLeisure 5:1775b4b13232 1555 //-----------------------------------------------------------------------------
Just4pLeisure 4:682d96ff6d79 1556
Just4pLeisure 2:bf3a2b29259a 1557 /**
Just4pLeisure 1:d5452e398b76 1558 Clears the BDM interface after errors.
Just4pLeisure 1:d5452e398b76 1559 */
Just4pLeisure 5:1775b4b13232 1560 void bdm_clear()
Just4pLeisure 5:1775b4b13232 1561 {
Just4pLeisure 1:d5452e398b76 1562 bdm_clk (BDM_NOP, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1563 bdm_clk (BDM_NOP, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1564 bdm_clk (BDM_NOP, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1565 bdm_clk (BDM_NOP, CMD_BIT_COUNT);
Just4pLeisure 1:d5452e398b76 1566
Just4pLeisure 1:d5452e398b76 1567 while (bdm_response > 0) {
Just4pLeisure 1:d5452e398b76 1568 bdm_clk(0, 1);
Just4pLeisure 1:d5452e398b76 1569 }
Just4pLeisure 1:d5452e398b76 1570 while (bdm_response < 1) {
Just4pLeisure 1:d5452e398b76 1571 bdm_clk(0, 1);
Just4pLeisure 1:d5452e398b76 1572 }
Just4pLeisure 1:d5452e398b76 1573 bdm_clk(0, 15);
Just4pLeisure 1:d5452e398b76 1574 }
Just4pLeisure 1:d5452e398b76 1575
Just4pLeisure 1:d5452e398b76 1576 //-----------------------------------------------------------------------------
Just4pLeisure 1:d5452e398b76 1577 // EOF
Just4pLeisure 1:d5452e398b76 1578 //-----------------------------------------------------------------------------