From ff7a03a75cf5d19cd3aca5e4381a8f211a5fc8c5 Mon Sep 17 00:00:00 2001 From: Zack Buhman Date: Sat, 26 Oct 2024 04:53:07 -0500 Subject: [PATCH] serial_transfer: rewrite --- client.py | 12 +- common.mk | 23 +- crc32.c | 90 ++++++++ crc32.h | 19 ++ example/example.mk | 3 +- example/macaw.cpp | 5 + example/serial_transfer.cpp | 206 ++++++++++++++---- example/sprite.cpp | 10 +- holly/core.cpp | 4 +- holly/ta_fifo_polygon_converter.cpp | 4 +- ip.lds | 48 ++++- loader.lds | 4 +- main.lds | 4 +- serial_load.cpp | 180 +++++++++------- serial_load.hpp | 40 ++-- serial_protocol.hpp | 124 +++++++++++ sh7091/serial.cpp | 13 ++ sh7091/serial.hpp | 2 + sh7091/serial_dma.hpp | 8 +- symbols.lds | 3 - tools/Makefile | 13 +- tools/command_gen.py | 37 ++++ tools/{ftdi_transfer.c => ftdi_transfer.cpp} | 216 +++++++++++-------- 23 files changed, 815 insertions(+), 253 deletions(-) create mode 100644 crc32.c create mode 100644 crc32.h create mode 100644 serial_protocol.hpp create mode 100644 tools/command_gen.py rename tools/{ftdi_transfer.c => ftdi_transfer.cpp} (56%) diff --git a/client.py b/client.py index db19a3d..696c54a 100644 --- a/client.py +++ b/client.py @@ -36,9 +36,10 @@ def symmetric(ser, b): l = [] mem = memoryview(b) i = 0 - chunk_size = 128 while i < len(b): + chunk_size = 128 + if i % 1024 == 0: print(i, end=' ') sys.stdout.flush() @@ -49,6 +50,7 @@ def symmetric(ser, b): if len(l) + chunk_size >= i: break + time.sleep(1000 / 1000000) chunk_size = min(chunk_size, len(b) - i) assert chunk_size > 0, chunk_size ser.write(mem[i:i+chunk_size]) @@ -73,12 +75,12 @@ def start_data(ser, b): size = len(b) args = struct.pack(" + +#include "crc32.h" + +// Automatically generated CRC function +// polynomial: 0x104C11DB7 +const uint32_t crc32_table[256] = { + 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, + 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, + 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, + 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, + 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, + 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, + 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, + 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, + 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, + 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, + 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, + 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, + 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, + 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, + 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, + 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, + 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, + 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, + 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, + 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, + 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, + 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, + 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, + 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, + 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, + 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, + 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, + 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, + 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, + 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, + 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, + 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, + 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, + 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, + 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, + 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, + 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, + 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, + 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, + 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, + 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, + 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, + 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, + 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, + 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, + 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, + 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, + 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, + 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, + 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, + 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, + 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, + 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, + 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, + 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, + 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, + 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, + 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, + 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, + 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, + 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, + 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, + 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, + 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4, +}; + +uint32_t +crc32_update(uint32_t crc, const uint8_t * data, uint32_t len) +{ + while (len > 0) { + crc = crc32_table[*data ^ ((crc >> 24) & 0xff)] ^ (crc << 8); + data++; + len--; + } + + return crc; +} + +uint32_t +crc32(const uint8_t * buf, uint32_t len) +{ + return crc32_update(0xffffffff, buf, len) ^ 0xffffffff; +} diff --git a/crc32.h b/crc32.h new file mode 100644 index 0000000..99fc674 --- /dev/null +++ b/crc32.h @@ -0,0 +1,19 @@ +#pragma once + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +extern const uint32_t crc32_table[256]; + +uint32_t +crc32_update(uint32_t crc, const uint8_t *data, uint32_t len); + +uint32_t +crc32(const uint8_t *buf, uint32_t len); + +#ifdef __cplusplus +} +#endif diff --git a/example/example.mk b/example/example.mk index 267748f..bcde2c1 100644 --- a/example/example.mk +++ b/example/example.mk @@ -360,7 +360,8 @@ SERIAL_TRANSFER_OBJ = \ sh7091/serial.o \ serial_load.o \ maple/maple.o \ - font/portfolio_6x8/portfolio_6x8.data.o + font/portfolio_6x8/portfolio_6x8.data.o \ + crc32.o example/serial_transfer.elf: LDSCRIPT = $(LIB)/loader.lds example/serial_transfer.elf: $(START_OBJ) $(SERIAL_TRANSFER_OBJ) diff --git a/example/macaw.cpp b/example/macaw.cpp index 0747173..24e88e4 100644 --- a/example/macaw.cpp +++ b/example/macaw.cpp @@ -160,6 +160,7 @@ void main() init_texture_memory(opb_size); uint32_t frame_ix = 0; + uint32_t frame = 0; while (true) { ta_polygon_converter_init(opb_size.total(), @@ -179,5 +180,9 @@ void main() theta += half_degree; frame_ix = (frame_ix + 1) & 1; + frame += 1; + + if (frame > 10) + break; } } diff --git a/example/serial_transfer.cpp b/example/serial_transfer.cpp index 32bfa67..0ebdb8a 100644 --- a/example/serial_transfer.cpp +++ b/example/serial_transfer.cpp @@ -14,6 +14,8 @@ #include "serial_load.hpp" +#include "crc32.h" + extern uint32_t _binary_font_portfolio_6x8 __asm("_binary_font_portfolio_6x8_portfolio_6x8_data_start"); template @@ -26,11 +28,21 @@ inline void copy(T * dst, const T * src, const int32_t n) noexcept } } -static uint8_t * framebuffer; +static uint8_t * framebuffer[2]; +static char textbuffer[2][4 * 8]; static uint32_t send_buf[1024 / 4] __attribute__((aligned(32))); static uint32_t recv_buf[1024 / 4] __attribute__((aligned(32))); +struct serial_error_counter { + uint32_t brk; + uint32_t er; + uint32_t dr; + uint32_t orer; +}; + +struct serial_error_counter error_counter; + enum struct step { IDLE = 0, DEVICE_STATUS, @@ -67,9 +79,13 @@ void send_vmu_framebuffer(maple::host_command_writer& writer, uint8_t port, uint data_fields.phase = 0; data_fields.block_number = std::byteswap(0x0000); - copy(data_fields.written_data, - reinterpret_cast(framebuffer), - maple::display::vmu::framebuffer_size); + uint8_t * fb; + if (lm == ap::lm_bus::_0) + fb = framebuffer[0 ^ (port & 1)]; + else + fb = framebuffer[1 ^ (port & 1)]; + + copy(data_fields.written_data, fb, maple::display::vmu::framebuffer_size); } void recv_extension_device_status(struct maple_display_poll_state &state) @@ -213,7 +229,7 @@ void handle_maple(struct maple_display_poll_state& state) } } -void render_glyphs(maple::display::font_renderer& renderer, char * s) +void render_glyphs(maple::display::font_renderer& renderer, const char * s) { for (int i = 0; i < 8 * 4; i++) { int x = i % 8; @@ -222,23 +238,117 @@ void render_glyphs(maple::display::font_renderer& renderer, char * s) } } -void render_serial_state(maple::display::font_renderer& renderer, char * s, const char * msg) +void render_str(const char * src, char * dst) +{ + int i = 0; + char c; + while ((c = src[i]) != 0) { + dst[i] = c; + i++; + } +} + +void render_line(const char * src, char * dst, int src_len = 8) { bool end = false; for (int i = 0; i < 8; i++) { - if (end || msg[i] == 0) { - s[0 + i] = ' '; + if (end || src[i] == 0 || i >= src_len) { + dst[i] = ' '; end = true; } else { - s[0 + i] = msg[i]; + dst[i] = src[i]; } } +} + +void render_clear(char * dst, int len) +{ + for (int i = 0; i < len; i++) + dst[i] = ' '; +} + +void render_u32(uint32_t src, char * dst) +{ char num_buf[8]; - string::hex(num_buf, 8, sh7091.SCIF.SCFSR2); - for (int i = 0; i < 8; i++) s[8 + i] = num_buf[i]; - string::hex(num_buf, 8, sh7091.SCIF.SCFDR2); - for (int i = 0; i < 8; i++) s[16 + i] = num_buf[i]; - render_glyphs(renderer, s); + string::hex(num_buf, 8, src); + for (int i = 0; i < 8; i++) dst[i] = num_buf[i]; +} + +void render_u8(uint32_t src, char * dst) +{ + char num_buf[2]; + string::hex(num_buf, 2, src); + for (int i = 0; i < 2; i++) dst[i] = num_buf[i]; +} + +void render_idle_state(char * dst) +{ + render_line("idle", &dst[0]); + render_u32(serial_load::state.buf.u32[0], &dst[8]); + render_u32(serial_load::state.buf.u32[1], &dst[16]); + render_u8(serial_load::state.len, &dst[24]); + render_clear(&dst[26], 6); +} + +void render_write_state(char * dst) +{ + render_line("write", &dst[0]); + render_u32(sh7091.DMAC.DMATCR1, &dst[8]); + render_u32(sh7091.DMAC.DAR1, &dst[16]); + render_u32(serial_load::state.write_crc.value, &dst[24]); +} + +void render_fsm_state(char * dst) +{ + using namespace serial_load; + switch (state.fsm_state) { + case fsm_state::idle: + render_idle_state(dst); + break; + case fsm_state::write: + render_write_state(dst); + break; + case fsm_state::read: + render_line("read", &dst[0]); + render_clear(&dst[8], 24); + break; + case fsm_state::jump: + render_line("jump", &dst[0]); + render_clear(&dst[8], 24); + break; + case fsm_state::speed: + render_line("speed", &dst[0]); + render_clear(&dst[8], 24); + break; + default: + render_line("invalid", &dst[0]); + render_clear(&dst[8], 24); + break; + } +} + +void render_error_counter_state(char * dst) +{ + render_str("br", &dst[0]); + render_u8(error_counter.brk, &dst[2]); + render_str("er", &dst[4]); + render_u8(error_counter.er, &dst[6]); + render_str("dr", &dst[8]); + render_u8(error_counter.dr, &dst[10]); + render_str("oe", &dst[12]); + render_u8(error_counter.orer, &dst[14]); + + render_u32(sh7091.SCIF.SCFSR2, &dst[16]); + render_u32(sh7091.SCIF.SCLSR2, &dst[24]); +} + +void render(maple::display::font_renderer& renderer0, + maple::display::font_renderer& renderer1) +{ + render_fsm_state(textbuffer[0]); + render_error_counter_state(textbuffer[1]); + render_glyphs(renderer0, textbuffer[0]); + render_glyphs(renderer1, textbuffer[1]); } void main() __attribute__((section(".text.main"))); @@ -249,16 +359,12 @@ void main() struct maple_display_poll_state state = {0}; const uint8_t * font = reinterpret_cast(&_binary_font_portfolio_6x8); - auto renderer = maple::display::font_renderer(font); - framebuffer = renderer.fb; - char s[33] = - "1562500 " // 0 - " " // 8 - " " // 16 - " "; // 24 - render_glyphs(renderer, s); - state.want_start = 1; + auto renderer0 = maple::display::font_renderer(font); + framebuffer[0] = renderer0.fb; + auto renderer1 = maple::display::font_renderer(font); + framebuffer[1] = renderer1.fb; + state.want_start = 1; serial_load::init(); // reset serial status @@ -266,35 +372,57 @@ void main() // reset line status sh7091.SCIF.SCLSR2 = 0; + uint32_t last_scfsr2 = -1; + uint32_t last_sclsr2 = -1; + serial::string("ready\n"); + error_counter.brk = 0; + error_counter.er = 0; + error_counter.dr = 0; + error_counter.orer = 0; + while (1) { using namespace scif; const uint16_t scfsr2 = sh7091.SCIF.SCFSR2; + const uint16_t sclsr2 = sh7091.SCIF.SCLSR2; + if (scfsr2 & scfsr2::brk::bit_mask) { - render_serial_state(renderer, s, "brk"); // clear framing error and break + error_counter.brk += 1; + error_counter.er += (scfsr2 & scfsr2::er::bit_mask) != 0; + sh7091.SCIF.SCFSR2 = scfsr2 & ~(scfsr2::brk::bit_mask | scfsr2::er::bit_mask); + serial_load::init(); + serial::reset_txrx(); } else if (scfsr2 & scfsr2::er::bit_mask) { - render_serial_state(renderer, s, "er"); + // clear framing error + error_counter.er += 1; + sh7091.SCIF.SCFSR2 = scfsr2 & ~scfsr2::er::bit_mask; } else if (scfsr2 & scfsr2::dr::bit_mask) { - render_serial_state(renderer, s, "dr"); - } else if (sh7091.SCIF.SCLSR2 & sclsr2::orer::bit_mask) { - render_serial_state(renderer, s, "orer"); + error_counter.dr += 1; + sh7091.SCIF.SCFSR2 = scfsr2 & ~scfsr2::dr::bit_mask; + } else if (sclsr2 & sclsr2::orer::bit_mask) { + error_counter.orer += 1; + sh7091.SCIF.SCLSR2 = scfsr2 & ~sclsr2::orer::bit_mask; } else if (scfsr2 & scfsr2::rdf::bit_mask) { - render_serial_state(renderer, s, "rdf"); - const uint8_t c = sh7091.SCIF.SCFRDR2; - serial_load::recv(c); - } else { - render_serial_state(renderer, s, "idle"); + if (serial_load::state.fsm_state == serial_load::fsm_state::idle) { + while (sh7091.SCIF.SCFSR2 & scfsr2::rdf::bit_mask) { + const uint8_t c = sh7091.SCIF.SCFRDR2; + serial_load::recv(c); + sh7091.SCIF.SCFSR2 = scfsr2 & ~scfsr2::rdf::bit_mask; + } + } } - state.want_start = 1; + serial_load::tick(); + render(renderer0, renderer1); + + //if (sclsr2 != last_sclsr2 || scfsr2 != last_scfsr2) { + state.want_start = 1; + //} + last_scfsr2 = scfsr2; + last_sclsr2 = sclsr2; handle_maple(state); - - uint16_t error_bits = scfsr2::er::bit_mask | scfsr2::brk::bit_mask; - if (sh7091.SCIF.SCFSR2 & error_bits) { - sh7091.SCIF.SCFSR2 = ~error_bits; - } } } diff --git a/example/sprite.cpp b/example/sprite.cpp index 3e91ece..e9f0510 100644 --- a/example/sprite.cpp +++ b/example/sprite.cpp @@ -16,6 +16,8 @@ #include "holly/background.hpp" #include "holly/region_array.hpp" +#include "sh7091/serial.hpp" + struct vertex { float x; float y; @@ -86,15 +88,15 @@ void init_texture_memory(const struct opb_size& opb_size) background_parameter(0xff220000); } -uint32_t _ta_parameter_buf[((32 + 64 + 32) + 32) / 4]; - void main() { + serial::init(4); + serial::string("main\n"); video_output::set_mode_vga(); // The address of `ta_parameter_buf` must be a multiple of 32 bytes. // This is mandatory for ch2-dma to the ta fifo polygon converter. - uint32_t * ta_parameter_buf = align_32byte(_ta_parameter_buf); + uint32_t ta_parameter_buf[32 + 64 + 32 / 4] __attribute__((aligned(32))); constexpr uint32_t ta_alloc = ta_alloc_ctrl::pt_opb::no_list | ta_alloc_ctrl::tm_opb::no_list @@ -118,6 +120,8 @@ void main() uint32_t frame_ix = 0; + serial::string("while true\n"); + while (true) { ta_polygon_converter_init(opb_size.total(), ta_alloc, diff --git a/holly/core.cpp b/holly/core.cpp index 1a42593..c6799db 100644 --- a/holly/core.cpp +++ b/holly/core.cpp @@ -116,8 +116,8 @@ void core_wait_end_of_render_video() */ while ((system.ISTNRM & istnrm::end_of_render_tsp) == 0) { if (system.ISTERR) { - serial::string("core "); - serial::integer(system.ISTERR); + //serial::string("core "); + //serial::integer(system.ISTERR); holly.SOFTRESET = softreset::pipeline_soft_reset; holly.SOFTRESET = 0; break; diff --git a/holly/ta_fifo_polygon_converter.cpp b/holly/ta_fifo_polygon_converter.cpp index d59f3ef..4f4f3f0 100644 --- a/holly/ta_fifo_polygon_converter.cpp +++ b/holly/ta_fifo_polygon_converter.cpp @@ -142,8 +142,8 @@ void ta_wait_opaque_list() { while ((system.ISTNRM & istnrm::end_of_transferring_opaque_list) == 0) { if (system.ISTERR) { - serial::string("ta ISTERR: "); - serial::integer(system.ISTERR); + //serial::string("ta ISTERR: "); + //serial::integer(system.ISTERR); } }; diff --git a/ip.lds b/ip.lds index 73aa034..01c8d10 100644 --- a/ip.lds +++ b/ip.lds @@ -2,12 +2,14 @@ OUTPUT_FORMAT("elf32-shl", "elf32-shl", "elf32-shl") MEMORY { - systemid (arx) : ORIGIN = 0x8c008000, LENGTH = 0x100 - toc (arx) : ORIGIN = 0x8c008100, LENGTH = 0x200 - sg_sec (arx) : ORIGIN = 0x8c008300, LENGTH = 0x3400 - sg_are (arx) : ORIGIN = 0x8c00b700, LENGTH = 0x100 - sg_ini (arx) : ORIGIN = 0x8c00b800, LENGTH = 0x2800 - aip (arx) : ORIGIN = 0x8c00e000, LENGTH = 0x2000 + systemid : ORIGIN = 0x8c008000, LENGTH = 0x100 + toc : ORIGIN = 0x8c008100, LENGTH = 0x200 + sg_sec : ORIGIN = 0x8c008300, LENGTH = 0x3400 + sg_are : ORIGIN = 0x8c00b700, LENGTH = 0x100 + sg_ini : ORIGIN = 0x8c00b800, LENGTH = 0x4800 +/* sg_ini : ORIGIN = 0x8c00b800, LENGTH = 0x2800 */ +/* aip : ORIGIN = 0x8c00e000, LENGTH = 0x2000 */ + p1ram : ORIGIN = 0x8c010000, LENGTH = 0xff0000 } SECTIONS @@ -42,14 +44,22 @@ SECTIONS .text.sg_ini : { KEEP(*(.text.*sg_ini)) + KEEP(*(.text.start)) + *(.text.startup.*) + *(.text*) + *(.rodata*) + *(.bss*) + *(.data*) . = ORIGIN(sg_ini) + LENGTH(sg_ini); } > sg_ini +/* .text.aip : { KEEP(*(.text.*aip)) . = ORIGIN(aip) + LENGTH(aip); } > aip + */ /DISCARD/ : { @@ -61,3 +71,29 @@ SECTIONS INCLUDE "debug.lds" } +__stack_reservation = 0x1000; +__stack_end = ORIGIN(p1ram) + LENGTH(p1ram) - __stack_reservation; + +__text_link_start = 0; +__text_link_end = 0; +__text_load_start = 0; + +__data_link_start = 0; +__data_link_end = 0; +__data_load_start = 0; + +__rodata_link_start = 0; +__rodata_link_end = 0; +__rodata_load_start = 0; + +__ctors_link_start = 0; +__ctors_link_end = 0; + +__bss_link_start = 0; +__bss_link_end = 0; + +__vbr_link_start = 0; +__vbr_link_end = 0; +__vbr_load_end = 0; + +INCLUDE "addresses.lds" diff --git a/loader.lds b/loader.lds index ce467d1..8fb732f 100644 --- a/loader.lds +++ b/loader.lds @@ -68,6 +68,8 @@ SECTIONS INCLUDE "debug.lds" } -__stack_reservation = 0x0; + INCLUDE "symbols.lds" INCLUDE "addresses.lds" + +__stack_end = 0x8c008000; diff --git a/main.lds b/main.lds index 94bfbc3..4077b02 100644 --- a/main.lds +++ b/main.lds @@ -4,5 +4,7 @@ MEMORY p1ram : ORIGIN = 0x8c010000, LENGTH = 0xff0000 p2ram : ORIGIN = 0xac010000, LENGTH = 0xff0000 } -__stack_reservation = 0x1000; + INCLUDE "common.lds" + +__stack_end = ORIGIN(p1ram) + LENGTH(p1ram) - 0x2000; diff --git a/serial_load.cpp b/serial_load.cpp index 9bc6d3f..0091dc4 100644 --- a/serial_load.cpp +++ b/serial_load.cpp @@ -1,7 +1,10 @@ #include #include "sh7091/serial.hpp" +#include "sh7091/serial_dma.hpp" + #include "serial_load.hpp" +#include "crc32.h" namespace serial_load { @@ -23,10 +26,11 @@ static void move(void *dst, const void *src, uint32_t n) void init() { state.len = 0; - state.command = CMD_NONE; + state.fsm_state = fsm_state::idle; + sh7091.DMAC.CHCR1 = 0; } -static void jump_to_func(const uint32_t addr) +void jump_to_func(const uint32_t addr) { serial::string("jump to: "); serial::integer(addr); @@ -44,87 +48,117 @@ static void jump_to_func(const uint32_t addr) // restore our stack } +static inline void prestart_write() +{ + uint32_t dest = state.buf.arg[0]; + uint32_t size = state.buf.arg[1]; + serial::recv_dma(dest - 1, size + 1); + state.write_crc.value = 0xffffffff; + state.write_crc.offset = dest; +} + +struct state_arglen_reply command_list[] = { + {command::write, reply::write, fsm_state::write}, + {command::read , reply::read , fsm_state::read }, + {command::jump , reply::jump , fsm_state::jump }, + {command::speed, reply::speed, fsm_state::speed}, +}; +constexpr uint32_t command_list_length = (sizeof (command_list)) / (sizeof (command_list[0])); + void recv(uint8_t c) { - while (1) { - switch (state.command) { - case CMD_NONE: - state.buf[state.len++] = c; - if (state.len >= 4) { - if (state.buf[0] == 'D' && - state.buf[1] == 'A' && - state.buf[2] == 'T' && - state.buf[3] == 'A') { - if (state.len < 12) { + state.buf.u8[state.len++] = c; + switch (state.fsm_state) { + case fsm_state::idle: + if (state.len == 16) { + for (uint32_t i = 0; i < command_list_length; i++) { + struct state_arglen_reply& sar = command_list[i]; + if (state.buf.cmd == sar.command) { + uint32_t crc = crc32(&state.buf.u8[0], 12); + if (crc == state.buf.crc) { + // valid command, do the transition + if (state.buf.cmd == command::write) prestart_write(); + state.fsm_state = sar.fsm_state; + state.len = 0; + union command_reply reply = command_reply(sar.reply, state.buf.arg[0], state.buf.arg[1]); + serial::string(reply.u8, 16); return; } else { - serial::string("data"); - state.command = CMD_DATA; + /* + union command_reply reply = crc_error_reply(crc); + serial::string(reply.u8, 16); + state.len = 0; return; + */ } - } else if (state.buf[0] == 'J' && - state.buf[1] == 'U' && - state.buf[2] == 'M' && - state.buf[3] == 'P') { - if (state.len < 8) { - return; - } else { - serial::string("jump"); - state.command = CMD_JUMP; - } - } else if (state.buf[0] == 'R' && - state.buf[1] == 'A' && - state.buf[2] == 'T' && - state.buf[3] == 'E') { - if (state.len < 8) { - return; - } else { - serial::string("rate"); - state.command = CMD_RATE; - } - } else { - move(&state.buf[0], &state.buf[1], state.len - 1); - state.len -= 1; } - } else { - return; } - break; - case CMD_DATA: - { - uint32_t * size = &state.addr1; - uint8_t * dest = reinterpret_cast(state.addr2); - if (*size > 0) { - serial::character(c); - - // write c to dest - *dest = c; - state.addr2++; - - (*size)--; - } - if (*size == 0) { - state.len = 0; - state.command = CMD_NONE; - serial::string("next"); - } - return; - break; - } - case CMD_JUMP: - // jump - state.len = 0; - state.command = CMD_NONE; - jump_to_func(state.addr1); - return; - break; - case CMD_RATE: - state.len = 0; - state.command = CMD_NONE; - serial::init(state.addr1 & 0xff); - return; + // invalid command + move(&state.buf.u8[0], &state.buf.u8[1], state.len - 1); + state.len -= 1; break; } + default: + break; + } +} + +void tick() +{ + switch (state.fsm_state) { + case fsm_state::idle: + break; + case fsm_state::write: + { + // read chcr1 before dar1 to avoid race + uint32_t chcr1 = sh7091.DMAC.CHCR1; + uint32_t dar1 = sh7091.DMAC.DAR1; + if (dar1 > state.write_crc.offset) { + uint32_t len = dar1 - state.write_crc.offset; + const uint8_t * dest = reinterpret_cast(state.write_crc.offset); + state.write_crc.value = crc32_update(state.write_crc.value, dest, len); + state.write_crc.offset += len; + } + if (chcr1 & dmac::chcr::te::transfers_completed) { + state.write_crc.value ^= 0xffffffff; + union command_reply reply = write_crc_reply(state.write_crc.value); + serial::string(reply.u8, 16); + + sh7091.DMAC.CHCR1 = 0; + + // transition to next state + state.fsm_state = fsm_state::idle; + } + } + break; + case fsm_state::read: + break; + case fsm_state::jump: + { + using namespace scif; + // wait for serial transmission to end + constexpr uint32_t transmission_end = scfsr2::tend::bit_mask | scfsr2::tdfe::bit_mask; + if ((sh7091.SCIF.SCFSR2 & transmission_end) != transmission_end) + return; + + const uint32_t dest = state.buf.arg[0]; + jump_to_func(dest); + + // transition to next state + state.fsm_state = fsm_state::idle; + } + break; + case fsm_state::speed: + { + const uint32_t speed = state.buf.arg[0]; + serial::init(speed & 0xff); + + // transition to next state + state.fsm_state = fsm_state::idle; + } + break; + default: + break; } } diff --git a/serial_load.hpp b/serial_load.hpp index 26c7d60..f18d3fd 100644 --- a/serial_load.hpp +++ b/serial_load.hpp @@ -1,28 +1,40 @@ #pragma once +#include + +#include "serial_protocol.hpp" + namespace serial_load { void init(); void recv(uint8_t c); +void tick(); -enum command { - CMD_NONE, - CMD_DATA, // DATA 0000 0000 {data} - CMD_JUMP, // JUMP 0000 - CMD_RATE, // RATE 0000 +enum struct fsm_state { + idle, + write, + read, + jump, + speed, +}; + +struct state_arglen_reply { + uint32_t command; + uint32_t reply; + enum fsm_state fsm_state; +}; + +struct incremental_crc { + uint32_t value; + uint32_t offset; }; struct state { - union { - uint8_t buf[12]; - struct { - uint8_t cmd[4]; - uint32_t addr1; - uint32_t addr2; - }; - }; + union command_reply buf; uint32_t len; - enum command command; + enum fsm_state fsm_state; + struct incremental_crc write_crc; + struct incremental_crc read_crc; }; extern struct state state; diff --git a/serial_protocol.hpp b/serial_protocol.hpp new file mode 100644 index 0000000..ba39cf6 --- /dev/null +++ b/serial_protocol.hpp @@ -0,0 +1,124 @@ +#pragma once + +#include + +#include "crc32.h" + +namespace serial_load { + +consteval uint32_t gen_cmd(const char * s) +{ + uint32_t x = 0 + | s[0] << 0 + | s[1] << 8 + | s[2] << 16 + | s[3] << 24; + + x ^= x << 13; + x ^= x >> 17; + x ^= x << 5; + + return x; +} + +namespace command { + constexpr uint32_t write = gen_cmd("WRTE"); + constexpr uint32_t read = gen_cmd("READ"); + constexpr uint32_t jump = gen_cmd("JUMP"); + constexpr uint32_t speed = gen_cmd("SPED"); + + static_assert(write == 0x2cc46ed8); + static_assert(read == 0xf18d57c7); + static_assert(jump == 0xa6696f38); + static_assert(speed == 0x27a7a9f4); +} + +namespace reply { + constexpr uint32_t write = gen_cmd("wrte"); + constexpr uint32_t read = gen_cmd("read"); + constexpr uint32_t jump = gen_cmd("jump"); + constexpr uint32_t speed = gen_cmd("sped"); + constexpr uint32_t write_crc = gen_cmd("crcW"); + + static_assert(write == 0x8c661aaa); + static_assert(read == 0x512f23b5); + static_assert(jump == 0x06cb1b4a); + static_assert(speed == 0x8705dd86); + static_assert(write_crc == 0x1cced074); +} + +union command_reply { + uint8_t u8[16]; + uint32_t u32[4]; + struct { + uint32_t cmd; + uint32_t arg[2]; + uint32_t crc; + }; +}; + +static inline uint32_t le_bswap(const uint32_t n) +{ + if constexpr (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) + return n; + else + return __builtin_bswap32(n); +} + +constexpr union command_reply command_reply(uint32_t cmd, uint32_t arg0, uint32_t arg1) +{ + union command_reply command = { + .cmd = le_bswap(cmd), + .arg = { le_bswap(arg0), le_bswap(arg1) }, + .crc = 0, + }; + command.crc = le_bswap(crc32(command.u8, 12)); + return command; +} + +constexpr union command_reply write_command(uint32_t dest, uint32_t size) +{ + return command_reply(command::write, dest, size); +} + +constexpr union command_reply read_command(uint32_t dest, uint32_t size) +{ + return command_reply(command::read, dest, size); +} + +constexpr union command_reply jump_command(uint32_t dest) +{ + return command_reply(command::jump, dest, 0); +} + +constexpr union command_reply speed_command(uint32_t speed) +{ + return command_reply(command::speed, speed, 0); +} + +constexpr union command_reply write_reply(uint32_t dest, uint32_t size) +{ + return command_reply(reply::write, dest, size); +} + +constexpr union command_reply read_reply(uint32_t dest, uint32_t size) +{ + return command_reply(reply::read, dest, size); +} + +constexpr union command_reply jump_reply(uint32_t dest) +{ + return command_reply(reply::jump, dest, 0); +} + +constexpr union command_reply speed_reply(uint32_t speed) +{ + return command_reply(reply::speed, speed, 0); +} + +constexpr union command_reply write_crc_reply(uint32_t crc) +{ + return command_reply(reply::write_crc, crc, 0); +} + +} diff --git a/sh7091/serial.cpp b/sh7091/serial.cpp index 867031e..618eed7 100644 --- a/sh7091/serial.cpp +++ b/sh7091/serial.cpp @@ -24,6 +24,19 @@ static inline void init_wait() sh7091.TMU.TSTR &= (~tmu::tstr::str1::counter_start) & 0xff; // stop TCNT1 } +void reset_txrx() +{ + using namespace scif; + + sh7091.SCIF.SCFCR2 |= ( scfcr2::tfrst::reset_operation_enabled + | scfcr2::rfrst::reset_operation_enabled + ); + + sh7091.SCIF.SCFCR2 &= ~( scfcr2::tfrst::reset_operation_enabled + | scfcr2::rfrst::reset_operation_enabled + ); +} + void init(uint8_t bit_rate) { using namespace scif; diff --git a/sh7091/serial.hpp b/sh7091/serial.hpp index 80027cd..edd8503 100644 --- a/sh7091/serial.hpp +++ b/sh7091/serial.hpp @@ -4,6 +4,8 @@ namespace serial { +void reset_txrx(); + void init(uint8_t bit_rate); void character(const char c); diff --git a/sh7091/serial_dma.hpp b/sh7091/serial_dma.hpp index b8bf603..1a2ba3f 100644 --- a/sh7091/serial_dma.hpp +++ b/sh7091/serial_dma.hpp @@ -1,5 +1,6 @@ #pragma once +#include "sh7091/sh7091.hpp" #include "sh7091/sh7091_bits.hpp" /* @@ -42,7 +43,7 @@ namespace serial { -static void recv_dma(void * destination_address, uint32_t length) +static void recv_dma(uint32_t destination_address, uint32_t length) { using namespace dmac; /* Initial settings (SAR, DAR, DMATCR, CHCR, DMAOR) */ @@ -53,13 +54,10 @@ static void recv_dma(void * destination_address, uint32_t length) // SAR1 = SCFRDR2 // DAR1 = (address) // DMATCR1 = (transfer count, 24 bit) - sh7091.DMAC.CHCR3 = 0; - sh7091.DMAC.CHCR2 = 0; sh7091.DMAC.CHCR1 = 0; - sh7091.DMAC.CHCR0 = 0; sh7091.DMAC.SAR1 = reinterpret_cast(&sh7091.SCIF.SCFRDR2); - sh7091.DMAC.DAR1 = reinterpret_cast(destination_address); + sh7091.DMAC.DAR1 = destination_address; sh7091.DMAC.DMATCR1 = length & 0x00ff'ffff; // SSA (only used for PCMCIA) diff --git a/symbols.lds b/symbols.lds index 74c01e4..3c1faa6 100644 --- a/symbols.lds +++ b/symbols.lds @@ -1,6 +1,3 @@ -/* reserve bytes for serial program loader */ -__stack_end = ORIGIN(p1ram) + LENGTH(p1ram) - __stack_reservation; - __text_link_start = ADDR(.text); __text_link_end = ADDR(.text) + SIZEOF(.text); __text_load_start = LOADADDR(.text); diff --git a/tools/Makefile b/tools/Makefile index 0a3c6c7..e2583a1 100644 --- a/tools/Makefile +++ b/tools/Makefile @@ -4,21 +4,24 @@ CXXFLAGS = -std=c++23 FREETYPE_CFLAGS = $(shell pkg-config --cflags freetype2) FREETYPE_LDFLAGS = $(shell pkg-config --libs freetype2) -FTDI_CFLAGS = $(shell pkg-config --cflags libftdi1) +FTDI_CFLAGS = $(shell pkg-config --cflags libftdi1) -I.. FTDI_LDFLAGS = $(shell pkg-config --libs libftdi1) all: ttf_outline +crc32.o: ../crc32.c + $(CC) -std=gnu2x $(CFLAGS) -I.. -c $< -o $@ + ttf_%.o: ttf_%.cpp - $(CXX) $(CFLAGS) $(FREETYPE_CFLAGS) $(CXXFLAGS) -c $< -o $@ + $(CXX) $(CFLAGS) $(CXXFLAGS) $(FREETYPE_CFLAGS) -c $< -o $@ ttf_%: ttf_%.o $(CXX) $(LDFLAGS) $(FREETYPE_LDFLAGS) $^ -o $@ -ftdi_%.o: ftdi_%.c - $(CC) -std=gnu2x $(CFLAGS) $(FTDI_CFLAGS) -c $< -o $@ +ftdi_%.o: ftdi_%.cpp + $(CXX) $(CFLAGS) $(CXXFLAGS) $(FTDI_CFLAGS) -c $< -o $@ -ftdi_%: ftdi_%.o +ftdi_%: ftdi_%.o crc32.o $(CXX) $(LDFLAGS) $(FTDI_LDFLAGS) $^ -o $@ ttf_outline: ttf_outline.o 2d_pack.o diff --git a/tools/command_gen.py b/tools/command_gen.py new file mode 100644 index 0000000..b2c9d02 --- /dev/null +++ b/tools/command_gen.py @@ -0,0 +1,37 @@ +def gen_cmd(s): + x = (0 + | s[0] << 0 + | s[1] << 8 + | s[2] << 16 + | s[3] << 24 + ) + + x ^= (x << 13) & 0xffff_ffff + x ^= (x >> 17) & 0xffff_ffff + x ^= (x << 5) & 0xffff_ffff + + return x + +commands = [ + "WRTE", + "READ", + "JUMP", + "SPED", +] + +replies = [ + "wrte", + "read", + "jump", + "sped", + "crcW", +] + +for c in commands: + x = gen_cmd(c.encode('ascii')) + print(c, f"{x:08x}") + + +for c in replies: + x = gen_cmd(c.encode('ascii')) + print(c, f"{x:08x}") diff --git a/tools/ftdi_transfer.c b/tools/ftdi_transfer.cpp similarity index 56% rename from tools/ftdi_transfer.c rename to tools/ftdi_transfer.cpp index 9c82e51..e7c9489 100644 --- a/tools/ftdi_transfer.c +++ b/tools/ftdi_transfer.cpp @@ -9,23 +9,26 @@ #include #include +#include "crc32.h" +#include "serial_protocol.hpp" + extern int convert_baudrate_UT_export(int baudrate, struct ftdi_context *ftdi, unsigned short *value, unsigned short *index); int dreamcast_rates[] = { - 1562500, - 781250, - 520833, - 390625, - 312500, - 260416, - 223214, - 195312, - 173611, - 156250, - 142045, - 130208, - 120192 + 1562500, // 0 + 781250, // 1 + 520833, // 2 + 390625, // 3 + 312500, // 4 + 260416, // 5 + 223214, // 6 + 195312, // 7 + 173611, // 8 + 156250, // 9 + 142045, // 10 + 130208, // 11 + 120192 // 12 }; int init_ftdi_context(struct ftdi_context * ftdi) @@ -63,9 +66,9 @@ int init_ftdi_context(struct ftdi_context * ftdi) } ftdi_list_free(&devlist); + /* unsigned short value; unsigned short index; - for (unsigned int i = 0; i < (sizeof (dreamcast_rates)) / (sizeof (dreamcast_rates[0])); i++) { int baud = convert_baudrate_UT_export(dreamcast_rates[i], ftdi, &value, &index); float baudf = baud; @@ -73,15 +76,21 @@ int init_ftdi_context(struct ftdi_context * ftdi) float error = (baudf > ratef) ? ratef / baudf : baudf / ratef; fprintf(stdout, "%d: best: %d, error: %f\n", dreamcast_rates[i], baud, (1.f - error) * 100.f); } + */ - res = ftdi_set_baudrate(ftdi, 1562500); - //res = ftdi_set_baudrate(ftdi, 312500); + res = ftdi_set_baudrate(ftdi, dreamcast_rates[0]); if (res < 0) { fprintf(stderr, "ftdi_set_baudrate\n"); return -1; } - res = ftdi_set_line_property(ftdi, 8, STOP_BIT_1, NONE); + res = ftdi_set_line_property2(ftdi, BITS_8, STOP_BIT_1, NONE, BREAK_ON); + if (res < 0) { + fprintf(stderr, "ftdi_set_line_property\n"); + return -1; + } + + res = ftdi_set_line_property2(ftdi, BITS_8, STOP_BIT_1, NONE, BREAK_OFF); if (res < 0) { fprintf(stderr, "ftdi_set_line_property\n"); return -1; @@ -117,15 +126,7 @@ union data_command { }; uint8_t data[4 * 3]; }; -static_assert((sizeof (union data_command)) == 4 * 3); - -uint32_t bswap(const uint32_t n) -{ - if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) - return n; - else - return __builtin_bswap32(n); -} +static_assert((sizeof (union data_command)) == 12); long read_with_timeout(struct ftdi_context * ftdi, uint8_t * read_buf, const long expect_length) { @@ -167,79 +168,110 @@ long max(long a, long b) return a > b ? a : b; } -void symmetric(struct ftdi_context * ftdi, const uint8_t * tx_buf, const long size) -{ - int res; - uint8_t rx_buf[size]; - long tx_offset = 0; - long rx_offset = 0; - - while (tx_offset < size) { - long txrx_diff = tx_offset - rx_offset; - long tx_length = max(min(min(chunk_size, size - tx_offset), chunk_size - txrx_diff), 0); - - if (tx_length > 0) { - res = ftdi_write_data(ftdi, &tx_buf[tx_offset], tx_length); - assert(res >= 0); - tx_offset += res; - } - - res = ftdi_read_data(ftdi, &rx_buf[rx_offset], size - rx_offset); - assert(res >= 0); - rx_offset += res; - } - - for (int i = 0; i < size; i++) { - if (tx_buf[i] != rx_buf[i]) { - fprintf(stderr, "mismatch at %d\n", i); - return; - } - } - fprintf(stderr, "equal\n"); -} - double timespec_difference(struct timespec const * const a, struct timespec const * const b) { return (double)(a->tv_sec - b->tv_sec) + (double)(a->tv_nsec - b->tv_nsec) / 1'000'000'000.0; } -int transfer(struct ftdi_context * ftdi, const uint8_t * buf, const long size) +void dump_command_reply(union serial_load::command_reply& cr) +{ + for (uint32_t i = 0; i < (sizeof (union serial_load::command_reply)) / (sizeof (uint32_t)); i++) { + fprintf(stderr, " %08x\n", cr.u32[i]); + } +} + +int read_reply(struct ftdi_context * ftdi, uint32_t expected_cmd, union serial_load::command_reply& reply) +{ + using namespace serial_load; + + constexpr long read_length = (sizeof (union serial_load::command_reply)); + + long length = read_with_timeout(ftdi, reply.u8, read_length); + if (length != read_length) { + fprintf(stderr, "short read; want %ld bytes; received: %ld\n", read_length, length); + return -1; + } + + for (uint32_t i = 0; i < (sizeof (reply)) / (sizeof (uint32_t)); i++) { + reply.u32[i] = le_bswap(reply.u32[i]); + } + + uint32_t crc = crc32(&reply.u8[0], 12); + if (crc != reply.crc) { + fprintf(stderr, "crc mismatch; remote crc: %08x; local crc: %08x\n", reply.crc, crc); + dump_command_reply(reply); + return -1; + } + + if (reply.cmd != expected_cmd) { + fprintf(stderr, "invalid reply; remote cmd %08x; expected cmd: %08x\n", reply.cmd, expected_cmd); + dump_command_reply(reply); + return -1; + } + + return 0; +} + +int do_write(struct ftdi_context * ftdi, const uint8_t * buf, const uint32_t size) { int res; - union data_command command = { - .command = {'D', 'A', 'T', 'A'}, - .size = bswap(size), - .dest = bswap(0xac010000), - }; - - res = ftdi_write_data(ftdi, command.data, (sizeof (union data_command))); - assert(res >= 0); - - const char * expect = "data\n"; - const long expect_length = 5; - uint8_t read_buf[expect_length + 1]; - read_buf[expect_length] = 0; - long read_length = read_with_timeout(ftdi, read_buf, expect_length); - if (read_length != expect_length) { - fprintf(stderr, "want %ld bytes; received: %ld\n", expect_length, read_length); - return -1; - } - res = memcmp(read_buf, expect, expect_length); + const uint32_t dest = 0xac010000; + union serial_load::command_reply command = serial_load::write_command(dest, size); + res = ftdi_write_data(ftdi, command.u8, (sizeof (command))); + assert(res == (sizeof (command))); + union serial_load::command_reply reply; + res = read_reply(ftdi, serial_load::reply::write, reply); if (res != 0) { - fprintf(stderr, "expect `%s`; received: `%s`\n", expect, read_buf); return -1; } - - fprintf(stderr, "OK\n"); + fprintf(stderr, "remote: dest: %08x size: %08x\n", reply.arg[0], reply.arg[1]); + if (reply.arg[0] != dest || reply.arg[1] != size) { + return -1; + } struct timespec start; struct timespec end; res = clock_gettime(CLOCK_MONOTONIC, &start); - symmetric(ftdi, buf, size); + assert(res == 0); + res = ftdi_write_data(ftdi, buf, size); + assert(res >= 0); + assert((uint32_t)res == size); res = clock_gettime(CLOCK_MONOTONIC, &end); + assert(res == 0); fprintf(stderr, "symmetric time: %.03f\n", timespec_difference(&end, &start)); + uint32_t buf_crc = crc32(buf, size); + + union serial_load::command_reply crc_reply; + res = read_reply(ftdi, serial_load::reply::write_crc, crc_reply); + if (res != 0) { + return -1; + } + fprintf(stderr, "remote crc: %08x; local crc %08x\n", crc_reply.arg[0], buf_crc); + + return 0; +} + +int do_jump(struct ftdi_context * ftdi) +{ + int res; + + const uint32_t dest = 0xac010000; + + union serial_load::command_reply command = serial_load::jump_command(dest); + res = ftdi_write_data(ftdi, command.u8, (sizeof (command))); + assert(res == (sizeof (command))); + + union serial_load::command_reply reply; + res = read_reply(ftdi, serial_load::reply::jump, reply); + if (res != 0) { + return -1; + } + fprintf(stderr, "remote: jump: %08x\n", reply.arg[0]); + if (reply.arg[0] != dest || reply.arg[1] != 0) { + return -1; + } return 0; } @@ -273,12 +305,14 @@ int main(int argc, char * argv[]) } fprintf(stderr, "%s off %ld\n", argv[1], off); - uint8_t buf[off]; + //uint8_t buf[off]; + uint8_t * buf = (uint8_t *)malloc(off); ssize_t size = fread(buf, 1, off, file); if (size < 0) { fprintf(stderr, "read"); return EXIT_FAILURE; } + printf("%02x\n", buf[0]); ret = fclose(file); if (ret < 0) { @@ -300,13 +334,25 @@ int main(int argc, char * argv[]) return EXIT_FAILURE; } + int return_code = EXIT_SUCCESS; + struct timespec start; struct timespec end; res = clock_gettime(CLOCK_MONOTONIC, &start); - int transfer_ret = transfer(ftdi, buf, off); + assert(res >= 0); + int do_write_ret = do_write(ftdi, buf, off); res = clock_gettime(CLOCK_MONOTONIC, &end); + assert(res >= 0); + fprintf(stderr, "do_write time: %.03f\n", timespec_difference(&end, &start)); + if (do_write_ret == 0) { + do_jump(ftdi); + } else { + return_code = EXIT_FAILURE; + } - fprintf(stderr, "time: %.03f\n", timespec_difference(&end, &start)); + res = clock_gettime(CLOCK_MONOTONIC, &end); + assert(res >= 0); + fprintf(stderr, "total time: %.03f\n", timespec_difference(&end, &start)); - return transfer_ret; + return return_code; }