From 6cd3815d5afe1a02f8922fa820312fa515890d7b Mon Sep 17 00:00:00 2001 From: Alessandro Mauri Date: Sun, 5 Apr 2026 01:31:11 +0200 Subject: [PATCH 1/3] first (non working) programmer --- fw/programmer/.gitignore | 5 + fw/programmer/platformio.ini | 14 + fw/programmer/src/bitbang_rvswdio.h | 1096 ++++++++++++++++++++++ fw/programmer/src/bitbang_rvswdio_pico.h | 219 +++++ fw/programmer/src/main.cpp | 90 ++ fw/programmer/test/rvswd.c | 199 ++++ fw/programmer/test/rvswd.h | 20 + 7 files changed, 1643 insertions(+) create mode 100644 fw/programmer/.gitignore create mode 100644 fw/programmer/platformio.ini create mode 100644 fw/programmer/src/bitbang_rvswdio.h create mode 100644 fw/programmer/src/bitbang_rvswdio_pico.h create mode 100644 fw/programmer/src/main.cpp create mode 100644 fw/programmer/test/rvswd.c create mode 100644 fw/programmer/test/rvswd.h diff --git a/fw/programmer/.gitignore b/fw/programmer/.gitignore new file mode 100644 index 0000000..6335249 --- /dev/null +++ b/fw/programmer/.gitignore @@ -0,0 +1,5 @@ +.pio +.zed +.vscode +.cache +compile_commands.json diff --git a/fw/programmer/platformio.ini b/fw/programmer/platformio.ini new file mode 100644 index 0000000..1308496 --- /dev/null +++ b/fw/programmer/platformio.ini @@ -0,0 +1,14 @@ +; PlatformIO Project Configuration File +; +; Build options: build flags, source filter +; Upload options: custom upload port, speed and extra flags +; Library options: dependencies, extra library storages +; Advanced options: extra scripting +; +; Please visit documentation for the other options and examples +; https://docs.platformio.org/page/projectconf.html + +[env:default] +platform = https://github.com/maxgerhardt/platform-raspberrypi +framework = arduino +board = rpipico diff --git a/fw/programmer/src/bitbang_rvswdio.h b/fw/programmer/src/bitbang_rvswdio.h new file mode 100644 index 0000000..09011d5 --- /dev/null +++ b/fw/programmer/src/bitbang_rvswdio.h @@ -0,0 +1,1096 @@ +// CH32V003 SWIO / CH32Vxxx / CH32Xxxx bit banging minimal reference +// implementation for bit banged IO or primitive IO. +// +// You will need to implement some of the basic functions. Example +// implementations for the functions on the ESP32-S2 are included. +// +// Copyright 2023-2024 <>< Charles Lohr, May be licensed under the MIT/x11 or +// NewBSD licenses. You choose. (Can be included in commercial and copyleft work) +// +// This file is original work. +// +// Mostly tested, though, not may not be perfect. Expect to tweak some things. +// The 003 code is pretty hardened, the other code may not be. +// +// Originally the only resources used to produce this file were publicly available docs +// and playing with the chips. The only leveraged tool was this: +// https://github.com/perigoso/sigrok-rvswd + +#ifndef _WCH_RVSWD_RVSWIO_H +#define _WCH_RVSWD_RVSWIO_H + +#include +#include + +// This is a hacky thing, but if you are laaaaazzzyyyy and don't want to add a 10k +// resistor, youcan do this. It glitches the line high very, very briefly. +// Enable for when you don't have a 10k pull-upand are relying on the internal pull-up. +// WARNING: If you set this, you should set the drive current to 5mA. This is +// only useful / needed if you are using the built-in functions. +//#define R_GLITCH_HIGH +//#define RUNNING_ON_ESP32S2 +//#define BB_PRINTF_DEBUG uprintf + +// You should interface to this file via these functions + +enum RiscVChip { + CHIP_UNKNOWN = 0x00, + CHIP_CH32V10x = 0x01, + CHIP_CH57x = 0x02, + CHIP_CH56x = 0x03, + CHIP_CH32V20x = 0x05, + CHIP_CH32V30x = 0x06, + CHIP_CH58x = 0x07, + CHIP_CH32V003 = 0x09, + CHIP_CH59x = 0x0b, + CHIP_CH643 = 0x0c, + CHIP_CH32X03x = 0x0d, + CHIP_CH32L10x = 0x0e, + CHIP_CH564 = 0x0f, + + CHIP_CH32V00x = 0x4e, + + CHIP_CH570 = 0x8b, + CHIP_CH585 = 0x4b, + CHIP_CH645 = 0x46, + CHIP_CH641 = 0x49, + CHIP_CH32V317 = 0x86, + CHIP_CH32M030 = 0x8e, +}; + +enum MemoryArea { + DEFAULT_AREA = 0, + PROGRAM_AREA = 1, + BOOTLOADER_AREA = 2, + OPTIONS_AREA = 3, + EEPROM_AREA = 4, + RAM_AREA = 5, +}; + +struct SWIOState +{ + int opmode; // 0 for undefined, 1 for SWIO, 2 for SWD + enum RiscVChip target_chip_type; + int sectorsize; + + // Zero the rest of the structure. + uint32_t statetag; + uint32_t lastwriteflags; + uint32_t currentstateval; + uint32_t flash_unlocked; + uint32_t autoincrement; + uint32_t clock_set; + uint32_t no_autoexec; +}; + +#define STTAG( x ) (*((uint32_t*)(x))) + + +// Provided Basic functions +static inline void ConfigureIOForRVSWD(void); +static inline void ConfigureIOForRVSWIO(void); +static void MCFWriteReg32( struct SWIOState * state, uint8_t command, uint32_t value ); +static int MCFReadReg32( struct SWIOState * state, uint8_t command, uint32_t * value ); + +// More advanced functions built on lower level PHY. +static int InitializeSWDSWIO( struct SWIOState * state ); +static int ReadWord( struct SWIOState * state, uint32_t word, uint32_t * ret ); +static int WriteWord( struct SWIOState * state, uint32_t word, uint32_t val ); +static int WaitForFlash( struct SWIOState * state ); +static int WaitForDoneOp( struct SWIOState * state ); +static int WriteBlock( struct SWIOState * iss, uint32_t address_to_write, uint8_t * data, uint8_t len, uint8_t erase ); +static int UnlockFlash( struct SWIOState * iss ); +static int EraseFlash( struct SWIOState * iss, uint32_t address, uint32_t length, int type ); +static void ResetInternalProgrammingState( struct SWIOState * iss ); +static int PollTerminal( struct SWIOState * iss, uint8_t * buffer, int maxlen, uint32_t leavevalA, uint32_t leavevalB ); + + +#define BDMDATA0 0x04 +#define BDMDATA1 0x05 +#define DMCONTROL 0x10 +#define DMSTATUS 0x11 +#define DMHARTINFO 0x12 +#define DMABSTRACTCS 0x16 +#define DMCOMMAND 0x17 +#define DMABSTRACTAUTO 0x18 +#define DMPROGBUF0 0x20 +#define DMPROGBUF1 0x21 +#define DMPROGBUF2 0x22 +#define DMPROGBUF3 0x23 +#define DMPROGBUF4 0x24 +#define DMPROGBUF5 0x25 +#define DMPROGBUF6 0x26 +#define DMPROGBUF7 0x27 + +#define DMCPBR 0x7C +#define DMCFGR 0x7D +#define DMSHDWCFGR 0x7E + +#ifndef __CH32V00x_H +#define FLASH_STATR_WRPRTERR ((uint8_t)0x10) +#define CR_PAGE_PG ((uint32_t)0x00010000) +#define CR_BUF_LOAD ((uint32_t)0x00040000) +#ifndef FLASH_CTLR_MER +#define FLASH_CTLR_MER ((uint16_t)0x0004) /* Mass Erase */ +#endif +#define CR_STRT_Set ((uint32_t)0x00000040) +#define CR_PAGE_ER ((uint32_t)0x00020000) +#define CR_BUF_RST ((uint32_t)0x00080000) +#endif + + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// High level functions +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +static int InitializeSWDSWIO( struct SWIOState * state ) +{ + for( int timeout = 20; timeout; timeout-- ) + { + //printf( "CFG FOR RV\n" ); + ConfigureIOForRVSWIO(); + //printf( "DONE CFG FOR RV\n" ); + + // Careful - don't halt the part, we might just want to attach for a debug printf or something. + state->target_chip_type = CHIP_UNKNOWN; + state->sectorsize = 64; + + state->opmode = 1; // Try SWIO first + // First try to see if there is an 003. + MCFWriteReg32( state, DMSHDWCFGR, 0x5aa50000 | (1<<10) ); // Shadow Config Reg + MCFWriteReg32( state, DMCFGR, 0x5aa50000 | (1<<10) ); // CFGR (1<<10 == Allow output from slave) + MCFWriteReg32( state, DMSHDWCFGR, 0x5aa50000 | (1<<10) ); // Try twice just in case + MCFWriteReg32( state, DMCFGR, 0x5aa50000 | (1<<10) ); + + MCFWriteReg32( state, DMCONTROL, 0x00000001 ); + MCFWriteReg32( state, DMCONTROL, 0x00000001 ); + + // See if we can see a chip here... + uint32_t value = 0; + int readdm = MCFReadReg32( state, DMCFGR, &value ); + if( readdm == 0 && ( value & 0xffff0000 ) == ( 0x5aa50000 ) ) + { + BB_PRINTF_DEBUG( "Found RVSWIO interface.\n" ); + return 0; + } + + //printf( "CFG FOR SWD\n" ); + ConfigureIOForRVSWD(); + //printf( "DONE CFG FOR SWD\n" ); + + //Otherwise Maybe it's SWD? + state->opmode = 2; + + MCFWriteReg32( state, DMCONTROL, 0x00000001 ); + MCFWriteReg32( state, DMCONTROL, 0x00000001 ); + + uint32_t dmstatus, dmcontrol; + if( MCFReadReg32( state, DMSTATUS, &dmstatus ) != 0 || + MCFReadReg32( state, DMCONTROL, &dmcontrol ) != 0 ) + { + //BB_PRINTF_DEBUG( "Could not read from RVSWD connection\n" ); + state->opmode = 0; + continue; + } + + // See if we can see a chip here... + if( ( ( ( dmstatus >> 8 ) & 0xf ) != 0x0c && + ( ( dmstatus >> 8 ) & 0xf ) != 0x03 ) || + dmcontrol != 1 ) + { + //BB_PRINTF_DEBUG( "DMSTATUS invalid (Probably no RVSWD chip)\n" ); + state->opmode = 0; + continue; + } + + MCFWriteReg32( state, DMABSTRACTCS, 0x08000302 ); // Clear out abstractcs register. + BB_PRINTF_DEBUG( "Found RVSWD interface\n" ); + return 0; + } + //printf( "TIMEOUT\n" ); + return -55; +} + +static int DetermineChipTypeAndSectorInfo( struct SWIOState * iss, uint8_t * reply) +{ + struct SWIOState * dev = iss; + if( iss->target_chip_type == CHIP_UNKNOWN || reply != NULL ) + { + if( iss->opmode == 0 ) + { + int r = InitializeSWDSWIO( iss ); + if( r ) return 0x11; + } + uint32_t rr; + if( MCFReadReg32( dev, DMHARTINFO, &rr ) ) + { + BB_PRINTF_DEBUG( "Error: Could not get hart info.\n" ); + return 0x12; + } + + MCFWriteReg32( dev, DMCONTROL, 0x80000001 ); // Make the debug module work properly. + MCFWriteReg32( dev, DMCONTROL, 0x80000001 ); // Initiate halt request. + + // Tricky, this function needs to clean everything up because it may be used entering debugger. + uint32_t old_data0; + MCFReadReg32( dev, BDMDATA0, &old_data0 ); + MCFWriteReg32( dev, DMCOMMAND, 0x00221008 ); // Copy data from x8. + uint32_t old_x8; + MCFReadReg32( dev, BDMDATA0, &old_x8 ); + + uint32_t marchid = 0; + + MCFWriteReg32( dev, DMABSTRACTCS, 0x08000700 ); // Clear out any dmabstractcs errors. + + MCFWriteReg32( dev, DMABSTRACTAUTO, 0x00000000 ); + MCFWriteReg32( dev, DMCOMMAND, 0x00220000 | 0xf12 ); + MCFWriteReg32( dev, DMCOMMAND, 0x00220000 | 0xf12 ); // Need to double-read, not sure why. + MCFReadReg32( dev, BDMDATA0, &marchid ); + MCFWriteReg32( dev, DMPROGBUF0, 0x90024000 ); // c.ebreak <<== c.lw x8, 0(x8) + + uint32_t chip_id = 0; + uint32_t vendor_bytes = 0; + uint32_t sevenf_id = 0; + int read_protection = 0; + uint8_t ch5xx = 0; + MCFReadReg32( dev, 0x7f, &sevenf_id ); + + if( sevenf_id == 0 ) + { + // Need to load new progbuf because we're reading 1 byte now + MCFWriteReg32( dev, DMPROGBUF0, 0x00040403 ); // lb x8, 0(x8) + MCFWriteReg32( dev, DMPROGBUF1, 0x00100073 ); // c.ebreak + MCFWriteReg32( dev, BDMDATA0, 0x40001041 ); // Special chip ID location. + MCFWriteReg32( dev, DMCOMMAND, 0x00271008 ); // Copy data to x8, and execute. + WaitForDoneOp( dev ); + MCFWriteReg32( dev, DMCOMMAND, 0x00221008 ); // Copy data from x8. + MCFReadReg32( dev, BDMDATA0, &chip_id ); + chip_id = chip_id & 0xff; + + // Looks like a CH32V103 or a CH56x + if( chip_id == 0 ) + { + // First check for CH56x + MCFWriteReg32( dev, BDMDATA0, 0x40001001 ); + MCFWriteReg32( dev, DMCOMMAND, 0x00271008 ); // Copy data to x8, and execute. + WaitForDoneOp( dev ); + MCFWriteReg32( dev, DMCOMMAND, 0x00221008 ); // Copy data from x8. + MCFReadReg32( dev, BDMDATA0, &chip_id ); + MCFWriteReg32( dev, BDMDATA0, 0x40001002 ); // Special chip ID location. + MCFWriteReg32( dev, DMCOMMAND, 0x00271008 ); // Copy data to x8, and execute. + WaitForDoneOp( dev ); + MCFWriteReg32( dev, DMCOMMAND, 0x00221008 ); // Copy data from x8. + MCFReadReg32( dev, BDMDATA0, &vendor_bytes ); + + if( (vendor_bytes & 0xff) == 2 && ((chip_id & 0xff) == 65 || (chip_id & 0xff) == 69) ) + { + iss->target_chip_type = CHIP_CH56x; + chip_id = 0x500 | (chip_id & 0xff); + goto chip_identified; + } + + // Now actually check for CH32V103 + MCFWriteReg32( dev, DMPROGBUF0, 0x90024000 ); // c.ebreak <<== c.lw x8, 0(x8) + MCFWriteReg32( dev, BDMDATA0, 0x1ffff880 ); // Special chip ID location. + MCFWriteReg32( dev, DMCOMMAND, 0x00271008 ); // Copy data to x8, and execute. + WaitForDoneOp( dev ); + MCFWriteReg32( dev, DMCOMMAND, 0x00221008 ); // Copy data from x8. + MCFReadReg32( dev, BDMDATA0, &chip_id ); + MCFWriteReg32( dev, BDMDATA0, 0x1ffff884 ); // Special chip ID location. + MCFWriteReg32( dev, DMCOMMAND, 0x00271008 ); // Copy data to x8, and execute. + WaitForDoneOp( dev ); + MCFWriteReg32( dev, DMCOMMAND, 0x00221008 ); // Copy data from x8. + MCFReadReg32( dev, BDMDATA0, &vendor_bytes ); + + if( ((((vendor_bytes >> 16) & 0xff00) != 0x2500) && (((vendor_bytes >> 16) & 0xdf00) != 0x1500)) || chip_id != 0xdc78fe34 ) + { + uint32_t flash_obr = 0; + MCFWriteReg32( dev, BDMDATA0, 0x4002201c ); // Special chip ID location. + MCFWriteReg32( dev, DMCOMMAND, 0x00271008 ); // Copy data to x8, and execute. + WaitForDoneOp( dev ); + MCFWriteReg32( dev, DMCOMMAND, 0x00221008 ); // Copy data from x8. + MCFReadReg32( dev, BDMDATA0, &flash_obr ); + + if( (flash_obr & 3) == 2 ) + { + iss->target_chip_type = CHIP_CH32V10x; + iss->no_autoexec = 1; + iss->sectorsize = 128; + read_protection = 1; + chip_id = (3 << 12) | 0x103; + } + } + else + { + iss->target_chip_type = CHIP_CH32V10x; + iss->no_autoexec = 1; + iss->sectorsize = 128; + read_protection = -1; + chip_id = (3 << 12) | 0x103; + } + } + else + { + // Check for CH5xx + read_protection = -1; + if( (chip_id & 0xf0) == 0x90 ) + { + uint32_t sevenc = 0; + MCFReadReg32( dev, DMCPBR, &sevenc ); + if((sevenc & 0x30000) == 0) + { + iss->target_chip_type = CHIP_CH59x; + iss->sectorsize = 256; + ch5xx = 1; + chip_id = 0x500 | chip_id; + } + else + { + iss->target_chip_type = CHIP_CH585; + iss->no_autoexec = 1; + iss->sectorsize = 256; + ch5xx = 1; + chip_id = 0x500 | 0x85; + } + } + else + { + if( chip_id == 0x70 || chip_id == 0x72 ) + { + iss->target_chip_type = CHIP_CH570; + iss->sectorsize = 4096; + ch5xx = 1; + chip_id = 0x500 | chip_id; + } + else if( chip_id == 0x71 || chip_id == 0x73 ) + { + iss->target_chip_type = CHIP_CH57x; + iss->no_autoexec = 1; + iss->sectorsize = 256; + ch5xx = 1; + chip_id = 0x500 | chip_id; + } + else if( chip_id == 0x82 || chip_id == 0x83 ) + { + iss->target_chip_type = CHIP_CH58x; + iss->no_autoexec = 1; + iss->sectorsize = 256; + ch5xx = 1; + chip_id = 0x500 | chip_id; + } + } + } + } + else + { + uint32_t masked_id = sevenf_id & 0xfff00000; + uint32_t masked_id2 = sevenf_id & 0xfff00f00; + if( masked_id == 0x3b00000 ) + { + iss->target_chip_type = CHIP_CH32M030; + iss->sectorsize = 256; + chip_id = (2 << 12) | 0x30; + } + else if( masked_id == 0x56400000 ) + { + iss->target_chip_type = CHIP_CH564; + iss->sectorsize = 256; + chip_id = 0x564; + } + else if( masked_id == 0x31700000 ) + { + iss->target_chip_type = CHIP_CH32V317; + iss->sectorsize = 256; + chip_id = (3 << 12) | 0x317; + } + else if( masked_id == 0x00200000 || masked_id == 0x00400000 || masked_id == 0x00600000 || masked_id == 0x00700000 ) + { + iss->target_chip_type = CHIP_CH32V00x; + iss->sectorsize = 256; + chip_id = (3 << 12) | (masked_id >> 20); + } + + if( masked_id2 == 0x64100500 ) + { + iss->target_chip_type = CHIP_CH641; + iss->sectorsize = 64; + chip_id = 0x641; + } + else if( masked_id2 == 0x64300600 ) + { + iss->target_chip_type = CHIP_CH643; + iss->sectorsize = 256; + chip_id = 0x643; + } + else if( masked_id == 0x64500000 ) + { + iss->target_chip_type = CHIP_CH645; + iss->sectorsize = 256; + chip_id = 0x645; + } + else if( masked_id2 == 0x3500600 ) + { + iss->target_chip_type = CHIP_CH32X03x; + iss->sectorsize = 256; + chip_id = (4 << 12) | 0x35; + } + else if( masked_id2 == 0x10300700 ) + { + iss->target_chip_type = CHIP_CH32L10x; + iss->sectorsize = 256; + chip_id = (1 << 12) | 0x103; + } + else if( masked_id2 == 0x300500 ) + { + iss->target_chip_type = CHIP_CH32V003; + iss->sectorsize = 64; + chip_id = (3 << 12) | 0x3; + } + + if( (sevenf_id & 0x20000500) == 0x20000500 || (sevenf_id & 0x30000500) == 0x30000500 ) + { + switch ((sevenf_id & 0xfff00000) >> 20) + { + case 0x203: + case 0x208: + iss->target_chip_type = CHIP_CH32V20x; + iss->sectorsize = 256; + break; + case 0x303: + case 0x305: + case 0x307: + iss->target_chip_type = CHIP_CH32V30x; + iss->sectorsize = 256; + break; + } + chip_id = (3 << 12) | (masked_id >> 20); + } + } + +chip_identified: + + if( read_protection == 0 ) + { + uint32_t one; + int two; + MCFWriteReg32( dev, BDMDATA0, 0x4002201c ); + MCFWriteReg32( dev, DMCOMMAND, 0x00271008 ); // Copy data to x8, and execute. + WaitForDoneOp( dev ); + MCFWriteReg32( dev, DMCOMMAND, 0x00221008 ); // Copy data from x8. + MCFReadReg32( dev, BDMDATA0, &one ); + MCFWriteReg32( dev, BDMDATA0, 0x40022020 ); + MCFWriteReg32( dev, DMCOMMAND, 0x00271008 ); // Copy data to x8, and execute. + WaitForDoneOp( dev ); + MCFWriteReg32( dev, DMCOMMAND, 0x00221008 ); // Copy data from x8. + MCFReadReg32( dev, BDMDATA0, (uint32_t*)&two ); + + if( (one & 2) || two != -1 ) read_protection = 1; + } + + if( reply != NULL ) + { + reply[3] = sevenf_id >> 24; + reply[2] = sevenf_id >> 16; + reply[1] = sevenf_id >> 8; + reply[0] = sevenf_id; + reply[5] = chip_id >> 8; + reply[4] = chip_id; + if( read_protection == 1 ) reply[5] |= 0x80; + } + + // Cleanup + MCFWriteReg32( dev, BDMDATA0, old_x8 ); + MCFWriteReg32( dev, DMCOMMAND, 0x00231008 ); // Copy data to x8 + MCFWriteReg32( dev, BDMDATA0, old_data0 ); + iss->statetag = STTAG( "XXXX" ); +#if CH5xx_SUPPORT + if( ch5xx ) ch5xx_set_clock( dev, 0 ); +#endif + } + return 0; +} + +static int WaitForFlash( struct SWIOState * iss ) +{ + struct SWIOState * dev = iss; + + if( DetermineChipTypeAndSectorInfo( iss, NULL ) ) return -9; + + uint32_t rw, timeout = 0; + do + { + rw = 0; + ReadWord( dev, 0x4002200C, &rw ); // FLASH_STATR => 0x4002200C + } while( (rw & 1) && timeout++ < 2000); // BSY flag. + + WriteWord( dev, 0x4002200C, 0 ); + + if( rw & FLASH_STATR_WRPRTERR ) + return -44; + + if( rw & 1 ) + return -5; + + return 0; +} + + +static int WaitForDoneOp( struct SWIOState * iss ) +{ + int r; + uint32_t rrv; + int ret = 0; + int timeout = 1000; + struct SWIOState * dev = iss; + do + { + r = MCFReadReg32( dev, DMABSTRACTCS, &rrv ); + if( r ) return r; + if( timeout-- == 0 ) return -8; + } + while( rrv & (1<<12) ); + if( (rrv >> 8 ) & 7 ) + { + MCFWriteReg32( dev, DMABSTRACTCS, 0x00000700 ); + ret = -33; + } + return ret; +} + +static int StaticUpdatePROGBUFRegs( struct SWIOState * dev ) +{ + if( DetermineChipTypeAndSectorInfo( dev, NULL ) ) return -9; + + MCFWriteReg32( dev, DMABSTRACTAUTO, 0 ); // Disable Autoexec. + uint32_t rr; + MCFReadReg32( dev, DMHARTINFO, &rr ); + uint32_t data0offset = 0xe0000000 | ( rr & 0x7ff ); + MCFWriteReg32( dev, BDMDATA0, data0offset ); // DATA0's location in memory. (hard code to 0xe00000f4 if only working on the 003) + MCFWriteReg32( dev, DMCOMMAND, 0x0023100a ); // Copy data to x10 + MCFWriteReg32( dev, BDMDATA0, data0offset + 4 ); // DATA1's location in memory. (hard code to 0xe00000f8 if only working on the 003) + MCFWriteReg32( dev, DMCOMMAND, 0x0023100b ); // Copy data to x11 + MCFWriteReg32( dev, BDMDATA0, 0x4002200c ); //FLASH->STATR (note add 4 to FLASH->CTLR) + MCFWriteReg32( dev, DMCOMMAND, 0x0023100c ); // Copy data to x12 + + // This is not even needed on the v20x/v30x chips. But it won't harm us to set the register for simplicity. + // v003 requires bufload every word. + // x035 requires bufload every word in spite of what the datasheet says. + // CR_PAGE_PG = FTPG = 0x00010000 | CR_BUF_LOAD = 0x00040000 + MCFWriteReg32( dev, BDMDATA0, 0x00010000|0x00040000 ); + + MCFWriteReg32( dev, DMCOMMAND, 0x0023100d ); // Copy data to x13 + return 0; +} + +static void ResetInternalProgrammingState( struct SWIOState * iss ) +{ + iss->statetag = 0; + iss->lastwriteflags = 0; + iss->currentstateval = 0; + iss->flash_unlocked = 0; + iss->autoincrement = 0; + iss->clock_set = 0; +} + +static int ReadByte( struct SWIOState * iss, uint32_t address_to_read, uint8_t * data ) +{ + struct SWIOState * dev = iss; + int ret = 0; + iss->statetag = STTAG( "XXXX" ); + + MCFWriteReg32( dev, DMABSTRACTAUTO, 0x00000000 ); // Disable Autoexec. + + // Different address, so we don't need to re-write all the program regs. + // lb x8,0(x9) // Read from the address. + MCFWriteReg32( dev, DMPROGBUF0, 0x00048403 ); // lb x8, 0(x9) + MCFWriteReg32( dev, DMPROGBUF1, 0x00100073 ); // c.ebreak + + MCFWriteReg32( dev, BDMDATA0, address_to_read ); + MCFWriteReg32( dev, DMCOMMAND, 0x00231009 ); // Copy data to x9 + MCFWriteReg32( dev, DMCOMMAND, 0x00241000 ); // Only execute. + MCFWriteReg32( dev, DMCOMMAND, 0x00221008 ); // Read x8 into DATA0. + + ret |= WaitForDoneOp( dev ); + iss->currentstateval = -1; + + uint32_t rr; + ret |= MCFReadReg32( dev, BDMDATA0, &rr ); + *data = rr; + return ret; +} + +static int ReadWord( struct SWIOState * iss, uint32_t address_to_read, uint32_t * data ) +{ + struct SWIOState * dev = iss; + int autoincrement = 1; + + if( address_to_read == 0x40022010 || address_to_read == 0x4002200C ) // Don't autoincrement when checking flash flag. + autoincrement = 0; + + if( iss->statetag != STTAG( "RDSQ" ) || address_to_read != iss->currentstateval || autoincrement != iss->autoincrement ) + { + if( iss->statetag != STTAG( "RDSQ" ) || autoincrement != iss->autoincrement ) + { + if( iss->statetag != STTAG( "WRSQ" ) ) + { + int r = StaticUpdatePROGBUFRegs( dev ); + if( r ) return r; + } + + MCFWriteReg32( dev, DMABSTRACTAUTO, 0 ); // Disable Autoexec. + + // c.lw x8,0(x11) // Pull the address from DATA1 + // c.lw x9,0(x8) // Read the data at that location. + MCFWriteReg32( dev, DMPROGBUF0, 0x40044180 ); + if( autoincrement ) + { + // c.addi x8, 4 + // c.sw x9, 0(x10) // Write back to DATA0 + + MCFWriteReg32( dev, DMPROGBUF1, 0xc1040411 ); + } + else + { + // c.nop + // c.sw x9, 0(x10) // Write back to DATA0 + + MCFWriteReg32( dev, DMPROGBUF1, 0xc1040001 ); + } + // c.sw x8, 0(x11) // Write addy to DATA1 + // c.ebreak + MCFWriteReg32( dev, DMPROGBUF2, 0x9002c180 ); + if( !iss->no_autoexec ) + MCFWriteReg32( dev, DMABSTRACTAUTO, 1 ); // Enable Autoexec (not autoincrement) + iss->autoincrement = autoincrement; + } + + MCFWriteReg32( dev, BDMDATA1, address_to_read ); + if( !iss->no_autoexec ) + MCFWriteReg32( dev, DMCOMMAND, 0x00240000 ); // Execute. + + iss->statetag = STTAG( "RDSQ" ); + iss->currentstateval = address_to_read; + } + + if( iss->autoincrement ) + iss->currentstateval += 4; + + if( iss->no_autoexec ) { + MCFWriteReg32( dev, DMCOMMAND, 0x00240000 ); + } + + // Only an issue if we are curising along very fast. + int r = WaitForDoneOp( dev ); + if( r ) return r; + + r = MCFReadReg32( dev, BDMDATA0, data ); + return r; +} + +static int WriteByte( struct SWIOState * iss, uint32_t address_to_write, uint8_t data ) +{ + struct SWIOState * dev = iss; + int ret = 0; + iss->statetag = STTAG( "XXXX" ); + + MCFWriteReg32( dev, DMABSTRACTAUTO, 0x00000000 ); // Disable Autoexec. + + // Different address, so we don't need to re-write all the program regs. + // sh x8,0(x9) // Write to the address. + MCFWriteReg32( dev, DMPROGBUF0, 0x00848023 ); // sb x8, 0(x9) + MCFWriteReg32( dev, DMPROGBUF1, 0x00100073 ); // c.ebreak + + MCFWriteReg32( dev, BDMDATA0, address_to_write ); + MCFWriteReg32( dev, DMCOMMAND, 0x00231009 ); // Copy data to x9 + MCFWriteReg32( dev, BDMDATA0, data ); + MCFWriteReg32( dev, DMCOMMAND, 0x00271008 ); // Copy data to x8, and execute program. + + ret |= WaitForDoneOp( dev ); + iss->currentstateval = -1; + return ret; +} + +static int WriteWord( struct SWIOState * iss, uint32_t address_to_write, uint32_t data ) +{ + struct SWIOState * dev = iss; + + int ret = 0; + + int is_flash = 0; + if( ( address_to_write & 0xff000000 ) == 0x08000000 || ( address_to_write & 0x1FFF0000 ) == 0x1FFF0000 ) + { + // Is flash. + is_flash = 1; + } + + if( iss->statetag != STTAG( "WRSQ" ) || is_flash != iss->lastwriteflags ) + { + int did_disable_req = 0; + + if( iss->statetag != STTAG( "WRSQ" ) ) + { + MCFWriteReg32( dev, DMABSTRACTAUTO, 0x00000000 ); // Disable Autoexec. + did_disable_req = 1; + + if( iss->statetag != STTAG( "RDSQ" ) ) + { + int r = StaticUpdatePROGBUFRegs( dev ); + if( r ) return r; + } + + // Different address, so we don't need to re-write all the program regs. + // c.lw x8,0(x10) // Get the value to write. + // c.lw x9,0(x11) // Get the address to write to. + MCFWriteReg32( dev, DMPROGBUF0, 0x41844100 ); + // c.sw x8,0(x9) // Write to the address. + // c.addi x9, 4 + MCFWriteReg32( dev, DMPROGBUF1, 0x0491c080 ); + } + + if( is_flash && iss->target_chip_type == CHIP_CH32V10x) + { + // Special 16 bytes buffer write sequence for CH32V103 + MCFWriteReg32( dev, DMPROGBUF2, 0x0001c184 ); // c.sw x9,0(x11); c.nop; + MCFWriteReg32( dev, DMPROGBUF3, 0x9002e391 ); // c.bnez x15, 4; c.ebreak; + MCFWriteReg32( dev, DMPROGBUF4, 0x4200c254 ); // c.sw x13,4(x12); c.lw x8,0(x12); + MCFWriteReg32( dev, DMPROGBUF5, 0xfc758805 ); // c.andi x8, 1; c.bnez x8, -4; + MCFWriteReg32( dev, DMPROGBUF6, 0x90024781 ); // c.li x15, 0; c.ebreak; + } + else if( is_flash ) + { + // A little weird - we need to wait until the buf load is done here to continue. + // x12 = 0x4002200C (FLASH_STATR) + // + // c254 c.sw x13,4(x12) // Acknowledge the page write. (BUT ONLY ON x035 / v003) + // otherwise c.nop + // 4200 c.lw x8,0(x12) // Start checking to see when buf load is done. + // 8809 c.andi x8, 2 // Only look at WR_BSY (seems to be rather undocumented) + // 8805 c.andi x8, 1 // Only look at BSY if we're not on a v30x / v20x + // fc75 c.bnez x8, -4 + // c.ebreak + MCFWriteReg32( dev, DMPROGBUF2, 0x0001c184 ); + MCFWriteReg32( dev, DMPROGBUF3, + (iss->target_chip_type == CHIP_CH32V003 || iss->target_chip_type == CHIP_CH32V00x + || iss->target_chip_type == CHIP_CH32X03x || iss->target_chip_type == CHIP_CH32L10x + || iss->target_chip_type == CHIP_CH641 || iss->target_chip_type == CHIP_CH643) ? + 0x4200c254 : 0x42000001 ); + + MCFWriteReg32( dev, DMPROGBUF4, + (iss->target_chip_type == CHIP_CH32V20x || iss->target_chip_type == CHIP_CH32V30x ) ? + 0xfc758809 : 0xfc758805 ); + + MCFWriteReg32( dev, DMPROGBUF5, 0x90029002 ); + } + else + { + MCFWriteReg32( dev, DMPROGBUF2, 0x9002c184 ); // c.sw x9,0(x11); c.ebreak; + } + + MCFWriteReg32( dev, BDMDATA1, address_to_write ); + MCFWriteReg32( dev, BDMDATA0, data ); + + if( iss->no_autoexec ) + { + MCFWriteReg32( dev, DMCOMMAND, 0x00240000 ); // Execute. + } + else if( did_disable_req ) + { + MCFWriteReg32( dev, DMCOMMAND, 0x00240000 ); // Execute. + MCFWriteReg32( dev, DMABSTRACTAUTO, 1 ); // Enable Autoexec. + } + + iss->lastwriteflags = is_flash; + + iss->statetag = STTAG( "WRSQ" ); + iss->currentstateval = address_to_write; + } + else + { + if( address_to_write != iss->currentstateval ) + { + MCFWriteReg32( dev, BDMDATA1, address_to_write ); + } + MCFWriteReg32( dev, BDMDATA0, data ); + if( iss->no_autoexec ) + { + MCFWriteReg32( dev, DMCOMMAND, 0x00240000 ); // Execute. + } + } + if( is_flash ) + ret |= WaitForDoneOp( dev ); + + iss->currentstateval += 4; + + return ret; +} + +static int UnlockFlash( struct SWIOState * iss ) +{ + struct SWIOState * dev = iss; + + if( DetermineChipTypeAndSectorInfo( iss, NULL ) ) return -9; + + uint32_t rw; + ReadWord( dev, 0x40022010, &rw ); // FLASH->CTLR = 0x40022010 + if( rw & 0x8080 ) + { + + WriteWord( dev, 0x40022004, 0x45670123 ); // FLASH->KEYR = 0x40022004 + WriteWord( dev, 0x40022004, 0xCDEF89AB ); + WriteWord( dev, 0x40022008, 0x45670123 ); // OBKEYR = 0x40022008 + WriteWord( dev, 0x40022008, 0xCDEF89AB ); + WriteWord( dev, 0x40022024, 0x45670123 ); // MODEKEYR = 0x40022024 + WriteWord( dev, 0x40022024, 0xCDEF89AB ); + + ReadWord( dev, 0x40022010, &rw ); // FLASH->CTLR = 0x40022010 + if( rw & 0x8080 ) + { + return -9; + } + } + iss->statetag = STTAG( "XXXX" ); + iss->flash_unlocked = 1; + return 0; +} + +static int EraseFlash( struct SWIOState * iss, uint32_t address, uint32_t length, int type ) +{ + struct SWIOState * dev = iss; + + uint32_t rw; + + if( !iss->flash_unlocked ) + { + if( ( rw = UnlockFlash( iss ) ) ) + return rw; + } + + if( type == 1 ) + { + // Whole-chip flash + iss->statetag = STTAG( "XXXX" ); + BB_PRINTF_DEBUG( "Whole-chip erase\n" ); + WriteWord( dev, 0x40022010, 0 ); // FLASH->CTLR = 0x40022010 + WriteWord( dev, 0x40022010, FLASH_CTLR_MER ); + WriteWord( dev, 0x40022010, CR_STRT_Set|FLASH_CTLR_MER ); + if( WaitForFlash( dev ) ) return -13; + WriteWord( dev, 0x40022010, 0 ); // FLASH->CTLR = 0x40022010 + } + else + { + // 16.4.7, Step 3: Check the BSY bit of the FLASH_STATR register to confirm that there are no other programming operations in progress. + // skip (we make sure at the end) + + int chunk_to_erase = address; + + while( chunk_to_erase < address + length ) + { + if( WaitForFlash( dev ) ) return -14; + + // Step 4: set PAGE_ER of FLASH_CTLR(0x40022010) + WriteWord( dev, 0x40022010, CR_PAGE_ER ); // Actually FTER // FLASH->CTLR = 0x40022010 + + // Step 5: Write the first address of the fast erase page to the FLASH_ADDR register. + WriteWord( dev, 0x40022014, chunk_to_erase ); // FLASH->ADDR = 0x40022014 + + // Step 6: Set the STAT bit of FLASH_CTLR register to '1' to initiate a fast page erase (64 bytes) action. + WriteWord( dev, 0x40022010, CR_STRT_Set|CR_PAGE_ER ); // FLASH->CTLR = 0x40022010 + if( WaitForFlash( dev ) ) return -15; + + WriteWord( dev, 0x40022010, 0 ); // FLASH->CTLR = 0x40022010 (Disable any pending ops) + chunk_to_erase+=64; + } + } + return 0; +} + +static int WriteBlock( struct SWIOState * iss, uint32_t address_to_write, uint8_t * blob, uint8_t len, uint8_t erase ) +{ + struct SWIOState * dev = iss; + + if( DetermineChipTypeAndSectorInfo( iss, NULL ) ) return -9; + + const int blob_size = len; + uint32_t wp = address_to_write; + uint32_t ew = wp + blob_size; + int group = -1; + int is_flash = 0; + int rw = 0; + + if( (address_to_write & 0xff000000) == 0x08000000 || (address_to_write & 0xff000000) == 0x00000000 || (address_to_write & 0x1FFF0000) == 0x1FFF0000 ) + { + // Need to unlock flash. + // Flash reg base = 0x40022000, + // FLASH_MODEKEYR => 0x40022024 + // FLASH_KEYR => 0x40022004 + + if( !iss->flash_unlocked ) + { + if( ( rw = UnlockFlash( dev ) ) ) + return rw; + } + + is_flash = 1; + + if( erase ) + { + // Only erase on first block in sector. + int block_in_sector = (wp & ( iss->sectorsize - 1 )) / blob_size; + int is_first_block = block_in_sector == 0; + + if( is_first_block ) + { + rw = EraseFlash( dev, address_to_write, blob_size, 0 ); + if( rw ) return rw; + // 16.4.6 Main memory fast programming, Step 5 + //if( WaitForFlash( dev ) ) return -11; + //WriteWord( dev, 0x40022010, FLASH_CTLR_BUF_RST ); + //if( WaitForFlash( dev ) ) return -11; + } + } + } + + /* General Note: + Most flash operations take about 3ms to complete :( + */ + + while( wp < ew ) + { + if( is_flash ) + { + group = (wp & 0xffffffc0); + + int block_in_sector = (group & ( iss->sectorsize - 1 )) / blob_size; + int is_first_block = block_in_sector == 0; + int is_last_block = block_in_sector == (iss->sectorsize / blob_size - 1 ); + + if( is_first_block ) + { + if( dev->target_chip_type == CHIP_CH32V20x || dev->target_chip_type == CHIP_CH32V30x ) + { + // No bufrst on v20x, v30x + WaitForFlash( dev ); + WriteWord( dev, 0x40022010, CR_PAGE_PG ); // THIS IS REQUIRED, (intptr_t)&FLASH->CTLR = 0x40022010 + //FTPG == CR_PAGE_PG == ((uint32_t)0x00010000) + } + else + { + // V003, x035, maybe more. + WriteWord( dev, 0x40022010, CR_PAGE_PG ); // THIS IS REQUIRED, (intptr_t)&FLASH->CTLR = 0x40022010 + WriteWord( dev, 0x40022010, CR_BUF_RST | CR_PAGE_PG ); // (intptr_t)&FLASH->CTLR = 0x40022010 + } + WaitForFlash( dev ); + } + + int j; + for( j = 0; j < blob_size/4; j++ ) + { + int index = (wp-address_to_write); + uint32_t data = 0xffffffff; + if( index + 3 < blob_size ) + { + memcpy( &data, &blob[index], 4 ); + } + else if( (int32_t)(blob_size - index) > 0 ) + { + memcpy( &data, &blob[index], blob_size - index ); + } + if( iss->target_chip_type == CHIP_CH32V10x && !((j+1)&3) ) + { + // Signal to WriteWord that we need to do a buffer load + MCFWriteReg32( dev, BDMDATA0, 1 ); + MCFWriteReg32( dev, DMCOMMAND, 0x0023100f ); + } + WriteWord( dev, wp, data ); + wp += 4; + } + + + if( ( iss->target_chip_type == CHIP_CH32V20x || iss->target_chip_type == CHIP_CH32V30x ) ) + { + if( is_last_block ) + { + WriteWord( dev, 0x40022010, CR_PAGE_PG | (1<<21) ); // Page Start + if( WaitForFlash( dev ) ) return -13; + } + } + else + { + // Datasheet says the x03x needs to have this called every group-of-16, but that's not true, it should be every 16-words. + WriteWord( dev, 0x40022014, group ); //0x40022014 -> FLASH->ADDR + WriteWord( dev, 0x40022010, CR_PAGE_PG|CR_STRT_Set ); // 0x40022010 -> FLASH->CTLR + if( WaitForFlash( dev ) ) return -16; + } + } + else + { + int index = (wp-address_to_write); + uint32_t data = 0xffffffff; + if( index + 3 < blob_size ) + { + memcpy( &data, &blob[index], 4 ); + } + else if( (int32_t)(blob_size - index) > 0 ) + { + memcpy( &data, &blob[index], blob_size - index ); + } + WriteWord( dev, wp, data ); + wp += 4; + } + } + + return 0; +} + +// Polls up to 7 bytes of printf, and can leave a 7-bit flag for the CH32V003. +static int PollTerminal( struct SWIOState * iss, uint8_t * buffer, int maxlen, uint32_t leavevalA, uint32_t leavevalB ) +{ + struct SWIOState * dev = iss; + + int r; + uint32_t rr; + if( iss->statetag != STTAG( "TERM" ) ) + { + MCFWriteReg32( dev, DMABSTRACTAUTO, 0x00000000 ); // Disable Autoexec. + iss->statetag = STTAG( "TERM" ); + } + r = MCFReadReg32( dev, BDMDATA0, &rr ); + if( r < 0 ) return r; + + if( maxlen < 8 ) return -9; + + // BDMDATA1: + // bit 7 = host-acknowledge. + if( rr & 0x80 ) + { + int ret = 0; + int num_printf_chars = (rr & 0xf)-4; + + if( num_printf_chars > 0 && num_printf_chars <= 7) + { + if( num_printf_chars > 3 ) + { + uint32_t r2; + r = MCFReadReg32( dev, BDMDATA1, &r2 ); + memcpy( buffer+3, &r2, num_printf_chars - 3 ); + } + int firstrem = num_printf_chars; + if( firstrem > 3 ) firstrem = 3; + memcpy( buffer, ((uint8_t*)&rr)+1, firstrem ); + buffer[num_printf_chars] = 0; + ret = num_printf_chars; + } + if( leavevalA ) + { + MCFWriteReg32( dev, BDMDATA1, leavevalB ); + } + MCFWriteReg32( dev, BDMDATA0, leavevalA ); // Write that we acknowledge the data. + return ret; + } + else + { + return 0; + } +} + +#endif // _CH32V003_SWIO_H diff --git a/fw/programmer/src/bitbang_rvswdio_pico.h b/fw/programmer/src/bitbang_rvswdio_pico.h new file mode 100644 index 0000000..e8ffdc8 --- /dev/null +++ b/fw/programmer/src/bitbang_rvswdio_pico.h @@ -0,0 +1,219 @@ +#include +#include + +#include "bitbang_rvswdio.h" +#include "hardware/timer.h" +#include "lwipopts.h" +#include "pico.h" + + +#define PIN_SWDIO 10 +#define PIN_SWCLK 11 + + +// open drain emulation, the pin is set with output '0' and is switched between input or output +// depending on the wanted value, in the high state the line is pulled high by the pull-up and +// in the low state the line in forced low +#define OD_PULL(pin, value) gpio_set_dir((pin), (value) ? GPIO_IN : GPIO_OUT) + +// wait time between line transitions +#define SWD_DELAY() busy_wait_us(1); + +// microseconds between each register read/write +#define STOP_WAIT 8 + +// Single wire debug (SWDIO and SWCLK) +static inline void ConfigureIOForRVSWD(void) +{ + // SWDIO, open drain (emulated) with pull-up + gpio_init(PIN_SWDIO); + gpio_set_pulls(PIN_SWDIO, true, false); + gpio_put(PIN_SWDIO, 0); + gpio_set_dir(PIN_SWDIO, GPIO_IN); + + gpio_init(PIN_SWCLK); + gpio_set_pulls(PIN_SWCLK, false, false); + gpio_put(PIN_SWCLK, 0); + gpio_set_dir(PIN_SWCLK, GPIO_OUT); +} + + +// Single wire input-output SDI (just SWDIO) +static inline void ConfigureIOForRVSWIO(void) +{ + BB_PRINTF_DEBUG( "TODO: add support for SWIO\n" ); +} + + +static inline void rvswd_start(void) +{ + // Start with both lines high + gpio_put(PIN_SWCLK, 1); + OD_PULL(PIN_SWDIO, 1); + //SWD_DELAY(); + + // Pull data low + OD_PULL(PIN_SWDIO, 0); + SWD_DELAY(); +} + + +static inline void rvswd_stop(void) +{ + gpio_put(PIN_SWCLK, 0); + SWD_DELAY(); + + OD_PULL(PIN_SWDIO, 0); + SWD_DELAY(); + + gpio_put(PIN_SWCLK, 1); + SWD_DELAY(); + + OD_PULL(PIN_SWDIO, 1); +} + + +void rvswd_write_bit(bool value) +{ + gpio_put(PIN_SWCLK, 0); + OD_PULL(PIN_SWDIO, value); + SWD_DELAY(); + gpio_put(PIN_SWCLK, 1); // Data is sampled on rising edge of clock + SWD_DELAY(); +} + + +bool rvswd_read_bit(void) +{ + OD_PULL(PIN_SWDIO, 0); + gpio_put(PIN_SWCLK, 0); + OD_PULL(PIN_SWDIO, 1); + SWD_DELAY(); + bool bit = gpio_get(PIN_SWDIO); + + gpio_put(PIN_SWCLK, 1); // Data is output on rising edge of clock + SWD_DELAY(); + return bit; +} + + +static void MCFWriteReg32( struct SWIOState * state, uint8_t command, uint32_t value ) +{ + // only supported mode is SWD + if (state->opmode != 2) { + BB_PRINTF_DEBUG( "TODO: add support for SWIO\n" ); + return; + } + + noInterrupts(); + rvswd_start(); + + // ADDR HOST + bool parity = false; // This time it's odd parity? + for (uint8_t position = 0; position < 7; position++) { + bool bit = (command >> (6 - position)) & 1; + rvswd_write_bit(bit); + if (bit) parity = !parity; + } + + // Operation: write + rvswd_write_bit(1); + parity = !parity; + + // Parity bit (even) + rvswd_write_bit(parity); + + rvswd_read_bit(); // ??? + rvswd_read_bit(); // Seems only need to be set for first transaction (We are ignoring that though) + rvswd_read_bit(); // ??? + rvswd_write_bit(0); // 0 for register, 1 for value. + rvswd_write_bit(0); // ??? Seems to have something to do with halting. + + // Data + parity = false; // This time it's even parity? + for (uint8_t position = 0; position < 32; position++) { + bool bit = (value >> (31 - position)) & 1; + rvswd_write_bit(bit); + if (bit) parity = !parity; + } + + // Parity bit + rvswd_write_bit(parity); + + rvswd_read_bit(); // ??? + rvswd_read_bit(); // ??? + rvswd_read_bit(); // ??? + rvswd_write_bit(1); // 0 for register, 1 for value + rvswd_write_bit(0); // ??? Seems to have something to do with halting? + + rvswd_stop(); + interrupts(); + sleep_us(STOP_WAIT); +} + + +static int MCFReadReg32( struct SWIOState * state, uint8_t command, uint32_t * value ) +{ + // only supported mode is SWD + if (state->opmode != 2) { + BB_PRINTF_DEBUG( "TODO: add support for SWIO\n" ); + return -1; + } + + bool parity; + + noInterrupts(); + rvswd_start(); + + // ADDR HOST + parity = false; + for (uint8_t position = 0; position < 7; position++) { + bool bit = (command >> (6 - position)) & 1; + rvswd_write_bit(bit); + if (bit) parity = !parity; + } + + // Operation: read + rvswd_write_bit(0); + + // Parity bit (even) + rvswd_write_bit(parity); + + rvswd_read_bit(); // ?? + rvswd_read_bit(); // ?? + rvswd_read_bit(); // ?? + + rvswd_write_bit(0); // 0 for register, 1 for value + rvswd_write_bit(0); // ??? Seems to have something to do with halting? + + *value = 0; + + // Data + parity = false; + uint32_t rval = 0; + for (uint8_t position = 0; position < 32; position++) { + bool bit = rvswd_read_bit(); + rval <<= 1; + if (bit) { + rval |= 1; + parity ^= 1; + } + } + *value = rval; + + // Parity bit + bool parity_read = rvswd_read_bit(); + + rvswd_read_bit(); // ?? + rvswd_read_bit(); // ?? + rvswd_read_bit(); // ?? + + rvswd_write_bit(1); // 1 for data + rvswd_write_bit(0); // ??? Seems to have something to do with halting? + + rvswd_stop(); + interrupts(); + + sleep_us(STOP_WAIT); + return (parity == parity_read) ? 0 : -1; +} diff --git a/fw/programmer/src/main.cpp b/fw/programmer/src/main.cpp new file mode 100644 index 0000000..df6993a --- /dev/null +++ b/fw/programmer/src/main.cpp @@ -0,0 +1,90 @@ + #include "pico/time.h" + #include + #include + + //#define BB_PRINTF_DEBUG(...) Serial.printf(__VA_ARGS__) + #define BB_PRINTF_DEBUG(...) + #include "bitbang_rvswdio.h" + #include "bitbang_rvswdio_pico.h" + + #define PROTOCOL_START '!' + #define PROTOCOL_ACK '+' + #define PROTOCOL_TEST '?' + #define PROTOCOL_POWER_ON 'p' + #define PROTOCOL_POWER_OFF 'P' + #define PROTOCOL_WRITE_REG 'w' + #define PROTOCOL_READ_REG 'r' + + bool last_dtr = false; + SWIOState state = {.opmode = 2}; + + void setup() { + Serial.begin(115200); + Serial.setTimeout(100); + ConfigureIOForRVSWD(); + + // We do NOT block waiting for Serial here, + // we handle the connection dynamically in the loop. + } + + + void setup1() + { + pinMode(LED_BUILTIN, OUTPUT); + } + + + void loop() { + // Monitor DTR line to simulate Arduino Reset behavior + bool current_dtr = Serial.dtr(); + if (current_dtr && !last_dtr) { + // minichlink just opened the port + ConfigureIOForRVSWD(); + while (Serial.available() > 0) { Serial.read(); } + delay(100); + Serial.write(PROTOCOL_START); // Announce readiness + } + last_dtr = current_dtr; + + if (Serial.available() > 0) { + char cmd = Serial.read(); + uint8_t reg; + uint32_t val; + + switch (cmd) { + case PROTOCOL_TEST: + Serial.write(PROTOCOL_ACK); + break; + case PROTOCOL_POWER_ON: + // Not needed for rvswd + sleep_us(10); + Serial.write(PROTOCOL_ACK); + break; + case PROTOCOL_POWER_OFF: + // Not needed for rvswd + sleep_us(10); + Serial.write(PROTOCOL_ACK); + break; + case PROTOCOL_WRITE_REG: + if (Serial.readBytes((char*)®, sizeof(uint8_t)) != 1) break; + if (Serial.readBytes((char*)&val, sizeof(uint32_t)) != 4) break; + MCFWriteReg32(&state, reg, val); + Serial.write(PROTOCOL_ACK); + break; + case PROTOCOL_READ_REG: + if (Serial.readBytes((char*)®, sizeof(uint8_t)) != 1) break; + MCFReadReg32(&state, reg, &val); + Serial.write((char*)&val, sizeof(uint32_t)); + break; + } + } + } + + + void loop1() + { + digitalWrite(LED_BUILTIN, 1); + delay(200); + digitalWrite(LED_BUILTIN, 0); + delay(200); + } diff --git a/fw/programmer/test/rvswd.c b/fw/programmer/test/rvswd.c new file mode 100644 index 0000000..a80c948 --- /dev/null +++ b/fw/programmer/test/rvswd.c @@ -0,0 +1,199 @@ +#include "rvswd.h" +#include +#include +#include +#include + + +// adapted from https://github.com/Nicolai-Electronics/esp32-component-rvswd + +rvswd_result_t rvswd_init(rvswd_handle_t* handle) { + //gpio_config_t swio_cfg = { + // .pin_bit_mask = BIT64(handle->swdio), + // .mode = GPIO_MODE_INPUT_OUTPUT_OD, + // .pull_up_en = true, + // .pull_down_en = false, + // .intr_type = GPIO_INTR_DISABLE, + //}; + gpio_init(handle->swdio); + gpio_set_pulls(handle->swdio, true, false); + gpio_put(handle->swdio, 0); + gpio_set_dir(handle->swdio, GPIO_IN); + + //gpio_config_t swck_cfg = { + // .pin_bit_mask = BIT64(handle->swclk), + // .mode = GPIO_MODE_OUTPUT, + // .pull_up_en = false, + // .pull_down_en = false, + // .intr_type = GPIO_INTR_DISABLE, + //}; + gpio_init(handle->swclk); + gpio_set_pulls(handle->swclk, false, false); + gpio_put(handle->swclk, 0); + gpio_set_dir(handle->swclk, GPIO_OUT); + + return RVSWD_OK; +} + +rvswd_result_t rvswd_start(rvswd_handle_t* handle) { + // Start with both lines high + // open drain emulation, input for high (pulled up) and out for low (forced) + gpio_set_dir(handle->swdio, GPIO_IN); // high + gpio_put(handle->swclk, 1); + sleep_us(2); + + // Pull data low + gpio_set_dir(handle->swdio, GPIO_OUT); // low + gpio_put(handle->swclk, 1); + sleep_us(1); + + // Pull clock low + gpio_set_dir(handle->swdio, GPIO_OUT); // low + gpio_put(handle->swclk, 0); + sleep_us(1); + + return RVSWD_OK; +} + +rvswd_result_t rvswd_stop(rvswd_handle_t* handle) { + // Pull data low + gpio_set_dir(handle->swdio, GPIO_OUT); + sleep_us(1); + gpio_put(handle->swclk, 1); + sleep_us(2); + + // Let data float high + gpio_set_dir(handle->swdio, GPIO_IN); + sleep_us(1); + return RVSWD_OK; +} + +rvswd_result_t rvswd_reset(rvswd_handle_t* handle) { + // set data floating high + gpio_set_dir(handle->swdio, GPIO_IN); + sleep_us(1); + // let clock go brrr + for (uint8_t i = 0; i < 100; i++) { + gpio_put(handle->swclk, 0); + sleep_us(1); + gpio_put(handle->swclk, 1); + sleep_us(1); + } + return rvswd_stop(handle); +} + +#define OD_PULL(pin, value) gpio_set_dir((pin), (value) ? GPIO_IN : GPIO_OUT) + +void rvswd_write_bit(rvswd_handle_t* handle, bool value) { + OD_PULL(handle->swdio, value); + gpio_put(handle->swclk, 0); + // FIXME: does this need a delay? + gpio_put(handle->swclk, 1); // Data is sampled on rising edge of clock +} + +bool rvswd_read_bit(rvswd_handle_t* handle) { + // let data float high + gpio_set_dir(handle->swdio, GPIO_IN); + // pulse clock + gpio_put(handle->swclk, 0); + gpio_put(handle->swclk, 1); // Data is output on rising edge of clock + // FIXME: does this need a delay? + return gpio_get(handle->swdio); +} + +rvswd_result_t rvswd_write(rvswd_handle_t* handle, uint8_t reg, uint32_t value) { + rvswd_start(handle); + + // ADDR HOST + bool parity = false; // This time it's odd parity? + for (uint8_t position = 0; position < 7; position++) { + bool bit = (reg >> (6 - position)) & 1; + rvswd_write_bit(handle, bit); + if (bit) parity = !parity; + } + + // Operation: write + rvswd_write_bit(handle, true); + parity = !parity; + + // Parity bit (even) + rvswd_write_bit(handle, parity); + + rvswd_write_bit(handle, 1); + rvswd_write_bit(handle, 0); + rvswd_write_bit(handle, 1); + rvswd_write_bit(handle, 0); + rvswd_write_bit(handle, 1); + + // Data + parity = false; // This time it's even parity? + for (uint8_t position = 0; position < 32; position++) { + bool bit = (value >> (31 - position)) & 1; + rvswd_write_bit(handle, bit); + if (bit) parity = !parity; + } + + // Parity bit + rvswd_write_bit(handle, parity); + + rvswd_write_bit(handle, 1); + rvswd_write_bit(handle, 0); + rvswd_write_bit(handle, 1); + rvswd_write_bit(handle, 1); + rvswd_write_bit(handle, 1); + + rvswd_stop(handle); + + return RVSWD_OK; +} + +rvswd_result_t rvswd_read(rvswd_handle_t* handle, uint8_t reg, uint32_t* value) { + bool parity; + + rvswd_start(handle); + + // ADDR HOST + parity = false; + for (uint8_t position = 0; position < 7; position++) { + bool bit = (reg >> (6 - position)) & 1; + rvswd_write_bit(handle, bit); + if (bit) parity = !parity; + } + + // Operation: read + rvswd_write_bit(handle, false); + + // Parity bit (even) + rvswd_write_bit(handle, parity); + + rvswd_write_bit(handle, 1); + rvswd_write_bit(handle, 0); + rvswd_write_bit(handle, 1); + rvswd_write_bit(handle, 0); + rvswd_write_bit(handle, 1); + + *value = 0; + + // Data + parity = false; + for (uint8_t position = 0; position < 32; position++) { + bool bit = rvswd_read_bit(handle); + if (bit) { + *value |= 1 << (31 - position); + } + if (bit) parity = !parity; + } + + // Parity bit + bool parity_read = rvswd_read_bit(handle); + + rvswd_write_bit(handle, 1); + rvswd_write_bit(handle, 0); + rvswd_write_bit(handle, 1); + rvswd_write_bit(handle, 1); + rvswd_write_bit(handle, 1); + + rvswd_stop(handle); + + return (parity == parity_read) ? RVSWD_OK : RVSWD_FAIL; +} diff --git a/fw/programmer/test/rvswd.h b/fw/programmer/test/rvswd.h new file mode 100644 index 0000000..dd43d31 --- /dev/null +++ b/fw/programmer/test/rvswd.h @@ -0,0 +1,20 @@ +#pragma once + +#include + +typedef struct rvswd_handle { + int swdio; + int swclk; +} rvswd_handle_t; + +typedef enum rvswd_result { + RVSWD_OK = 0, + RVSWD_FAIL = 1, + RVSWD_INVALID_ARGS = 2, + RVSWD_PARITY_ERROR = 3, +} rvswd_result_t; + +rvswd_result_t rvswd_init(rvswd_handle_t* handle); +rvswd_result_t rvswd_reset(rvswd_handle_t* handle); +rvswd_result_t rvswd_write(rvswd_handle_t* handle, uint8_t reg, uint32_t value); +rvswd_result_t rvswd_read(rvswd_handle_t* handle, uint8_t reg, uint32_t* value); From a51793e529de7b8f9cdc02ce3264854a8b49b838 Mon Sep 17 00:00:00 2001 From: Alessandro Mauri Date: Sun, 5 Apr 2026 01:31:47 +0200 Subject: [PATCH 2/3] better ignore --- fw/.gitignore | 6 ++++++ fw/blink.c | 5 ++++- 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/fw/.gitignore b/fw/.gitignore index 5484688..23a0ed5 100644 --- a/fw/.gitignore +++ b/fw/.gitignore @@ -1,3 +1,9 @@ .zen .vscode .ccls-cache +.cache +*.bin +*.lst +*.map +*.elf +*.hex \ No newline at end of file diff --git a/fw/blink.c b/fw/blink.c index 24f11e2..56dcc6e 100644 --- a/fw/blink.c +++ b/fw/blink.c @@ -1,6 +1,9 @@ #include int main(void) { - while(true); + unsigned int x = 0; + while(true) { + x = x+1; + } return 0; } From 920d0a46c3043ed7c89bccf764fcabd8a3401609 Mon Sep 17 00:00:00 2001 From: Alessandro Mauri Date: Sun, 5 Apr 2026 01:32:08 +0200 Subject: [PATCH 3/3] technical manuals of the mcu --- fw/CH32X035DS0.pdf | Bin 0 -> 766805 bytes fw/CH32X035RM.pdf | Bin 0 -> 3069728 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 fw/CH32X035DS0.pdf create mode 100644 fw/CH32X035RM.pdf diff --git a/fw/CH32X035DS0.pdf b/fw/CH32X035DS0.pdf new file mode 100644 index 0000000000000000000000000000000000000000..a08d5173b5965dfa76211aa6456ef02fb8143ebb GIT binary patch literal 766805 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