#include "swd_probe_app.h" #include "swd_probe_icons.h" #include "jep106.h" #include "adi.h" static void render_callback(Canvas* const canvas, void* cb_ctx); static bool swd_message_process(AppFSM* ctx); static uint8_t swd_transfer(AppFSM* const ctx, bool ap, bool write, uint8_t a23, uint32_t* data); static bool swd_execute_script(AppFSM* const ctx, const char* filename); static const GpioPin* gpios[] = { &gpio_ext_pc0, &gpio_ext_pc1, &gpio_ext_pc3, &gpio_ext_pb2, &gpio_ext_pb3, &gpio_ext_pa4, &gpio_ext_pa6, &gpio_ext_pa7}; static const char* gpio_names[] = {"PC0", "PC1", "PC3", "PB2", "PB3", "PA4", "PA6", "PA7"}; /* bit set: clock, else data */ static const uint8_t gpio_direction_mask[6] = {0b10101010, 0b01010101, 0b11001100, 0b00110011, 0b11110000, 0b00001111}; const NotificationSequence seq_c_minor = { &message_note_c4, &message_delay_100, &message_sound_off, &message_delay_10, &message_note_ds4, &message_delay_100, &message_sound_off, &message_delay_10, &message_note_g4, &message_delay_100, &message_sound_off, &message_delay_10, &message_vibro_on, &message_delay_50, &message_vibro_off, NULL, }; const NotificationSequence seq_error = { &message_vibro_on, &message_delay_50, &message_vibro_off, &message_note_g4, &message_delay_100, &message_sound_off, &message_delay_10, &message_note_c4, &message_delay_500, &message_sound_off, &message_delay_10, NULL, }; const NotificationSequence* seq_sounds[] = {&seq_c_minor, &seq_error}; static bool has_multiple_bits(uint8_t x) { return (x & (x - 1)) != 0; } static uint8_t get_bit_num(uint8_t x) { return (uint8_t)__builtin_ctz(x); } static const char* gpio_name(uint8_t mask) { if(has_multiple_bits(mask)) { return "Pxx"; } uint8_t io = get_bit_num(mask); if(io >= COUNT(gpio_names)) { return "Pxx"; } return gpio_names[io]; } static void swd_configure_pins(AppFSM* const ctx, bool output) { if(ctx->mode_page > ModePageFound && ctx->io_num_swc < 8 && ctx->io_num_swd < 8) { furi_hal_gpio_init( gpios[ctx->io_num_swc], GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh); if(!output) { furi_hal_gpio_init( gpios[ctx->io_num_swd], GpioModeInput, GpioPullUp, GpioSpeedVeryHigh); } else { furi_hal_gpio_init( gpios[ctx->io_num_swd], GpioModeOutputOpenDrain, GpioPullUp, GpioSpeedVeryHigh); } return; } for(int io = 0; io < 8; io++) { uint8_t bitmask = 1 << io; /* if neither candidate for SWC nor SWD then skip */ if(!(ctx->io_swc & bitmask) && !(ctx->io_swd & bitmask)) { furi_hal_gpio_init(gpios[io], GpioModeInput, GpioPullUp, GpioSpeedVeryHigh); continue; } if(ctx->current_mask & bitmask) { /* set for clock */ furi_hal_gpio_init(gpios[io], GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh); } else { /* set for data */ if(!output) { furi_hal_gpio_init(gpios[io], GpioModeInput, GpioPullUp, GpioSpeedVeryHigh); } else { furi_hal_gpio_init( gpios[io], GpioModeOutputOpenDrain, GpioPullUp, GpioSpeedVeryHigh); } } } } static void swd_set_clock(AppFSM* const ctx, const uint8_t level) { if(ctx->mode_page > ModePageFound && ctx->io_num_swc < 8) { furi_hal_gpio_write(gpios[ctx->io_num_swc], level); return; } for(int io = 0; io < 8; io++) { uint8_t bitmask = 1 << io; /* if no candidate for SWC then skip */ if(!(ctx->io_swc & bitmask)) { continue; } if(ctx->current_mask & bitmask) { furi_hal_gpio_write(gpios[io], level); } } } static void swd_set_data(AppFSM* const ctx, const uint8_t level) { if(ctx->mode_page > ModePageFound && ctx->io_num_swd < 8) { furi_hal_gpio_write(gpios[ctx->io_num_swd], level); return; } for(int io = 0; io < 8; io++) { uint8_t bitmask = 1 << io; /* if no candidate for SWD then skip */ if(!(ctx->io_swd & bitmask)) { continue; } if(!(ctx->current_mask & bitmask)) { furi_hal_gpio_write(gpios[io], level); } } } static uint8_t swd_get_data(AppFSM* const ctx) { if(ctx->mode_page > ModePageFound && ctx->io_num_swd < 8) { return furi_hal_gpio_read(gpios[ctx->io_num_swd]); } uint8_t bits = 0; for(int io = 0; io < 8; io++) { uint8_t bitmask = 1 << io; /* if no candidate for SWD then skip */ if(!(ctx->io_swd & bitmask)) { continue; } bits |= furi_hal_gpio_read(gpios[io]) ? bitmask : 0; } return bits; } static void swd_clock_delay(AppFSM* const ctx) { if(ctx->swd_clock_delay) { furi_delay_us(ctx->swd_clock_delay); } } static void swd_write_bit(AppFSM* const ctx, bool level) { swd_set_clock(ctx, 0); swd_set_data(ctx, level); swd_clock_delay(ctx); swd_set_clock(ctx, 1); swd_clock_delay(ctx); swd_set_clock(ctx, 0); } static uint8_t swd_read_bit(AppFSM* const ctx) { swd_set_clock(ctx, 1); swd_clock_delay(ctx); swd_set_clock(ctx, 0); uint8_t bits = swd_get_data(ctx); swd_clock_delay(ctx); swd_set_clock(ctx, 1); return bits; } /* send a byte or less LSB-first */ static void swd_write_byte(AppFSM* const ctx, const uint8_t data, size_t bits) { for(size_t pos = 0; pos < bits; pos++) { swd_write_bit(ctx, data & (1 << pos)); } } /* send a sequence of bytes LSB-first */ static void swd_write(AppFSM* const ctx, const uint8_t* data, size_t bits) { size_t byte_pos = 0; while(bits > 0) { size_t remain = (bits > 8) ? 8 : bits; swd_write_byte(ctx, data[byte_pos++], remain); bits -= remain; } } static uint8_t swd_transfer(AppFSM* const ctx, bool ap, bool write, uint8_t a23, uint32_t* data) { //notification_message(ctx->notification, &sequence_set_blue_255); //notification_message(ctx->notification, &sequence_reset_red); swd_set_data(ctx, false); swd_configure_pins(ctx, true); uint32_t idle = 0; swd_write(ctx, (uint8_t*)&idle, ctx->swd_idle_bits); uint8_t request[] = {0}; request[0] |= 0x01; /* start bit*/ request[0] |= ap ? 0x02 : 0; /* APnDP */ request[0] |= write ? 0 : 0x04; /* operation */ request[0] |= (a23 & 0x01) ? 0x08 : 0; /* A[2:3] */ request[0] |= (a23 & 0x02) ? 0x10 : 0; /* A[2:3] */ request[0] |= 0x80; /* park bit */ request[0] |= __builtin_parity(request[0]) ? 0x20 : 0; /* parity */ swd_write(ctx, request, sizeof(request) * 8); /* turnaround cycle */ swd_configure_pins(ctx, false); uint8_t ack = 0; /* receive 3 ACK bits */ for(int pos = 0; pos < 3; pos++) { ack >>= 1; ack |= swd_read_bit(ctx) ? 0x04 : 0; } /* force ABORT/CTRL to always work */ if(!ap && a23 == 0) { ack = 1; } if(ack != 0x01) { //notification_message(ctx->notification, &sequence_reset_blue); //notification_message(ctx->notification, &sequence_set_red_255); return ack; } if(write) { swd_write_bit(ctx, 0); swd_configure_pins(ctx, true); /* send 32 WDATA bits */ for(int pos = 0; pos < 32; pos++) { swd_write_bit(ctx, *data & (1 << pos)); } /* send parity bit */ swd_write_bit(ctx, __builtin_parity(*data)); } else { *data = 0; /* receive 32 RDATA bits */ for(int pos = 0; pos < 32; pos++) { *data >>= 1; *data |= swd_read_bit(ctx) ? 0x80000000 : 0; } /* receive parity bit */ bool parity = swd_read_bit(ctx); if(parity != __builtin_parity(*data)) { //notification_message(ctx->notification, &sequence_reset_blue); //notification_message(ctx->notification, &sequence_set_red_255); return 8; } } swd_set_data(ctx, false); swd_configure_pins(ctx, true); //notification_message(ctx->notification, &sequence_reset_blue); return ack; } /* A line reset is achieved by holding the data signal HIGH for at least 50 clock cycles, followed by at least two idle cycles. */ static void swd_line_reset(AppFSM* const ctx) { //notification_message(ctx->notification, &sequence_set_red_255); for(int bitcount = 0; bitcount < 50; bitcount += 8) { swd_write_byte(ctx, 0xFF, 8); } swd_write_byte(ctx, 0, 8); ctx->dp_regs.select_ok = false; //notification_message(ctx->notification, &sequence_reset_red); } static void swd_abort(AppFSM* const ctx) { uint32_t dpidr; /* first reset the line */ swd_line_reset(ctx); swd_transfer(ctx, false, false, 0, &dpidr); uint32_t abort = 0x0E; swd_transfer(ctx, false, true, 0, &abort); } static void swd_abort_simple(AppFSM* const ctx) { uint32_t abort = 0x0E; swd_transfer(ctx, false, true, 0, &abort); uint32_t dpidr; if(swd_transfer(ctx, false, false, 0, &dpidr) != 1) { swd_abort(ctx); } } static uint8_t swd_select(AppFSM* const ctx, uint8_t ap_sel, uint8_t ap_bank, uint8_t dp_bank) { uint32_t bank_reg = (ap_sel << 24) | ((ap_bank & 0x0F) << 4) | (dp_bank & 0x0F); if(ctx->dp_regs.select_ok && bank_reg == ctx->dp_regs.select) { return 1; } uint8_t ret = swd_transfer(ctx, false, true, REG_SELECT, &bank_reg); if(ret != 1) { ctx->dp_regs.select_ok = false; DBG("failed: %d", ret); return ret; } ctx->dp_regs.select = bank_reg; ctx->dp_regs.select_ok = true; return ret; } static uint8_t swd_read_dpbank(AppFSM* const ctx, uint8_t dp_off, uint8_t dp_bank, uint32_t* data) { uint8_t ret = 0; /* select target bank */ if(dp_bank < 0x10) { uint8_t ret = swd_select(ctx, 0, 0, dp_bank); if(ret != 1) { DBGS("swd_select failed"); return ret; } } /* read data from it */ *data = 0; ret = swd_transfer(ctx, false, false, dp_off, data); if(ret != 1) { DBG("failed: %d", ret); return ret; } return ret; } static uint8_t swd_write_dpbank(AppFSM* const ctx, uint8_t dp_off, uint8_t dp_bank, uint32_t* data) { uint8_t ret = 0; /* select target bank */ if(dp_bank < 0x10) { ret = swd_select(ctx, 0, 0, dp_bank); if(ret != 1) { DBGS("swd_select failed"); return ret; } } /* write it */ ret = swd_transfer(ctx, false, true, dp_off, data); if(ret != 1) { DBG("failed: %d", ret); return ret; } return ret; } static uint8_t swd_read_ap(AppFSM* const ctx, uint8_t ap, uint8_t ap_off, uint32_t* data) { /* select target bank */ uint8_t ret = swd_select(ctx, ap, (ap_off >> 4) & 0x0F, 0); if(ret != 1) { DBGS("swd_select failed"); return ret; } ret = swd_transfer(ctx, true, false, (ap_off >> 2) & 3, data); *data = 0; ret = swd_transfer(ctx, true, false, (ap_off >> 2) & 3, data); if(ret != 1) { DBG("failed: %d", ret); return ret; } return ret; } static uint8_t swd_read_ap_single(AppFSM* const ctx, uint8_t ap, uint8_t ap_off, uint32_t* data) { uint8_t ret = swd_select(ctx, ap, (ap_off >> 4) & 0x0F, 0); if(ret != 1) { DBGS("swd_select failed"); return ret; } *data = 0; ret = swd_transfer(ctx, true, false, (ap_off >> 2) & 3, data); if(ret != 1) { DBG("failed: %d", ret); return ret; } return ret; } static uint8_t swd_write_ap(AppFSM* const ctx, uint8_t ap, uint8_t ap_off, uint32_t data) { uint8_t ret = swd_select(ctx, ap, (ap_off >> 4) & 0x0F, 0); if(ret != 1) { DBGS("swd_select failed"); return ret; } ret = swd_transfer(ctx, true, true, (ap_off >> 2) & 3, &data); if(ret != 1) { DBG("failed: %d", ret); return ret; } return ret; } static uint8_t swd_write_memory(AppFSM* const ctx, uint8_t ap, uint32_t address, uint32_t data) { uint8_t ret = 0; uint32_t csw = 0x23000002; ret |= swd_write_ap(ctx, ap, MEMAP_CSW, csw); ret |= swd_write_ap(ctx, ap, MEMAP_TAR, address); ret |= swd_write_ap(ctx, ap, MEMAP_DRW, data); DBG("write 0x%08lX to 0x%08lX", data, address); if(ret != 1) { swd_abort(ctx); } return ret; } uint8_t swd_read_memory(AppFSM* const ctx, uint8_t ap, uint32_t address, uint32_t* data) { uint8_t ret = 0; uint32_t csw = 0x23000002; ret |= swd_write_ap(ctx, ap, MEMAP_CSW, csw); ret |= swd_write_ap(ctx, ap, MEMAP_TAR, address); ret |= swd_read_ap(ctx, ap, MEMAP_DRW, data); if(ret != 1) { DBG("read from 0x%08lX failed", address); swd_abort(ctx); } else { DBG("read 0x%08lX from 0x%08lX", *data, address); } return ret; } static uint8_t swd_read_memory_block( AppFSM* const ctx, uint8_t ap, uint32_t address, uint8_t* buf, uint32_t len) { uint8_t ret = 0; uint32_t data = 0; uint32_t csw = 0x23000012; ret |= swd_write_ap(ctx, ap, MEMAP_CSW, csw); ret |= swd_write_ap(ctx, ap, MEMAP_TAR, address); ret |= swd_read_ap_single(ctx, ap, MEMAP_DRW, &data); for(size_t pos = 0; pos < len; pos += 4) { data = 0xDEADBEEF; ret |= swd_read_ap_single(ctx, ap, MEMAP_DRW, &data); DBG("read %lX", data); memcpy(&buf[pos], &data, 4); if(ret != 1) { swd_abort(ctx); return ret; } } return ret; } static uint32_t swd_detect(AppFSM* const ctx) { swd_set_data(ctx, false); swd_configure_pins(ctx, true); uint8_t data[] = {0xA5}; swd_write(ctx, data, sizeof(data) * 8); /* turnaround cycle */ swd_configure_pins(ctx, false); uint8_t ack_bits[3]; uint8_t rdata[32]; /* receive 3 ACK bits */ for(int pos = 0; pos < 3; pos++) { ack_bits[pos] = swd_read_bit(ctx); } /* receive 32 RDATA bits */ for(int pos = 0; pos < 32; pos++) { rdata[pos] = swd_read_bit(ctx); } /* receive parity bit */ uint8_t parity = swd_read_bit(ctx); for(int io = 0; io < 8; io++) { uint8_t bitmask = 1 << io; /* skip if it's a clock */ if(ctx->current_mask & bitmask) { continue; } uint8_t ack = 0; for(int pos = 0; pos < 3; pos++) { ack >>= 1; ack |= (ack_bits[pos] & bitmask) ? 4 : 0; } uint32_t dpidr = 0; for(int pos = 0; pos < 32; pos++) { dpidr >>= 1; dpidr |= (rdata[pos] & bitmask) ? 0x80000000 : 0; } if(ack == 1 && dpidr != 0 && dpidr != 0xFFFFFFFF) { bool received_parity = (parity & bitmask); if(__builtin_parity(dpidr) == received_parity) { ctx->dp_regs.dpidr = dpidr; ctx->dp_regs.dpidr_ok = true; ctx->detected = true; ctx->io_swd = bitmask; ctx->io_swc &= ctx->current_mask; LOG("swd_detect: data: %08lX, io_swd %02X, io_swc %02X", dpidr, ctx->io_swd, ctx->io_swc); if(!has_multiple_bits(ctx->io_swc)) { ctx->io_num_swd = get_bit_num(ctx->io_swd); ctx->io_num_swc = get_bit_num(ctx->io_swc); } } } } swd_set_data(ctx, false); swd_configure_pins(ctx, true); return 0; } static void swd_scan(AppFSM* const ctx) { /* To switch SWJ-DP from JTAG to SWD operation: 1. Send at least 50 SWCLKTCK cycles with SWDIOTMS HIGH. This ensures that the current interface is in its reset state. The JTAG interface only detects the 16-bit JTAG-to-SWD sequence starting from the Test-Logic-Reset state. 2. Send the 16-bit JTAG-to-SWD select sequence 0x79e7 on SWDIOTMS. 3. Send at least 50 SWCLKTCK cycles with SWDIOTMS HIGH. This ensures that if SWJ-DP was already in SWD operation before sending the select sequence, the SWD interface enters line reset state. */ swd_configure_pins(ctx, true); /* reset JTAG interface */ for(int bitcount = 0; bitcount < 50; bitcount += 8) { swd_write_byte(ctx, 0xFF, 8); } /* Send the 16-bit JTAG-to-SWD select sequence */ swd_write_byte(ctx, 0x9E, 8); swd_write_byte(ctx, 0xE7, 8); /* resynchronize SWD */ swd_line_reset(ctx); swd_detect(ctx); } static bool swd_ensure_powerup(AppFSM* const ctx) { bool ret = true; if(!(ctx->dp_regs.ctrlstat & (CSYSPWRUPREQ | CDBGPWRUPREQ))) { DBGS("no (CSYSPWRUPREQ | CDBGPWRUPREQ)"); /* fetch current CTRL/STAT */ DBGS(" - Fetch CTRL/STAT"); ctx->dp_regs.ctrlstat_ok = swd_read_dpbank(ctx, REG_CTRLSTAT, REG_CTRLSTAT_BANK, &ctx->dp_regs.ctrlstat) == 1; DBG(" %08lX %s", ctx->dp_regs.ctrlstat, ctx->dp_regs.ctrlstat_ok ? "OK" : "FAIL"); /* enable requests */ ctx->dp_regs.ctrlstat |= (CSYSPWRUPREQ | CDBGPWRUPREQ); swd_write_dpbank(ctx, REG_CTRLSTAT, REG_CTRLSTAT_BANK, &ctx->dp_regs.ctrlstat); ret = false; } if(!(ctx->dp_regs.ctrlstat & CDBGPWRUPACK)) { DBGS("no CDBGPWRUPACK"); /* fetch current CTRL/STAT */ swd_read_dpbank(ctx, REG_CTRLSTAT, REG_CTRLSTAT_BANK, &ctx->dp_regs.ctrlstat); ret = false; } if(!ret) { DBGS(" - Fetch CTRL/STAT"); ctx->dp_regs.ctrlstat_ok = swd_read_dpbank(ctx, REG_CTRLSTAT, REG_CTRLSTAT_BANK, &ctx->dp_regs.ctrlstat) == 1; DBG(" %08lX %s", ctx->dp_regs.ctrlstat, ctx->dp_regs.ctrlstat_ok ? "OK" : "FAIL"); } return ret; } static void swd_apscan_reset(AppFSM* const ctx) { for(size_t reset_ap = 0; reset_ap < COUNT(ctx->apidr_info); reset_ap++) { ctx->apidr_info[reset_ap].tested = false; } } static bool swd_apscan_test(AppFSM* const ctx, uint32_t ap) { furi_assert(ctx); furi_assert(ap < sizeof(ctx->apidr_info)); bool ret = true; ctx->apidr_info[ap].tested = true; uint32_t data = 0; if(swd_read_ap(ctx, ap, AP_IDR, &data) != 1) { swd_abort(ctx); return false; } if(data == 0) { return false; } DBG("AP%lu detected", ap); ctx->apidr_info[ap].ok = true; ctx->apidr_info[ap].revision = (data >> 24) & 0x0F; ctx->apidr_info[ap].designer = (data >> 17) & 0x3FF; ctx->apidr_info[ap].class = (data >> 13) & 0x0F; ctx->apidr_info[ap].variant = (data >> 4) & 0x0F; ctx->apidr_info[ap].type = (data >> 0) & 0x0F; if(swd_read_ap(ctx, ap, AP_BASE, &ctx->apidr_info[ap].base) != 1) { swd_abort(ctx); ret = false; } return ret; } /************************** script helpers **************************/ static void swd_script_log(ScriptContext* ctx, FuriLogLevel level, const char* format, ...) { bool commandline = false; ScriptContext* cur = ctx; char buffer[256]; va_list argp; va_start(argp, format); do { if(cur == ctx->app->commandline) { commandline = true; } cur = cur->parent; } while(cur); if(commandline) { const char* prefix = ""; switch(level) { case FuriLogLevelWarn: prefix = "Warning: "; break; case FuriLogLevelError: prefix = "ERROR: "; break; default: break; } strcpy(buffer, prefix); size_t pos = strlen(buffer); vsnprintf(&buffer[pos], sizeof(buffer) - pos - 2, format, argp); strcat(buffer, "\n"); if(!usb_uart_tx_data(ctx->app->uart, (uint8_t*)buffer, strlen(buffer))) { DBGS("Sending via USB failed"); } } else { LOG(buffer); } va_end(argp); } /* read characters until newline was read */ static bool swd_script_seek_newline(ScriptContext* ctx) { while(true) { uint8_t ch = 0; if(ctx->script_file) { if(storage_file_read(ctx->script_file, &ch, 1) != 1) { return false; } } else { ch = ctx->line_data[ctx->line_pos]; if(ch == 0) { return false; } ctx->line_pos++; } if(ch == '\n') { return true; } } } /* read whitespaces until the next character is read. returns false if EOF or newline was read */ static bool swd_script_skip_whitespace(ScriptContext* ctx) { while(true) { uint8_t ch = 0; uint64_t start_pos = 0; if(ctx->script_file) { start_pos = storage_file_tell(ctx->script_file); if(storage_file_read(ctx->script_file, &ch, 1) != 1) { return false; } } else { start_pos = ctx->line_pos; ch = ctx->line_data[ctx->line_pos]; if(ch == 0) { return false; } ctx->line_pos++; } if(ch == '\n') { return false; } if(ch != ' ') { if(ctx->script_file) { storage_file_seek(ctx->script_file, start_pos, true); } else { ctx->line_pos = start_pos; } return true; } } } static bool swd_script_get_string(ScriptContext* ctx, char* str, size_t max_length) { bool quot = false; size_t pos = 0; str[pos] = '\000'; while(true) { char ch = 0; uint64_t start_pos = 0; if(ctx->script_file) { start_pos = storage_file_tell(ctx->script_file); if(storage_file_read(ctx->script_file, &ch, 1) != 1) { DBGS("end reached"); return false; } } else { start_pos = ctx->line_pos; ch = ctx->line_data[ctx->line_pos]; if(ch == 0) { DBGS("end reached"); return false; } ctx->line_pos++; } if(ch == '"') { quot = !quot; continue; } if(!quot) { if(ch == ' ') { break; } if(ch == '\r' || ch == '\n') { if(ctx->script_file) { storage_file_seek(ctx->script_file, start_pos, true); } else { ctx->line_pos = start_pos; } break; } } if(pos + 2 > max_length) { DBGS("too long"); return false; } str[pos++] = ch; str[pos] = '\000'; } DBG("got '%s'", str); return true; } static bool swd_script_get_number(ScriptContext* ctx, uint32_t* number) { char str[16]; if(!swd_script_get_string(ctx, str, sizeof(str))) { DBGS("could not get string"); return false; } DBG("got '%s'", str); size_t pos = 0; *number = 0; /* hex number? */ if(!strncmp(str, "0x", 2)) { pos += 2; while(str[pos]) { uint8_t ch = str[pos++]; uint8_t ch_num = ch - '0'; uint8_t ch_hex = (ch & ~0x20) - 'A'; *number <<= 4; if(ch_num <= 10) { *number += ch_num; } else if(ch_hex <= 5) { *number += 10 + ch_hex; } else { return false; } } } else { while(str[pos]) { uint8_t ch = str[pos++]; uint8_t ch_num = ch - '0'; *number *= 10; if(ch_num < 10) { *number += ch_num; } else { return false; } } } return true; } static void swd_script_gui_refresh(ScriptContext* ctx) { if(furi_message_queue_get_count(ctx->app->event_queue) > 0) { swd_message_process(ctx->app); } if(!ctx->status_ignore) { DBG("Status: %s", ctx->app->state_string); view_port_update(ctx->app->view_port); } } /************************** script functions **************************/ static bool swd_scriptfunc_comment(ScriptContext* ctx) { DBGS("comment"); swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_label(ScriptContext* ctx) { char label[256]; DBGS("label"); swd_script_skip_whitespace(ctx); if(!swd_script_get_string(ctx, label, sizeof(label))) { swd_script_log(ctx, FuriLogLevelError, "failed to parse label"); return false; } if(!strcmp(label, ctx->goto_label)) { ctx->goto_active = false; DBG("matches '%s'", ctx->goto_label); } swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_goto(ScriptContext* ctx) { DBGS("goto"); swd_script_skip_whitespace(ctx); if(!swd_script_get_string(ctx, ctx->goto_label, sizeof(ctx->goto_label))) { swd_script_log(ctx, FuriLogLevelError, "failed to parse target label"); return false; } /* start from beginning and rerun starting from label */ ctx->goto_active = true; ctx->restart = true; swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_call(ScriptContext* ctx) { DBGS("call"); swd_script_skip_whitespace(ctx); /* fetch previous file directory */ char filename[MAX_FILE_LENGTH]; strncpy(filename, ctx->filename, sizeof(filename)); char* path = strrchr(filename, '/'); path[1] = '\000'; /* append filename */ if(!swd_script_get_string(ctx, &path[1], sizeof(filename) - strlen(path))) { swd_script_log(ctx, FuriLogLevelError, "failed to parse filename"); return false; } swd_script_seek_newline(ctx); /* append extension */ if(strlen(filename) + 5 >= sizeof(filename)) { swd_script_log(ctx, FuriLogLevelError, "name too long"); return false; } strcat(filename, ".swd"); bool ret = swd_execute_script(ctx->app, filename); if(!ret) { swd_script_log(ctx, FuriLogLevelError, "failed to exec '%s'", filename); return false; } return true; } static bool swd_scriptfunc_status(ScriptContext* ctx) { uint32_t status = 1; DBGS("status"); swd_script_skip_whitespace(ctx); swd_script_get_number(ctx, &status); ctx->status_ignore = (status == 0); swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_errors(ScriptContext* ctx) { char type[32]; DBGS("errors"); swd_script_skip_whitespace(ctx); if(!swd_script_get_string(ctx, type, sizeof(type))) { swd_script_log(ctx, FuriLogLevelError, "failed to parse"); return false; } if(!strcmp(type, "ignore")) { ctx->errors_ignore = true; } if(!strcmp(type, "fail")) { ctx->errors_ignore = false; } swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_beep(ScriptContext* ctx) { uint32_t sound = 0; DBGS("beep"); swd_script_skip_whitespace(ctx); swd_script_get_number(ctx, &sound); notification_message_block(ctx->app->notification, seq_sounds[sound]); swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_message(ScriptContext* ctx) { uint32_t wait_time = 0; char message[256]; char type[256]; bool success = true; bool show_dialog = false; if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } if(!swd_script_get_number(ctx, &wait_time)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse wait_time"); return false; } if(!swd_script_get_string(ctx, message, sizeof(message))) { swd_script_log(ctx, FuriLogLevelError, "failed to parse message"); return false; } if(swd_script_get_string(ctx, type, sizeof(type))) { if(!strcmp(type, "dialog")) { show_dialog = true; } } if(wait_time <= 60 * 1000) { strncpy(ctx->app->state_string, message, sizeof(ctx->app->state_string)); swd_script_gui_refresh(ctx); furi_delay_ms(wait_time); if(show_dialog) { DialogMessage* message = dialog_message_alloc(); dialog_message_set_header(message, "SWD Probe", 16, 2, AlignLeft, AlignTop); dialog_message_set_icon(message, &I_app, 3, 2); dialog_message_set_text(message, ctx->app->state_string, 3, 16, AlignLeft, AlignTop); dialog_message_set_buttons(message, "Abort", "Ok", NULL); success = dialog_message_show(ctx->app->dialogs, message) == DialogMessageButtonCenter; dialog_message_free(message); } } swd_script_seek_newline(ctx); return success; } static bool swd_scriptfunc_swd_idle_bits(ScriptContext* ctx) { uint32_t swd_idle_bits = 0; if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } if(!swd_script_get_number(ctx, &swd_idle_bits)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse"); return false; } if(swd_idle_bits <= 32) { ctx->app->swd_idle_bits = swd_idle_bits; } else { swd_script_log(ctx, FuriLogLevelError, "value must be between 1 and 32"); } swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_swd_clock_delay(ScriptContext* ctx) { uint32_t swd_clock_delay = 0; if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } if(!swd_script_get_number(ctx, &swd_clock_delay)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse"); return false; } if(swd_clock_delay <= 1000000) { ctx->app->swd_clock_delay = swd_clock_delay; } else { swd_script_log(ctx, FuriLogLevelError, "value must be between 1 and 1000000"); } swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_maxtries(ScriptContext* ctx) { uint32_t max_tries = 0; if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } if(!swd_script_get_number(ctx, &max_tries)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse"); return false; } if(max_tries >= 1 && max_tries <= 1024) { ctx->max_tries = max_tries; } else { DBGS("value must be between 1 and 1024"); } swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_blocksize(ScriptContext* ctx) { uint32_t block_size = 0; if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } if(!swd_script_get_number(ctx, &block_size)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse"); return false; } if(block_size >= 4 && block_size <= 0x1000) { ctx->block_size = block_size; } else { swd_script_log(ctx, FuriLogLevelError, "value must be between 4 and 4096"); } swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_apselect(ScriptContext* ctx) { uint32_t ap = 0; if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } if(!swd_script_get_number(ctx, &ap)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse AP"); return false; } if(!swd_apscan_test(ctx->app, ap)) { swd_script_log(ctx, FuriLogLevelError, "no selected AP"); return false; } ctx->selected_ap = ap; swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_apscan(ScriptContext* ctx) { DBGS("Scanning APs"); for(uint32_t ap = 0; ap < 255; ap++) { snprintf(ctx->app->state_string, sizeof(ctx->app->state_string), "Scan AP %lu", ap); swd_script_gui_refresh(ctx); if(swd_apscan_test(ctx->app, ap)) { DBG(" AP%lu detected", ap); } } swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_abort(ScriptContext* ctx) { DBGS("Aborting"); swd_abort(ctx->app); swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_mem_dump(ScriptContext* ctx) { char filename[MAX_FILE_LENGTH]; uint32_t address = 0; uint32_t length = 0; uint32_t flags = 0; bool success = true; /* get file */ if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } if(!swd_script_get_string(ctx, filename, sizeof(filename))) { swd_script_log(ctx, FuriLogLevelError, "failed to parse filename"); return false; } /* get address */ if(!swd_script_get_number(ctx, &address)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse address"); return false; } /* get length */ if(!swd_script_get_number(ctx, &length)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse length"); return false; } /* get flags */ if(swd_script_get_number(ctx, &flags)) { DBGS("found extra flags"); } LOG("would dump %08lX, len %08lX into %s", address, length, filename); File* dump = storage_file_alloc(ctx->app->storage); if(!storage_file_open(dump, filename, FSAM_WRITE, FSOM_CREATE_ALWAYS)) { storage_file_free(dump); snprintf(ctx->app->state_string, sizeof(ctx->app->state_string), "Failed to create file"); swd_script_gui_refresh(ctx); notification_message_block(ctx->app->notification, &seq_error); return false; } if(ctx->block_size == 0) { ctx->block_size = 0x100; } if(ctx->block_size > 0x1000) { ctx->block_size = 0x1000; } uint8_t* buffer = malloc(ctx->block_size); furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); for(uint32_t pos = 0; pos < length; pos += ctx->block_size) { if((pos & 0xFF) == 0) { int pct = pos * 100 / length; snprintf( ctx->app->state_string, sizeof(ctx->app->state_string), "Dump %08lX (%d%%)", pos, pct); swd_script_gui_refresh(ctx); } bool read_ok = false; for(uint32_t tries = 0; tries < ctx->max_tries; tries++) { if(ctx->abort) { DBGS("aborting read"); break; } uint32_t ret = 0; if(ctx->block_size > 4) { ret = swd_read_memory_block( ctx->app, ctx->selected_ap, address + pos, buffer, ctx->block_size); } else { ret = swd_read_memory(ctx->app, ctx->selected_ap, address + pos, (uint32_t*)buffer); } read_ok = (ret == 1); if(!read_ok) { snprintf( ctx->app->state_string, sizeof(ctx->app->state_string), "Failed at 0x%08lX", address + pos); swd_script_gui_refresh(ctx); furi_delay_ms(100); } else { break; } } if(ctx->abort) { DBGS("aborting"); break; } if(!read_ok) { /* flags == 1: "continue reading even if it fails" */ /* flags == 2: "its okay if cannot dump fully" */ if(flags & 1) { /* set all content to a known value as indication */ for(size_t fill_pos = 0; fill_pos < ctx->block_size; fill_pos += 4) { *((uint32_t*)&buffer[fill_pos]) = 0xDEADFACE; } } else if(flags & 2) { success = (pos > 0); break; } else { notification_message_block(ctx->app->notification, &seq_error); success = false; break; } } storage_file_write(dump, buffer, ctx->block_size); } furi_mutex_release(ctx->app->swd_mutex); storage_file_close(dump); swd_script_seek_newline(ctx); free(buffer); return success; } static bool swd_scriptfunc_mem_write(ScriptContext* ctx) { uint32_t address = 0; uint32_t data = 0; bool success = true; /* get file */ if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } /* get address */ if(!swd_script_get_number(ctx, &address)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse address"); return false; } /* get data */ if(!swd_script_get_number(ctx, &data)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse data"); return false; } DBG("write %08lX to %08lX", data, address); bool access_ok = false; for(uint32_t tries = 0; tries < ctx->max_tries; tries++) { if(ctx->abort) { DBGS("aborting"); break; } furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); access_ok = swd_write_memory(ctx->app, ctx->selected_ap, address, data) == 1; access_ok |= ctx->errors_ignore; swd_read_memory(ctx->app, ctx->selected_ap, address, &data); furi_mutex_release(ctx->app->swd_mutex); DBG("read %08lX from %08lX", data, address); if(!access_ok) { snprintf( ctx->app->state_string, sizeof(ctx->app->state_string), "Failed write 0x%08lX", address); swd_script_gui_refresh(ctx); } else { break; } } if(!access_ok) { notification_message_block(ctx->app->notification, &seq_error); success = false; } swd_script_seek_newline(ctx); return success; } static bool swd_scriptfunc_mem_read(ScriptContext* ctx) { uint32_t address = 0; bool success = true; /* get file */ if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } /* get address */ if(!swd_script_get_number(ctx, &address)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse address"); return false; } DBG("read from %08lX", address); uint32_t data = 0; bool access_ok = false; for(uint32_t tries = 0; tries < ctx->max_tries; tries++) { if(ctx->abort) { DBGS("aborting"); break; } furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); access_ok = swd_read_memory(ctx->app, ctx->selected_ap, address, &data) == 1; furi_mutex_release(ctx->app->swd_mutex); if(!access_ok) { swd_script_log(ctx, FuriLogLevelError, "Failed to read from %08lX", address); snprintf( ctx->app->state_string, sizeof(ctx->app->state_string), "Failed read 0x%08lX", address); swd_script_gui_refresh(ctx); } else { swd_script_log(ctx, FuriLogLevelDefault, "%08lX", data); break; } } if(!access_ok) { notification_message_block(ctx->app->notification, &seq_error); success = false; } swd_script_seek_newline(ctx); return success; } static bool swd_scriptfunc_mem_ldmst(ScriptContext* ctx) { uint32_t address = 0; uint32_t data = 0; uint32_t mask = 0; bool success = true; if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } /* get address */ if(!swd_script_get_number(ctx, &address)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse address"); return false; } /* get data */ if(!swd_script_get_number(ctx, &data)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse data"); return false; } /* get mask */ if(!swd_script_get_number(ctx, &mask)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse mask"); return false; } LOG("write %08lX to %08lX, mask %08lX", data, address, mask); bool access_ok = false; uint32_t modified = 0; for(uint32_t tries = 0; tries < ctx->max_tries; tries++) { if(ctx->abort) { DBGS("aborting"); break; } furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); access_ok = swd_read_memory(ctx->app, ctx->selected_ap, address, &modified) == 1; modified = (modified & mask) | data; access_ok &= swd_write_memory(ctx->app, ctx->selected_ap, address, modified) == 1; furi_mutex_release(ctx->app->swd_mutex); access_ok |= ctx->errors_ignore; if(!access_ok) { snprintf( ctx->app->state_string, sizeof(ctx->app->state_string), "Failed access 0x%08lX", address); swd_script_gui_refresh(ctx); } else { break; } } if(!access_ok) { notification_message_block(ctx->app->notification, &seq_error); success = false; } swd_script_seek_newline(ctx); return success; } static bool swd_scriptfunc_dp_write(ScriptContext* ctx) { uint32_t dp_bank = 0; uint32_t dp_off = 0; uint32_t data = 0; bool success = true; if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } /* get data */ if(!swd_script_get_number(ctx, &data)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse data"); return false; } /* get dp_off */ if(!swd_script_get_number(ctx, &dp_off)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse DP offset"); return false; } /* get dp_bank */ if(!swd_script_get_number(ctx, &dp_bank)) { dp_bank = 0xFF; } swd_script_log( ctx, FuriLogLevelDefault, "write %08lX to reg %08lX / bank %08lX", data, dp_off, dp_bank); furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); uint8_t ret = swd_write_dpbank(ctx->app, dp_off, dp_bank, &data); if(ret != 1) { swd_script_log(ctx, FuriLogLevelError, "swd_write_dpbank failed"); success = false; } furi_mutex_release(ctx->app->swd_mutex); swd_script_seek_newline(ctx); return success; } static bool swd_scriptfunc_dp_read(ScriptContext* ctx) { uint32_t dp_bank = 0; uint32_t dp_off = 0; uint32_t data = 0; bool success = true; if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } /* get dp_off */ if(!swd_script_get_number(ctx, &dp_off)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse DP offset"); return false; } /* get dp_bank */ if(!swd_script_get_number(ctx, &dp_bank)) { dp_bank = 0xFF; } swd_script_log(ctx, FuriLogLevelDefault, "read reg %02lX / bank %02lX", dp_off, dp_bank); furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); uint8_t ret = swd_read_dpbank(ctx->app, dp_off, dp_bank, &data); if(ret != 1) { swd_script_log(ctx, FuriLogLevelError, "swd_read_dpbank failed"); success = false; } else { swd_script_log(ctx, FuriLogLevelDefault, "result: 0x%08lX", data); } furi_mutex_release(ctx->app->swd_mutex); swd_script_seek_newline(ctx); return success; } static bool swd_scriptfunc_ap_write(ScriptContext* ctx) { uint32_t ap_reg = 0; uint32_t data = 0; bool success = true; if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } /* get data */ if(!swd_script_get_number(ctx, &data)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse data"); return false; } /* get ap_reg */ if(!swd_script_get_number(ctx, &ap_reg)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse AP register"); return false; } swd_script_log( ctx, FuriLogLevelDefault, "AP%d %08lX -> %02lX", ctx->selected_ap, data, ap_reg); furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); uint8_t ret = swd_write_ap(ctx->app, ctx->selected_ap, ap_reg, data); if(ret != 1) { swd_script_log(ctx, FuriLogLevelError, "swd_write_ap failed"); success = false; } furi_mutex_release(ctx->app->swd_mutex); swd_script_seek_newline(ctx); return success; } static bool swd_scriptfunc_ap_read(ScriptContext* ctx) { uint32_t ap_reg = 0; uint32_t data = 0; bool success = true; if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } /* get ap_reg */ if(!swd_script_get_number(ctx, &ap_reg)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse AP register"); return false; } furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); uint8_t ret = swd_read_ap(ctx->app, ctx->selected_ap, ap_reg, &data); if(ret != 1) { swd_script_log(ctx, FuriLogLevelError, "swd_read_ap failed"); success = false; } else { swd_script_log( ctx, FuriLogLevelDefault, "AP%d %02lX: %08lX", ctx->selected_ap, ap_reg, data); } furi_mutex_release(ctx->app->swd_mutex); swd_script_seek_newline(ctx); return success; } static bool swd_scriptfunc_core_halt(ScriptContext* ctx) { bool succ = false; furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); uint32_t reg_dhcsr = SCS_DHCSR_KEY | SCS_DHCSR_C_HALT | SCS_DHCSR_C_DEBUGEN; succ = swd_write_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, reg_dhcsr) == 1; if(!succ) { swd_script_log(ctx, FuriLogLevelError, "swd_write_memory failed"); } else { swd_read_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, ®_dhcsr); if(!(reg_dhcsr & SCS_DHCSR_S_HALT)) { swd_script_log(ctx, FuriLogLevelError, "Core did not halt"); succ = false; } else { swd_script_log(ctx, FuriLogLevelDefault, "Core halted"); } } furi_mutex_release(ctx->app->swd_mutex); swd_script_seek_newline(ctx); return succ; } static bool swd_scriptfunc_core_continue(ScriptContext* ctx) { bool succ = false; uint32_t data = 0; furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); succ = swd_read_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, &data) == 1; if(!(data & SCS_DHCSR_S_HALT)) { swd_script_log(ctx, FuriLogLevelError, "Core is not in debug state"); succ = false; } else { succ = swd_write_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, SCS_DHCSR_KEY) == 1; furi_mutex_release(ctx->app->swd_mutex); } if(!succ) { swd_script_log(ctx, FuriLogLevelError, "swd_write_memory failed"); } else { swd_script_log(ctx, FuriLogLevelDefault, "Core continued"); } swd_script_seek_newline(ctx); return succ; } static bool swd_scriptfunc_core_step(ScriptContext* ctx) { bool succ = false; uint32_t data = 0; furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); succ = swd_read_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, &data) == 1; if(!(data & SCS_DHCSR_S_HALT)) { swd_script_log(ctx, FuriLogLevelError, "Core is not in debug state"); succ = false; } else { succ = swd_write_memory( ctx->app, ctx->selected_ap, SCS_DHCSR, SCS_DHCSR_KEY | SCS_DHCSR_C_STEP | SCS_DHCSR_C_MASKINTS | SCS_DHCSR_C_DEBUGEN) == 1; } furi_mutex_release(ctx->app->swd_mutex); if(!succ) { swd_script_log(ctx, FuriLogLevelError, "swd_write_memory failed"); } else { swd_script_log(ctx, FuriLogLevelDefault, "Core stepped"); } swd_script_seek_newline(ctx); return succ; } static struct cpu_regs_type { uint8_t regsel; const char* desc; } cpu_regs[] = { {0x00, "R00"}, {0x01, "R01"}, {0x02, "R02"}, {0x03, "R03"}, {0x04, "R04"}, {0x05, "R05"}, {0x06, "R06"}, {0x07, "R07"}, {0x08, "R08"}, {0x09, "R09"}, {0x0A, "R10"}, {0x0B, "R11"}, {0x0C, "R12"}, {0x0D, "SP/R13"}, {0x0E, "LR/R14"}, {0x0F, "PC/R15"}, {0x10, "xPSR"}, {0x11, "MSP"}, {0x12, "PSP"}, {0x14, "Flags"}, {0x21, "FPCSR"}, {0x40, "FP S00"}, {0x41, "FP S01"}, {0x42, "FP S02"}, {0x43, "FP S03"}, {0x44, "FP S04"}, {0x45, "FP S05"}, {0x46, "FP S06"}, {0x47, "FP S07"}, {0x48, "FP S08"}, {0x49, "FP S09"}, {0x4A, "FP S10"}, {0x4B, "FP S11"}, {0x4C, "FP S12"}, {0x4D, "FP S13"}, {0x4E, "FP S14"}, {0x4F, "FP S15"}, {0x50, "FP S16"}, {0x51, "FP S17"}, {0x52, "FP S18"}, {0x53, "FP S19"}, {0x54, "FP S20"}, {0x55, "FP S21"}, {0x56, "FP S22"}, {0x57, "FP S23"}, {0x58, "FP S24"}, {0x59, "FP S25"}, {0x5A, "FP S26"}, {0x5B, "FP S27"}, {0x5C, "FP S28"}, {0x5D, "FP S29"}, {0x5E, "FP S30"}, {0x5F, "FP S31"}}; static bool swd_scriptfunc_core_regs(ScriptContext* ctx) { bool succ = false; furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); uint32_t reg_dhcsr = 0; uint32_t reg_cpacr = 0; swd_read_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, ®_dhcsr); swd_read_memory(ctx->app, ctx->selected_ap, SCS_CPACR, ®_cpacr); /* when FPU is enabled/available, CP10 and CP11 are implemented */ bool has_fpu = ((reg_cpacr >> 20) & 0x0F) != 0; if(!(reg_dhcsr & SCS_DHCSR_S_HALT)) { swd_script_log(ctx, FuriLogLevelError, "Core is not in debug state"); succ = false; } else { for(size_t pos = 0; pos < COUNT(cpu_regs); pos++) { if(!has_fpu && (cpu_regs[pos].regsel >= 0x20)) { continue; } uint32_t core_data = 0; succ = swd_write_memory( ctx->app, ctx->selected_ap, SCS_DCRSR, SCS_DCRSR_RD | cpu_regs[pos].regsel) == 1; succ &= swd_read_memory(ctx->app, ctx->selected_ap, SCS_DCRDR, &core_data) == 1; if(!succ) { swd_script_log(ctx, FuriLogLevelDefault, "%08s ----------", cpu_regs[pos].desc); } else { swd_script_log( ctx, FuriLogLevelDefault, "%06s 0x%08X", cpu_regs[pos].desc, core_data); } } } furi_mutex_release(ctx->app->swd_mutex); swd_script_seek_newline(ctx); return true; } static bool swd_scriptfunc_core_reg_get(ScriptContext* ctx) { uint32_t core_reg = 0; uint32_t core_data = 0; bool succ = false; if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } if(!swd_script_get_number(ctx, &core_reg)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse register"); return false; } furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); uint32_t reg_dhcsr = 0; uint32_t reg_cpacr = 0; swd_read_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, ®_dhcsr); swd_read_memory(ctx->app, ctx->selected_ap, SCS_CPACR, ®_cpacr); /* when FPU is enabled/available, CP10 and CP11 are implemented */ bool has_fpu = ((reg_cpacr >> 20) & 0x0F) != 0; if(!(reg_dhcsr & SCS_DHCSR_S_HALT)) { swd_script_log(ctx, FuriLogLevelError, "Core is not in debug state"); succ = false; } else { if(!has_fpu && (core_reg >= 0x20)) { swd_script_log(ctx, FuriLogLevelError, "Core has no FP extensions"); succ = false; } else { succ = swd_write_memory( ctx->app, ctx->selected_ap, SCS_DCRSR, SCS_DCRSR_RD | core_reg) == 1; succ &= swd_read_memory(ctx->app, ctx->selected_ap, SCS_DCRDR, &core_data) == 1; if(!succ) { swd_script_log(ctx, FuriLogLevelError, "swd_write_memory failed"); } } } furi_mutex_release(ctx->app->swd_mutex); if(succ) { swd_script_log(ctx, FuriLogLevelDefault, "0x%08X", core_data); } swd_script_seek_newline(ctx); return succ; } static bool swd_scriptfunc_core_reg_set(ScriptContext* ctx) { uint32_t core_reg = 0; uint32_t core_data = 0; bool succ = false; if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } if(!swd_script_get_number(ctx, &core_reg)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse register"); return false; } if(!swd_script_skip_whitespace(ctx)) { swd_script_log(ctx, FuriLogLevelError, "missing whitespace"); return false; } if(!swd_script_get_number(ctx, &core_data)) { swd_script_log(ctx, FuriLogLevelError, "failed to parse data"); return false; } furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); uint32_t reg_dhcsr = 0; uint32_t reg_cpacr = 0; swd_read_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, ®_dhcsr); swd_read_memory(ctx->app, ctx->selected_ap, SCS_CPACR, ®_cpacr); /* when FPU is enabled/available, CP10 and CP11 are implemented */ bool has_fpu = ((reg_cpacr >> 20) & 0x0F) != 0; if(!(reg_dhcsr & SCS_DHCSR_S_HALT)) { swd_script_log(ctx, FuriLogLevelError, "Core is not in debug state"); succ = false; } else { if(!has_fpu && (core_reg >= 0x20)) { swd_script_log(ctx, FuriLogLevelError, "Core has no FP extensions"); succ = false; } else { succ = swd_write_memory(ctx->app, ctx->selected_ap, SCS_DCRDR, core_data) == 1; succ &= swd_write_memory( ctx->app, ctx->selected_ap, SCS_DCRSR, SCS_DCRSR_WR | core_reg) == 1; if(!succ) { swd_script_log(ctx, FuriLogLevelError, "swd_write_memory failed"); } } } furi_mutex_release(ctx->app->swd_mutex); swd_script_seek_newline(ctx); return succ; } static bool swd_scriptfunc_core_cpuid(ScriptContext* ctx) { bool succ = false; uint32_t reg_cpuid = 0; furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever); succ = swd_read_memory(ctx->app, ctx->selected_ap, SCS_CPUID, ®_cpuid) == 1; furi_mutex_release(ctx->app->swd_mutex); if(!succ) { swd_script_log(ctx, FuriLogLevelError, "swd_read_memory failed"); } else { swd_script_log(ctx, FuriLogLevelDefault, "0x%08X", reg_cpuid); } swd_script_seek_newline(ctx); return succ; } static const ScriptFunctionInfo script_funcs[] = { {"#", &swd_scriptfunc_comment}, {".label", &swd_scriptfunc_label}, {"goto", &swd_scriptfunc_goto}, {"call", &swd_scriptfunc_call}, {"status", &swd_scriptfunc_status}, {"errors", &swd_scriptfunc_errors}, {"message", &swd_scriptfunc_message}, {"beep", &swd_scriptfunc_beep}, {"max_tries", &swd_scriptfunc_maxtries}, {"swd_clock_delay", &swd_scriptfunc_swd_clock_delay}, {"swd_idle_bits", &swd_scriptfunc_swd_idle_bits}, {"block_size", &swd_scriptfunc_blocksize}, {"abort", &swd_scriptfunc_abort}, {"mem_dump", &swd_scriptfunc_mem_dump}, {"mem_ldmst", &swd_scriptfunc_mem_ldmst}, {"mem_write", &swd_scriptfunc_mem_write}, {"mem_read", &swd_scriptfunc_mem_read}, {"dp_write", &swd_scriptfunc_dp_write}, {"dp_read", &swd_scriptfunc_dp_read}, {"ap_scan", &swd_scriptfunc_apscan}, {"ap_select", &swd_scriptfunc_apselect}, {"ap_read", &swd_scriptfunc_ap_read}, {"ap_write", &swd_scriptfunc_ap_write}, {"core_halt", &swd_scriptfunc_core_halt}, {"core_step", &swd_scriptfunc_core_step}, {"core_continue", &swd_scriptfunc_core_continue}, {"core_regs", &swd_scriptfunc_core_regs}, {"core_reg_get", &swd_scriptfunc_core_reg_get}, {"core_reg_set", &swd_scriptfunc_core_reg_set}, {"core_cpuid", &swd_scriptfunc_core_cpuid}}; /************************** script main code **************************/ static bool swd_execute_script_line(ScriptContext* const ctx) { char buffer[64]; uint64_t start_pos = 0; if(ctx->script_file) { start_pos = storage_file_tell(ctx->script_file); uint16_t ret = storage_file_read(ctx->script_file, buffer, 2); storage_file_seek(ctx->script_file, start_pos, true); if(ret < 2) { return true; } } else { start_pos = ctx->line_pos; strncpy(buffer, ctx->line_data, 2); if(buffer[0] == 0 || buffer[1] == 0) { return true; } } if(buffer[0] == '\n' || (buffer[0] == '\r' && buffer[1] == '\n')) { swd_script_seek_newline(ctx); return true; } for(size_t entry = 0; entry < COUNT(script_funcs); entry++) { if(ctx->abort) { DBGS("aborting"); break; } size_t expected = strlen(script_funcs[entry].prefix); if(ctx->script_file) { storage_file_seek(ctx->script_file, start_pos, true); if(storage_file_read(ctx->script_file, buffer, expected) != expected) { continue; } } else { ctx->line_pos = start_pos; if(strlen(ctx->line_data) < expected) { continue; } strncpy(buffer, ctx->line_data, expected); ctx->line_pos += expected; } buffer[expected] = '\000'; if(strncmp(buffer, script_funcs[entry].prefix, expected)) { continue; } bool success = true; if(ctx->goto_active) { DBG("ignore: '%s'", script_funcs[entry].prefix); /* only execute label handlers */ if(buffer[0] == '.') { success = script_funcs[entry].func(ctx); } else { swd_script_seek_newline(ctx); } } else { DBG("command: '%s'", script_funcs[entry].prefix); if(!ctx->status_ignore) { snprintf( ctx->app->state_string, sizeof(ctx->app->state_string), "CMD: %s", script_funcs[entry].prefix); } swd_script_gui_refresh(ctx); /* function, execute */ success = script_funcs[entry].func(ctx); if(!success && !ctx->errors_ignore) { swd_script_log( ctx, FuriLogLevelError, "Command failed: %s", script_funcs[entry].prefix); snprintf( ctx->app->state_string, sizeof(ctx->app->state_string), "Command failed: %s", script_funcs[entry].prefix); return false; } } return true; } swd_script_log(ctx, FuriLogLevelError, "unknown command '%s'", buffer); return false; } static bool swd_execute_script(AppFSM* const ctx, const char* filename) { bool success = true; /* fetch current script and set as parent */ ScriptContext* parent = ctx->script; ctx->script = malloc(sizeof(ScriptContext)); ctx->script->app = ctx; ctx->script->max_tries = 1; ctx->script->parent = parent; strcpy(ctx->script->filename, filename); if(!storage_file_exists(ctx->storage, filename)) { DBG("Does not exist '%s'", filename); parent = ctx->script->parent; free(ctx->script); ctx->script = parent; return false; } /* first allocate a file object */ ctx->script->script_file = storage_file_alloc(ctx->storage); /* then get our script opened */ if(!storage_file_open(ctx->script->script_file, filename, FSAM_READ, FSOM_OPEN_EXISTING)) { FURI_LOG_E(TAG, "open, %s", storage_file_get_error_desc(ctx->script->script_file)); DBG("Failed to open '%s'", filename); storage_file_free(ctx->script->script_file); parent = ctx->script->parent; free(ctx->script); ctx->script = parent; return false; } do { success = true; ctx->script->restart = false; storage_file_seek(ctx->script->script_file, 0, true); uint32_t line = 1; while(line < SCRIPT_MAX_LINES) { if(ctx->script->abort) { DBGS("Abort requested"); break; } if(storage_file_eof(ctx->script->script_file)) { break; } DBG("line %lu", line); if(!swd_execute_script_line(ctx->script)) { success = false; break; } if(ctx->script->restart) { break; } line++; } if(ctx->script->restart) { DBGS("Restarting"); } else { DBGS("Finished"); } if(line >= SCRIPT_MAX_LINES) { success = true; char text_buf[128]; snprintf(text_buf, sizeof(text_buf), "aborting after %d lines", SCRIPT_MAX_LINES); DialogMessage* message = dialog_message_alloc(); dialog_message_set_header(message, "SWD Probe", 16, 2, AlignLeft, AlignTop); dialog_message_set_icon(message, &I_app, 3, 2); dialog_message_set_text(message, text_buf, 3, 16, AlignLeft, AlignTop); dialog_message_set_buttons(message, "Back", NULL, NULL); dialog_message_free(message); ctx->script->restart = false; } if(!success) { char text_buf[128]; snprintf(text_buf, sizeof(text_buf), "Line %lu failed:\n%s", line, ctx->state_string); DialogMessage* message = dialog_message_alloc(); dialog_message_set_header(message, "SWD Probe", 16, 2, AlignLeft, AlignTop); dialog_message_set_icon(message, &I_app, 3, 2); dialog_message_set_text(message, text_buf, 3, 16, AlignLeft, AlignTop); dialog_message_set_buttons(message, "Back", "Retry", NULL); if(dialog_message_show(ctx->dialogs, message) == DialogMessageButtonCenter) { ctx->script->restart = true; } dialog_message_free(message); } } while(ctx->script->restart); storage_file_close(ctx->script->script_file); storage_file_free(ctx->script->script_file); parent = ctx->script->parent; free(ctx->script); ctx->script = parent; return success; } /************************** UI functions **************************/ #define CANVAS_WIDTH 128 #define CANVAS_HEIGHT 64 #define COERCE(d, min, max) \ do { \ if(d < (min)) { \ d = (min); \ } \ if(d > (max)) { \ d = (max); \ } \ } while(0) #define COERCE_COORDS(x1, y1, x2, y2) \ do { \ COERCE(x1, 0, CANVAS_WIDTH); \ COERCE(x2, 0, CANVAS_WIDTH); \ COERCE(y1, 0, CANVAS_HEIGHT); \ COERCE(y1, 0, CANVAS_HEIGHT); \ } while(0) #include "model/model_chip.h" static int rotatedVertexCoords[NUM_VERTICES][3]; static void draw_model(Canvas* const canvas) { static float xAngle = 0; static float yAngle = 0; static float zAngle = 0; static float zoom = 0; static float speed = 0.6f; float cosXAngle = cosf(xAngle); float sinXAngle = sinf(xAngle); float cosYAngle = cosf(yAngle); float sinYAngle = sinf(yAngle); float cosZAngle = cosf(zAngle); float sinZAngle = sinf(zAngle); float sinZoom = 1.2f + sinf(zoom) * 0.25f; int centerX = CANVAS_WIDTH / 2; int centerY = CANVAS_HEIGHT / 2 + 5; for(int i = 0; i < NUM_VERTICES; i++) { int x = vertexCoords[i][0] * sinZoom * 16; int y = vertexCoords[i][1] * sinZoom * 16; int z = vertexCoords[i][2] * sinZoom * 16; int y1 = y * cosXAngle - z * sinXAngle; int z1 = y * sinXAngle + z * cosXAngle; int x2 = x * cosYAngle + z1 * sinYAngle; int z2 = -x * sinYAngle + z1 * cosYAngle; int x3 = x2 * cosZAngle - y1 * sinZAngle; int y3 = x2 * sinZAngle + y1 * cosZAngle; rotatedVertexCoords[i][0] = x3 + centerX; rotatedVertexCoords[i][1] = y3 + centerY; rotatedVertexCoords[i][2] = z2; } for(size_t i = 0; i < COUNT(edgeIndices); i++) { int v1Index = edgeIndices[i][0]; int v2Index = edgeIndices[i][1]; int x1 = rotatedVertexCoords[v1Index][0]; int y1 = rotatedVertexCoords[v1Index][1]; int x2 = rotatedVertexCoords[v2Index][0]; int y2 = rotatedVertexCoords[v2Index][1]; COERCE_COORDS(x1, y1, x2, y2); canvas_draw_line(canvas, x1, y1, x2, y2); } xAngle += speed * 0.02 / sinZoom; yAngle += speed * 0.023 / sinZoom; zAngle += speed * 0.029 * sinZoom; zoom += speed * 0.005; } static void render_callback(Canvas* const canvas, void* ctx_in) { furi_assert(canvas); furi_assert(ctx_in); AppFSM* ctx = ctx_in; furi_mutex_acquire(ctx->gui_mutex, FuriWaitForever); char buffer[64]; int y = 10; canvas_draw_frame(canvas, 0, 0, 128, 64); canvas_set_font(canvas, FontPrimary); if(!ctx->detected_device) { ctx->mode_page = ModePageScan; } else if(ctx->mode_page == ModePageScan) { ctx->mode_page = ModePageFound; } /* if seen less than a quarter second ago */ switch(ctx->mode_page) { case ModePageScan: { draw_model(canvas); canvas_draw_str_aligned(canvas, 64, y, AlignCenter, AlignBottom, "Searching"); y += 14; canvas_set_font(canvas, FontSecondary); bool info_page = (ctx->loop_count % 500) >= 250; if(info_page) { canvas_draw_str(canvas, 2, y, "Connect GND with target GND"); y += 10; canvas_draw_str(canvas, 2, y, "and any two GPIOs with pads"); y += 10; canvas_draw_str(canvas, 2, y, "you want to check for SWD"); canvas_set_font(canvas, FontPrimary); canvas_draw_str(canvas, 111, 62, "2/2"); } else { const char* filename = "<none>"; if(strlen(ctx->script_detected) > 0) { const char* slash = strrchr(ctx->script_detected, '/'); if(slash) { filename = &slash[1]; } else { filename = ctx->script_detected; } } canvas_set_font(canvas, FontSecondary); canvas_draw_str_aligned(canvas, 64, y, AlignCenter, AlignBottom, "Autoexec Script"); y += 10; canvas_set_font(canvas, FontKeyboard); canvas_draw_str_aligned(canvas, 64, y, AlignCenter, AlignBottom, filename); y += 16; canvas_set_font(canvas, FontSecondary); canvas_draw_icon(canvas, 14, y - 5, &I_ButtonUp_7x4); canvas_draw_icon(canvas, 78, y - 5, &I_ButtonDown_7x4); canvas_draw_str(canvas, 23, y, "Clear"); canvas_draw_str(canvas, 87, y, "Choose"); canvas_set_font(canvas, FontPrimary); canvas_draw_str(canvas, 111, 62, "1/2"); } canvas_set_font(canvas, FontSecondary); elements_button_left(canvas, "Script"); break; } case ModePageFound: { if((ctx->detected_timeout + TIMER_HZ / 4) >= TIMER_HZ * TIMEOUT) { snprintf(buffer, sizeof(buffer), "FOUND!"); } else { /* if it was seen more than a quarter second ago, show countdown */ snprintf( buffer, sizeof(buffer), "FOUND! (%lus)", (ctx->detected_timeout / TIMER_HZ) + 1); } canvas_draw_str_aligned(canvas, 64, y, AlignCenter, AlignBottom, buffer); y += 10; canvas_set_font(canvas, FontKeyboard); snprintf( buffer, sizeof(buffer), "SWC/SWD: %s/%s", gpio_name(ctx->io_swc), gpio_name(ctx->io_swd)); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; snprintf(buffer, sizeof(buffer), "DPIDR 0x%08lX", ctx->dp_regs.dpidr); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; snprintf( buffer, sizeof(buffer), "Part %02X Rev %X DAPv%d", ctx->dpidr_info.partno, ctx->dpidr_info.revision, ctx->dpidr_info.version); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; canvas_set_font(canvas, FontSecondary); snprintf(buffer, sizeof(buffer), "%s", jep106_manufacturer(ctx->dpidr_info.designer)); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; canvas_set_font(canvas, FontSecondary); elements_button_left(canvas, "Script"); elements_button_right(canvas, "DP Regs"); break; } case ModePageDPRegs: { canvas_draw_str_aligned(canvas, 64, y, AlignCenter, AlignBottom, "DP Registers"); y += 10; canvas_set_font(canvas, FontKeyboard); if(ctx->dp_regs.dpidr_ok) { snprintf(buffer, sizeof(buffer), "DPIDR %08lX", ctx->dp_regs.dpidr); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); } y += 10; if(ctx->dp_regs.ctrlstat_ok) { snprintf(buffer, sizeof(buffer), "CTRL %08lX", ctx->dp_regs.ctrlstat); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); } y += 10; if(ctx->dp_regs.targetid_ok) { snprintf(buffer, sizeof(buffer), "TGTID %08lX", ctx->dp_regs.targetid); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); } y += 10; if(ctx->dp_regs.eventstat_ok) { snprintf(buffer, sizeof(buffer), "EVTST %08lX", ctx->dp_regs.eventstat); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); } y += 10; canvas_set_font(canvas, FontSecondary); elements_button_left(canvas, "Scan"); elements_button_right(canvas, "DPID"); break; } case ModePageDPID: { canvas_draw_str_aligned(canvas, 64, y, AlignCenter, AlignBottom, "DP ID Register"); y += 10; canvas_set_font(canvas, FontKeyboard); if(ctx->dpidr_info.version != 2) { snprintf(buffer, sizeof(buffer), "TARGETID not supported"); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; } else { if(ctx->dp_regs.targetid_ok) { snprintf(buffer, sizeof(buffer), "TGTID %08lX", ctx->dp_regs.targetid); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; snprintf(buffer, sizeof(buffer), "Part No. %04X", ctx->targetid_info.partno); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; snprintf( buffer, sizeof(buffer), "%s", jep106_manufacturer(ctx->targetid_info.designer)); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; } } canvas_set_font(canvas, FontSecondary); elements_button_left(canvas, "DP Regs"); elements_button_right(canvas, "APs"); break; } case ModePageAPID: { canvas_draw_str_aligned(canvas, 64, y, AlignCenter, AlignBottom, "AP Menu"); y += 10; canvas_set_font(canvas, FontKeyboard); char state = ' '; if(ctx->ap_pos >= ctx->ap_scanned && ctx->ap_pos <= ctx->ap_scanned + 10) { state = '*'; } if(!ctx->apidr_info[ctx->ap_pos].ok) { snprintf(buffer, sizeof(buffer), "[%d]%c<none>", ctx->ap_pos, state); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; if(ctx->ap_pos == 0) { for(size_t pos = 0; pos < COUNT(ctx->apidr_info); pos++) { if(ctx->apidr_info[pos].ok) { ctx->ap_pos = pos; } } } } else { const char* class = ""; switch(ctx->apidr_info[ctx->ap_pos].class) { case 0: class = "und"; break; case 1: class = "COM"; break; case 8: class = "MEM"; break; default: class = "unk"; break; } const char* types[] = { "COM-AP", "AHB3", "APB2 or APB3", "Type unknown", "AXI3 or AXI4", "AHB5", "APB4 and APB5", "AXI5", "AHB5 enh.", }; const char* type = "Type unk"; if(ctx->apidr_info[ctx->ap_pos].type < COUNT(types)) { type = types[ctx->apidr_info[ctx->ap_pos].type]; } snprintf(buffer, sizeof(buffer), "[%d]%c%s, %s", ctx->ap_pos, state, class, type); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; snprintf(buffer, sizeof(buffer), "Base 0x%08lX", ctx->apidr_info[ctx->ap_pos].base); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; snprintf( buffer, sizeof(buffer), "Rev %d Var %d", ctx->apidr_info[ctx->ap_pos].revision, ctx->apidr_info[ctx->ap_pos].variant); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; snprintf( buffer, sizeof(buffer), "%s", jep106_manufacturer(ctx->apidr_info[ctx->ap_pos].designer)); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; elements_button_center(canvas, "Show"); } canvas_set_font(canvas, FontSecondary); elements_button_left(canvas, "DPID"); elements_button_right(canvas, "CoreS."); elements_scrollbar_pos(canvas, 4, 10, 40, ctx->ap_pos / 32, COUNT(ctx->apidr_info) / 32); break; } /* hex dump view */ case ModePageHexDump: { canvas_draw_str_aligned(canvas, 64, y, AlignCenter, AlignBottom, "Hex dump"); y += 10; canvas_set_font(canvas, FontKeyboard); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, "Addr:"); snprintf(buffer, sizeof(buffer), "%08lX", ctx->hex_addr); canvas_draw_str_aligned(canvas, 38, y, AlignLeft, AlignBottom, buffer); uint32_t font_width = canvas_glyph_width(canvas, '0'); uint32_t x = 37 + (7 - ctx->hex_select) * font_width; /* draw selection */ canvas_draw_line(canvas, x, y + 1, x + font_width, y + 1); y += 10; uint32_t byte_num = 0; for(int line = 0; line < 4; line++) { uint32_t x_pos = 5; for(int byte_pos = 0; byte_pos < 8; byte_pos++) { if(ctx->hex_buffer_valid[byte_num / 4]) { snprintf(buffer, sizeof(buffer), "%02X", ctx->hex_buffer[byte_num]); } else { snprintf(buffer, sizeof(buffer), "--"); } byte_num++; canvas_draw_str_aligned(canvas, x_pos, y, AlignLeft, AlignBottom, buffer); x_pos += font_width * 2 + font_width / 2; } y += 10; } break; } case ModePageCoresight: { canvas_draw_str_aligned(canvas, 64, y, AlignCenter, AlignBottom, "Coresight"); y += 10; canvas_set_font(canvas, FontSecondary); uint32_t base = ctx->coresight_bases[ctx->coresight_level]; uint32_t base_next = adi_romtable_get(ctx, base, ctx->coresight_pos[ctx->coresight_level]); snprintf(buffer, sizeof(buffer), "Base: %08lX", base); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; snprintf(buffer, sizeof(buffer), "Type: %s", adi_romtable_type(ctx, base)); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; snprintf(buffer, sizeof(buffer), "Full: %s", adi_romtable_full(ctx, base)); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); y += 10; if(adi_is_romtable(ctx, base)) { snprintf( buffer, sizeof(buffer), "[%lu/%lu] -> %08lX", ctx->coresight_pos[ctx->coresight_level] + 1, ctx->coresight_count[ctx->coresight_level], base_next); canvas_draw_str_aligned(canvas, 5, y, AlignLeft, AlignBottom, buffer); canvas_set_font(canvas, FontSecondary); elements_button_center(canvas, "Enter"); } y += 10; canvas_set_font(canvas, FontSecondary); if(ctx->coresight_level) { elements_button_left(canvas, "Prev"); } else { elements_button_left(canvas, "APs"); } elements_scrollbar_pos( canvas, 4, 10, 40, ctx->coresight_pos[ctx->coresight_level], ctx->coresight_count[ctx->coresight_level]); break; } /* hex dump view */ case ModePageScript: { canvas_draw_str_aligned(canvas, 64, y, AlignCenter, AlignBottom, "Script"); y += 10; y += 10; canvas_draw_str_aligned(canvas, 10, y, AlignLeft, AlignBottom, "Status:"); y += 10; canvas_set_font(canvas, FontKeyboard); canvas_draw_str_aligned(canvas, 64, y, AlignCenter, AlignBottom, ctx->state_string); y += 10; break; } } furi_mutex_release(ctx->gui_mutex); } static void input_callback(InputEvent* input_event, void* ctx_in) { furi_assert(input_event); furi_assert(ctx_in); AppFSM* ctx = ctx_in; int entries = furi_message_queue_get_count(ctx->event_queue); /* better skip than sorry */ if(entries < QUEUE_SIZE) { AppEvent event = {.type = EventKeyPress, .input = *input_event}; furi_message_queue_put(ctx->event_queue, &event, 0); } } static void app_init(AppFSM* const app) { furi_assert(app); app->loop_count = 0; app->current_mask_id = 0; app->current_mask = gpio_direction_mask[app->current_mask_id]; app->io_swd = 0xFF; app->io_swc = 0xFF; app->hex_addr = 0x40002800; app->hex_addr = 0xE000EDF0; app->swd_clock_delay = CLOCK_DELAY; app->swd_idle_bits = IDLE_BITS; strcpy(app->state_string, "none"); strcpy(app->script_detected, ""); } static void app_deinit(AppFSM* const app) { furi_assert(app); strcpy(app->state_string, "exiting"); } static void swd_main_loop(AppFSM* ctx) { furi_assert(ctx); ctx->loop_count++; switch(ctx->mode_page) { case ModePageScan: case ModePageFound: { /* reset after timeout */ if(ctx->detected_timeout > 0) { ctx->detected_timeout--; } else { DBGS("Reset detected flag"); ctx->detected_device = false; ctx->io_swd = 0xFF; ctx->io_swc = 0xFF; ctx->io_num_swd = 0xFF; ctx->io_num_swc = 0xFF; ctx->ap_scanned = 0; memset(&ctx->dp_regs, 0x00, sizeof(ctx->dp_regs)); memset(&ctx->targetid_info, 0x00, sizeof(ctx->targetid_info)); memset(&ctx->apidr_info, 0x00, sizeof(ctx->apidr_info)); ctx->script_detected_executed = false; } ctx->detected = false; ctx->current_mask = gpio_direction_mask[ctx->current_mask_id]; /* when SWD was already detected, set it to data pin regardless of the mask */ if(ctx->detected_device) { ctx->current_mask &= ~ctx->io_swd; } /* do the scan */ furi_mutex_acquire(ctx->swd_mutex, FuriWaitForever); swd_scan(ctx); furi_mutex_release(ctx->swd_mutex); /* now when detected a device, set the timeout */ if(ctx->detected) { DBGS("Set detected flag"); ctx->detected_device = true; ctx->detected_timeout = TIMER_HZ * TIMEOUT; /* update DPIDR fields */ ctx->dpidr_info.revision = (ctx->dp_regs.dpidr >> 28) & 0x0F; ctx->dpidr_info.partno = (ctx->dp_regs.dpidr >> 20) & 0xFF; ctx->dpidr_info.version = (ctx->dp_regs.dpidr >> 12) & 0x0F; ctx->dpidr_info.designer = (ctx->dp_regs.dpidr >> 1) & 0x3FF; if(!has_multiple_bits(ctx->io_swc)) { DBGS(" - Detected pins"); DBGS(" - Resetting error"); furi_mutex_acquire(ctx->swd_mutex, FuriWaitForever); /* reset error */ /* first make sure we have the correct bank by invalidating the current select cache */ ctx->dp_regs.select_ok = false; uint8_t ack = swd_read_dpbank(ctx, REG_CTRLSTAT, REG_CTRLSTAT_BANK, &ctx->dp_regs.ctrlstat); if(ack != 1 || (ctx->dp_regs.ctrlstat & STAT_ERROR_FLAGS)) { DBGS(" - send ABORT"); swd_abort(ctx); } DBGS(" - Fetch CTRL/STAT"); ctx->dp_regs.ctrlstat_ok = swd_read_dpbank( ctx, REG_CTRLSTAT, REG_CTRLSTAT_BANK, &ctx->dp_regs.ctrlstat) == 1; DBG(" %08lX %s", ctx->dp_regs.ctrlstat, ctx->dp_regs.ctrlstat_ok ? "OK" : "FAIL"); if(ctx->dpidr_info.version >= 1) { DBGS(" - DAPv1, read DLCR"); ctx->dp_regs.dlcr_ok = swd_read_dpbank(ctx, REG_DLCR, REG_DLCR_BANK, &ctx->dp_regs.dlcr) == 1; DBG(" %08lX %s", ctx->dp_regs.dlcr, ctx->dp_regs.dlcr_ok ? "OK" : "FAIL"); } if(ctx->dpidr_info.version >= 2) { DBGS(" - DAPv2, read TARGETID"); ctx->dp_regs.targetid_ok = swd_read_dpbank( ctx, REG_TARGETID, REG_TARGETID_BANK, &ctx->dp_regs.targetid) == 1; DBG(" %08lX %s", ctx->dp_regs.targetid, ctx->dp_regs.targetid_ok ? "OK" : "FAIL"); DBGS(" - DAPv2, read EVENTSTAT"); ctx->dp_regs.eventstat_ok = swd_read_dpbank( ctx, REG_EVENTSTAT, REG_EVENTSTAT_BANK, &ctx->dp_regs.eventstat) == 1; DBG(" %08lX %s", ctx->dp_regs.eventstat, ctx->dp_regs.eventstat_ok ? "OK" : "FAIL"); DBGS(" - DAPv2, read DLPIDR"); ctx->dp_regs.dlpidr_ok = swd_read_dpbank(ctx, REG_DLPIDR, REG_DLPIDR_BANK, &ctx->dp_regs.dlpidr) == 1; DBG(" %08lX %s", ctx->dp_regs.dlpidr, ctx->dp_regs.dlpidr_ok ? "OK" : "FAIL"); } if(ctx->dp_regs.targetid_ok) { ctx->targetid_info.revision = (ctx->dp_regs.targetid >> 28) & 0x0F; ctx->targetid_info.partno = (ctx->dp_regs.targetid >> 12) & 0xFFFF; ctx->targetid_info.designer = (ctx->dp_regs.targetid >> 1) & 0x3FF; } if(!ctx->script_detected_executed && strlen(ctx->script_detected) > 0) { DBG(" - Run script '%s'", ctx->script_detected); ctx->script_detected_executed = true; ctx->mode_page = ModePageScript; swd_execute_script(ctx, ctx->script_detected); ctx->mode_page = ModePageFound; } furi_mutex_release(ctx->swd_mutex); } } else { if(!has_multiple_bits(ctx->io_swc)) { DBGS(" - Lost device"); } } ctx->current_mask_id = (ctx->current_mask_id + 1) % COUNT(gpio_direction_mask); break; } case ModePageDPRegs: case ModePageAPID: { furi_mutex_acquire(ctx->swd_mutex, FuriWaitForever); /* set debug enable request */ if(!swd_ensure_powerup(ctx)) { furi_mutex_release(ctx->swd_mutex); break; } /* only scan a few APs at once to stay responsive */ for(int pos = 0; pos < 8; pos++) { if(ctx->ap_scanned == 0) { swd_apscan_reset(ctx); } uint8_t ap = ctx->ap_scanned++; if(ctx->apidr_info[ap].tested) { continue; } if(swd_apscan_test(ctx, ap)) { break; } } furi_mutex_release(ctx->swd_mutex); break; } case ModePageHexDump: { furi_mutex_acquire(ctx->swd_mutex, FuriWaitForever); for(size_t byte_pos = 0; byte_pos < sizeof(ctx->hex_buffer); byte_pos += 4) { uint32_t* data = (uint32_t*)&ctx->hex_buffer[byte_pos]; bool ret = swd_read_memory(ctx, ctx->ap_pos, ctx->hex_addr + byte_pos, data) == 1; ctx->hex_buffer_valid[byte_pos / 4] = ret; if(!ret) { swd_abort_simple(ctx); } } furi_mutex_release(ctx->swd_mutex); break; } case ModePageDPID: case ModePageCoresight: furi_delay_ms(50); break; } } static bool swd_message_process(AppFSM* ctx) { bool processing = true; AppEvent event; /* wait to make sure the OS can do its stuff */ FuriStatus event_status = furi_message_queue_get(ctx->event_queue, &event, 1000 / TIMER_HZ); if(event_status != FuriStatusOk) { return processing; } if(event.type == EventKeyPress) { if(event.input.type == InputTypePress) { switch(event.input.key) { case InputKeyUp: switch(ctx->mode_page) { default: break; case ModePageScan: case ModePageFound: { strcpy(ctx->script_detected, ""); break; } case ModePageAPID: if(ctx->ap_pos > 0) { ctx->ap_pos--; } break; case ModePageHexDump: { ctx->hex_addr += ((ctx->hex_select) ? 1 : 8) * (1 << (4 * ctx->hex_select)); break; } case ModePageCoresight: { if(ctx->coresight_pos[ctx->coresight_level] > 0) { ctx->coresight_pos[ctx->coresight_level]--; } break; } } break; case InputKeyDown: { switch(ctx->mode_page) { default: break; case ModePageScan: { FuriString* result_path = furi_string_alloc_printf(ANY_PATH("swd_scripts")); FuriString* preselected = furi_string_alloc_printf( (strlen(ctx->script_detected) > 0) ? ctx->script_detected : ANY_PATH("swd_scripts")); DialogsFileBrowserOptions options; dialog_file_browser_set_basic_options(&options, "swd", &I_swd); if(dialog_file_browser_show(ctx->dialogs, result_path, preselected, &options)) { const char* path = furi_string_get_cstr(result_path); strcpy(ctx->script_detected, path); } furi_string_free(result_path); furi_string_free(preselected); break; } case ModePageAPID: if(ctx->ap_pos + 1U < COUNT(ctx->apidr_info)) { ctx->ap_pos++; } break; case ModePageHexDump: { ctx->hex_addr -= ((ctx->hex_select) ? 1 : 8) * (1 << (4 * ctx->hex_select)); break; } case ModePageCoresight: { if(ctx->coresight_pos[ctx->coresight_level] + 1 < ctx->coresight_count[ctx->coresight_level]) { ctx->coresight_pos[ctx->coresight_level]++; } break; } } break; } case InputKeyRight: if(ctx->mode_page == ModePageHexDump) { if(ctx->hex_select > 0) { ctx->hex_select--; } } else if(ctx->mode_page == ModePageAPID && ctx->apidr_info[ctx->ap_pos].ok) { ctx->mode_page = ModePageCoresight; uint32_t base = ctx->apidr_info[ctx->ap_pos].base & 0xFFFFF000; ctx->coresight_level = 0; ctx->coresight_bases[ctx->coresight_level] = base; ctx->coresight_pos[ctx->coresight_level] = 0; ctx->coresight_count[ctx->coresight_level] = adi_romtable_entry_count(ctx, base); } else if(ctx->detected) { if(ctx->mode_page + 1 < ModePageCount) { ctx->mode_page++; } } break; case InputKeyLeft: if(ctx->mode_page == ModePageHexDump) { if(ctx->hex_select < 7) { ctx->hex_select++; } } else if(ctx->mode_page == ModePageCoresight) { if(ctx->coresight_level > 0) { ctx->coresight_level--; } else { ctx->mode_page = ModePageAPID; } } else if((ctx->mode_page == ModePageScan) || (ctx->mode_page == ModePageFound)) { uint32_t mode_page = ctx->mode_page; FuriString* result_path = furi_string_alloc_printf(ANY_PATH("swd_scripts")); FuriString* preselected = furi_string_alloc_printf( (strlen(ctx->script_detected) > 0) ? ctx->script_detected : ANY_PATH("swd_scripts")); DialogsFileBrowserOptions options; dialog_file_browser_set_basic_options(&options, "swd", &I_swd); if(dialog_file_browser_show(ctx->dialogs, result_path, preselected, &options)) { const char* path = furi_string_get_cstr(result_path); ctx->mode_page = ModePageScript; swd_execute_script(ctx, path); ctx->mode_page = mode_page; } furi_string_free(result_path); furi_string_free(preselected); break; } else { if(ctx->mode_page > 0) { ctx->mode_page--; } } break; case InputKeyOk: if(ctx->mode_page == ModePageAPID && ctx->apidr_info[ctx->ap_pos].ok) { ctx->mode_page = ModePageHexDump; } else if(ctx->mode_page == ModePageCoresight) { uint32_t base = ctx->coresight_bases[ctx->coresight_level]; if(!adi_is_romtable(ctx, base)) { break; } uint32_t cur_pos = ctx->coresight_pos[ctx->coresight_level]; uint32_t base_next = adi_romtable_get(ctx, base, cur_pos); uint32_t new_count = adi_romtable_entry_count(ctx, base_next); ctx->coresight_level++; ctx->coresight_pos[ctx->coresight_level] = 0; ctx->coresight_count[ctx->coresight_level] = new_count; ctx->coresight_bases[ctx->coresight_level] = base_next; } break; case InputKeyBack: if(ctx->mode_page == ModePageHexDump) { ctx->mode_page = ModePageAPID; } else if(ctx->mode_page == ModePageScript) { ctx->script->abort = true; } else if(ctx->mode_page > ModePageFound) { ctx->mode_page = ModePageScan; } else if(ctx->mode_page == ModePageScan) { processing = false; } else if(ctx->mode_page == ModePageFound) { processing = false; } break; default: break; } } } return processing; } size_t data_received(void* ctx, uint8_t* data, size_t length) { AppFSM* app = (AppFSM*)ctx; strncpy(app->commandline->line_data, (const char*)data, length); app->commandline->line_pos = 0; for(size_t pos = 0; pos < length; pos++) { uint8_t ch = app->commandline->line_data[pos]; if((ch == '\r') || (ch == '\n')) { app->commandline->line_data[pos++] = '\n'; app->commandline->line_data[pos] = 0; LOG("direct command '%s'", app->commandline->line_data); swd_execute_script_line(app->commandline); return pos; } } return 0; } int32_t swd_probe_app_main(void* p) { UNUSED(p); AppFSM* app = malloc(sizeof(AppFSM)); DBGS("App init"); app_init(app); DBGS("furi_record_open"); app->notification = furi_record_open(RECORD_NOTIFICATION); app->gui = furi_record_open(RECORD_GUI); app->dialogs = furi_record_open(RECORD_DIALOGS); app->storage = furi_record_open(RECORD_STORAGE); DBGS("furi_mutex_alloc"); app->swd_mutex = furi_mutex_alloc(FuriMutexTypeNormal); app->gui_mutex = furi_mutex_alloc(FuriMutexTypeNormal); app->event_queue = furi_message_queue_alloc(QUEUE_SIZE, sizeof(AppEvent)); DBGS("usb_uart_enable"); UsbUartConfig uart_config; uart_config.vcp_ch = 1; uart_config.rx_data = &data_received; uart_config.rx_data_ctx = app; app->uart = usb_uart_enable(&uart_config); app->commandline = malloc(sizeof(ScriptContext)); app->commandline->max_tries = 1; app->commandline->app = app; DBGS("view_port_alloc"); app->view_port = view_port_alloc(); view_port_draw_callback_set(app->view_port, render_callback, app); view_port_input_callback_set(app->view_port, input_callback, app); gui_add_view_port(app->gui, app->view_port, GuiLayerFullscreen); DBGS("notification_message_block"); notification_message(app->notification, &sequence_display_backlight_enforce_on); DBGS("swd_execute_script"); swd_execute_script(app, ANY_PATH("swd_scripts/startup.swd")); DOLPHIN_DEED(DolphinDeedPluginGameStart); DBGS("processing"); for(bool processing = true; processing;) { swd_main_loop(app); view_port_update(app->view_port); processing = swd_message_process(app); bool beep = false; if(app->detected_device && !app->detected_notified) { app->detected_notified = true; beep = true; } if(!app->detected_device && app->detected_notified) { app->detected_notified = false; } if(beep) { notification_message_block(app->notification, &seq_c_minor); } } view_port_enabled_set(app->view_port, false); gui_remove_view_port(app->gui, app->view_port); view_port_free(app->view_port); app_deinit(app); notification_message(app->notification, &sequence_display_backlight_enforce_auto); usb_uart_disable(app->uart); furi_message_queue_free(app->event_queue); furi_mutex_free(app->gui_mutex); furi_mutex_free(app->swd_mutex); free(app); furi_record_close(RECORD_GUI); furi_record_close(RECORD_NOTIFICATION); furi_record_close(RECORD_DIALOGS); furi_record_close(RECORD_STORAGE); return 0; }