Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

implement more debugger windows

Layle5e69c2f2f90a
diff --git a/crates/debugger/src/windows/controls.rs b/crates/debugger/src/windows/controls.rs
new file mode 100644
index 0000000..0bb1c0b
--- /dev/null
+++ b/crates/debugger/src/windows/controls.rs
@@ -0,0 +1,77 @@
+use egui::Context;
+use egui_material_icons::icons;
+
+use crate::debugger::EmulatorState;
+
+pub fn show_controls(ctx: &Context, open: &mut bool, state: &mut EmulatorState, run_until_addr_input: &mut String) {
+ egui::Window::new("Controls")
+ .open(open)
+ .resizable(false)
+ .default_size(egui::vec2(160.0, 0.0))
+ .show(ctx, |ui| {
+ let is_paused = *state == EmulatorState::Paused;
+ let is_running = *state == EmulatorState::Running;
+
+ ui.set_min_width(140.0);
+
+ let btn_size = egui::vec2(ui.available_width(), 0.0);
+
+ if ui
+ .add_enabled(
+ is_paused,
+ egui::Button::new(format!("{} Continue", icons::ICON_PLAY_ARROW)).min_size(btn_size),
+ )
+ .clicked()
+ {
+ *state = EmulatorState::Running;
+ }
+
+ if ui
+ .add_enabled(
+ is_running,
+ egui::Button::new(format!("{} Pause", icons::ICON_PAUSE)).min_size(btn_size),
+ )
+ .clicked()
+ {
+ *state = EmulatorState::Paused;
+ }
+
+ if ui
+ .add_enabled(
+ is_paused,
+ egui::Button::new(format!("{} Step", icons::ICON_SKIP_NEXT)).min_size(btn_size),
+ )
+ .clicked()
+ {
+ *state = EmulatorState::Step;
+ }
+
+ if ui
+ .add(egui::Button::new(format!("{} Run Until VSync", icons::ICON_FAST_FORWARD)).min_size(btn_size))
+ .clicked()
+ {
+ *state = EmulatorState::RunUntilVsync;
+ }
+
+ ui.separator();
+
+ ui.horizontal(|ui| {
+ let resp = ui.add_enabled(
+ is_paused,
+ egui::TextEdit::singleline(run_until_addr_input)
+ .hint_text("address")
+ .desired_width(80.0)
+ .font(egui::TextStyle::Monospace),
+ );
+ let go = ui
+ .add_enabled(is_paused, egui::Button::new(format!("{} Run", icons::ICON_PLAY_ARROW)))
+ .clicked();
+ if go || (resp.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter))) {
+ let s = run_until_addr_input.trim().trim_start_matches("0x");
+ if let Ok(addr) = u32::from_str_radix(s, 16) {
+ *state = EmulatorState::RunUntilAddress(addr);
+ }
+ }
+ });
+ });
+}
diff --git a/crates/debugger/src/windows/exi.rs b/crates/debugger/src/windows/exi.rs
new file mode 100644
index 0000000..ce4edb0
--- /dev/null
+++ b/crates/debugger/src/windows/exi.rs
@@ -0,0 +1,253 @@
+use egui::{Color32, Context, Grid, RichText};
+use egui_material_icons::icons;
+use gekko::exi::Exi;
+
+fn flag(ui: &mut egui::Ui, val: bool) {
+ let (icon, color) = if val {
+ (icons::ICON_RADIO_BUTTON_CHECKED, Color32::from_rgb(100, 220, 100))
+ } else {
+ (icons::ICON_RADIO_BUTTON_UNCHECKED, Color32::from_rgb(70, 70, 70))
+ };
+ ui.label(RichText::new(icon).color(color));
+}
+
+fn chip_select_str(cs: u8) -> &'static str {
+ match cs {
+ 0b001 => "slot 0",
+ 0b010 => "slot 1",
+ 0b100 => "slot 2",
+ 0b000 => "none",
+ _ => "invalid",
+ }
+}
+
+fn clock_mhz(clk: u8) -> &'static str {
+ match clk {
+ 0 => "~1 MHz",
+ 1 => "~4 MHz",
+ 2 => "~8 MHz",
+ 3 => "~16 MHz",
+ 4 => "~32 MHz",
+ _ => "?",
+ }
+}
+
+struct ChannelInfo {
+ name: &'static str,
+ csr_raw: u32,
+ exi_int_mask: bool,
+ exi_int: bool,
+ tc_int_mask: bool,
+ tc_int: bool,
+ ext_int_mask: bool,
+ ext_int: bool,
+ device_connected: bool,
+ clock: u8,
+ chip_select: u8,
+ transfer_start: bool,
+ dma_mode: bool,
+ transfer_type: &'static str,
+ transfer_length: u8,
+ dma_addr: u32,
+ dma_length: u32,
+ data_raw: u32,
+}
+
+fn channel_info(exi: &Exi, ch: usize) -> ChannelInfo {
+ use gekko::exi::regs::TransferType;
+ match ch {
+ 0 => ChannelInfo {
+ name: "CH0",
+ csr_raw: exi.ch0_csr.raw(),
+ exi_int_mask: exi.ch0_csr.exi_interrupt_mask(),
+ exi_int: exi.ch0_csr.exi_interrupt(),
+ tc_int_mask: exi.ch0_csr.tc_interrupt_mask(),
+ tc_int: exi.ch0_csr.tc_interrupt(),
+ ext_int_mask: exi.ch0_csr.ext_interrupt_mask(),
+ ext_int: exi.ch0_csr.ext_interrupt(),
+ device_connected: exi.ch0_csr.device_connected(),
+ clock: exi.ch0_csr.clock(),
+ chip_select: exi.ch0_csr.chip_select(),
+ transfer_start: exi.ch0_cr.transfer_start(),
+ dma_mode: exi.ch0_cr.dma_mode(),
+ transfer_type: match exi.ch0_cr.transfer_type() {
+ TransferType::Read => "read",
+ TransferType::Write => "write",
+ TransferType::ReadAndWrite => "read+write",
+ TransferType::Reserved => "reserved",
+ },
+ transfer_length: exi.ch0_cr.transfer_length(),
+ dma_addr: exi.ch0_mar.address() << 5,
+ dma_length: exi.ch0_length.length() << 5,
+ data_raw: exi.ch0_data.raw(),
+ },
+ 1 => ChannelInfo {
+ name: "CH1",
+ csr_raw: exi.ch1_csr.raw(),
+ exi_int_mask: exi.ch1_csr.exi_interrupt_mask(),
+ exi_int: exi.ch1_csr.exi_interrupt(),
+ tc_int_mask: exi.ch1_csr.tc_interrupt_mask(),
+ tc_int: exi.ch1_csr.tc_interrupt(),
+ ext_int_mask: exi.ch1_csr.ext_interrupt_mask(),
+ ext_int: exi.ch1_csr.ext_interrupt(),
+ device_connected: exi.ch1_csr.device_connected(),
+ clock: exi.ch1_csr.clock(),
+ chip_select: exi.ch1_csr.chip_select(),
+ transfer_start: exi.ch1_cr.transfer_start(),
+ dma_mode: exi.ch1_cr.dma_mode(),
+ transfer_type: match exi.ch1_cr.transfer_type() {
+ TransferType::Read => "read",
+ TransferType::Write => "write",
+ TransferType::ReadAndWrite => "read+write",
+ TransferType::Reserved => "reserved",
+ },
+ transfer_length: exi.ch1_cr.transfer_length(),
+ dma_addr: exi.ch1_mar.address() << 5,
+ dma_length: exi.ch1_length.length() << 5,
+ data_raw: exi.ch1_data.raw(),
+ },
+ 2 => ChannelInfo {
+ name: "CH2",
+ csr_raw: exi.ch2_csr.raw(),
+ exi_int_mask: exi.ch2_csr.exi_interrupt_mask(),
+ exi_int: exi.ch2_csr.exi_interrupt(),
+ tc_int_mask: exi.ch2_csr.tc_interrupt_mask(),
+ tc_int: exi.ch2_csr.tc_interrupt(),
+ ext_int_mask: exi.ch2_csr.ext_interrupt_mask(),
+ ext_int: exi.ch2_csr.ext_interrupt(),
+ device_connected: exi.ch2_csr.device_connected(),
+ clock: exi.ch2_csr.clock(),
+ chip_select: exi.ch2_csr.chip_select(),
+ transfer_start: exi.ch2_cr.transfer_start(),
+ dma_mode: exi.ch2_cr.dma_mode(),
+ transfer_type: match exi.ch2_cr.transfer_type() {
+ TransferType::Read => "read",
+ TransferType::Write => "write",
+ TransferType::ReadAndWrite => "read+write",
+ TransferType::Reserved => "reserved",
+ },
+ transfer_length: exi.ch2_cr.transfer_length(),
+ dma_addr: exi.ch2_mar.address() << 5,
+ dma_length: exi.ch2_length.length() << 5,
+ data_raw: exi.ch2_data.raw(),
+ },
+ _ => unreachable!(),
+ }
+}
+
+fn show_channel(ui: &mut egui::Ui, ch: &ChannelInfo) {
+ ui.push_id(ch.name, |ui| {
+ ui.strong(ch.name);
+ ui.separator();
+
+ Grid::new(format!("{}_csr", ch.name))
+ .num_columns(4)
+ .striped(true)
+ .show(ui, |ui| {
+ ui.label("CSR");
+ ui.monospace(format!("{:#010X}", ch.csr_raw));
+ ui.label("");
+ ui.label("");
+ ui.end_row();
+
+ ui.label("Device");
+ flag(ui, ch.device_connected);
+ ui.label("Clock");
+ ui.monospace(format!("{} ({})", ch.clock, clock_mhz(ch.clock)));
+ ui.end_row();
+
+ ui.label("CS");
+ ui.monospace(chip_select_str(ch.chip_select));
+ ui.label("");
+ ui.label("");
+ ui.end_row();
+
+ // Interrupt status row
+ ui.label("EXIINT");
+ ui.horizontal(|ui| {
+ flag(ui, ch.exi_int);
+ ui.label("Mask");
+ flag(ui, ch.exi_int_mask);
+ });
+ ui.label("TCINT");
+ ui.horizontal(|ui| {
+ flag(ui, ch.tc_int);
+ ui.label("Mask");
+ flag(ui, ch.tc_int_mask);
+ });
+ ui.end_row();
+
+ ui.label("EXTINT");
+ ui.horizontal(|ui| {
+ flag(ui, ch.ext_int);
+ ui.label("Mask");
+ flag(ui, ch.ext_int_mask);
+ });
+ ui.label("");
+ ui.label("");
+ ui.end_row();
+ });
+
+ ui.add_space(4.0);
+
+ Grid::new(format!("{}_cr", ch.name))
+ .num_columns(4)
+ .striped(true)
+ .show(ui, |ui| {
+ ui.label("CR");
+ ui.label("");
+ ui.label("");
+ ui.label("");
+ ui.end_row();
+
+ ui.label("TSTART");
+ flag(ui, ch.transfer_start);
+ ui.label("DMA");
+ flag(ui, ch.dma_mode);
+ ui.end_row();
+
+ ui.label("RW");
+ ui.monospace(ch.transfer_type);
+ ui.label("TLEN");
+ ui.monospace(format!("{} B", ch.transfer_length + 1));
+ ui.end_row();
+ });
+
+ ui.add_space(4.0);
+
+ Grid::new(format!("{}_dma", ch.name))
+ .num_columns(2)
+ .striped(true)
+ .show(ui, |ui| {
+ ui.label("DMA");
+ ui.label("");
+ ui.end_row();
+
+ ui.label("Addr");
+ ui.monospace(format!("{:#010X}", ch.dma_addr));
+ ui.end_row();
+
+ ui.label("Length");
+ ui.monospace(format!("{} B", ch.dma_length));
+ ui.end_row();
+
+ ui.label("Data");
+ ui.monospace(format!("{:#010X}", ch.data_raw));
+ ui.end_row();
+ });
+ });
+}
+
+pub fn show_exi(ctx: &Context, open: &mut bool, exi: &Exi) {
+ egui::Window::new("EXI")
+ .open(open)
+ .default_size(egui::vec2(600.0, 400.0))
+ .show(ctx, |ui| {
+ ui.columns(3, |cols| {
+ for (i, col) in cols.iter_mut().enumerate() {
+ let ch = channel_info(exi, i);
+ show_channel(col, &ch);
+ }
+ });
+ });
+}
diff --git a/crates/debugger/src/windows/irq.rs b/crates/debugger/src/windows/irq.rs
new file mode 100644
index 0000000..d64c99e
--- /dev/null
+++ b/crates/debugger/src/windows/irq.rs
@@ -0,0 +1,121 @@
+use egui::{Align, Color32, Context, Grid, Layout, RichText};
+use egui_material_icons::icons;
+use gekko::cpu::Cpu;
+use gekko::flipper::pi::Pi;
+
+fn centered_icon(ui: &mut egui::Ui, icon: &str, color: Color32) {
+ ui.with_layout(Layout::top_down(Align::Center), |ui| {
+ ui.label(RichText::new(icon).color(color));
+ });
+}
+
+fn interrupt_row(ui: &mut egui::Ui, name: &str, pending: bool, masked: bool) {
+ let name_color = if pending && masked {
+ Color32::from_rgb(255, 180, 60)
+ } else {
+ Color32::PLACEHOLDER
+ };
+
+ let (pending_icon, pending_color) = if pending {
+ (icons::ICON_RADIO_BUTTON_CHECKED, Color32::from_rgb(255, 180, 60))
+ } else {
+ (icons::ICON_RADIO_BUTTON_UNCHECKED, Color32::from_rgb(70, 70, 70))
+ };
+
+ let (mask_icon, mask_color) = if masked {
+ (icons::ICON_CHECK_BOX, Color32::from_rgb(100, 180, 255))
+ } else {
+ (icons::ICON_CHECK_BOX_OUTLINE_BLANK, Color32::from_rgb(70, 70, 70))
+ };
+
+ ui.label(RichText::new(name).color(name_color));
+ centered_icon(ui, pending_icon, pending_color);
+ ui.label(RichText::new(mask_icon).color(mask_color));
+ ui.end_row();
+}
+
+pub fn show_irq(ctx: &Context, open: &mut bool, cpu: &Cpu, pi: &Pi) {
+ egui::Window::new("IRQ")
+ .open(open)
+ .default_size(egui::vec2(380.0, 480.0))
+ .show(ctx, |ui| {
+ let msr = &cpu.msr;
+ let spr = &cpu.spr;
+ let ee = msr.external_interrupt_enable();
+
+ // MSR.EE, SRR0/SRR1
+ Grid::new("top_state").num_columns(2).striped(true).show(ui, |ui| {
+ ui.label("MSR.EE");
+ ui.horizontal(|ui| {
+ let (icon, color) = if ee {
+ (icons::ICON_CHECK_CIRCLE, Color32::from_rgb(80, 220, 80))
+ } else {
+ (icons::ICON_CANCEL, Color32::from_rgb(200, 60, 60))
+ };
+ ui.label(RichText::new(icon).color(color));
+ ui.label(if ee {
+ "interrupts enabled"
+ } else {
+ "interrupts disabled"
+ });
+ });
+ ui.end_row();
+
+ ui.label("SRR0");
+ ui.monospace(format!("{:#010X}", spr.srr0.raw()));
+ ui.end_row();
+
+ ui.label("SRR1");
+ ui.monospace(format!("{:#010X}", spr.srr1));
+ ui.end_row();
+ });
+
+ ui.add_space(8.0);
+
+ // PI Table
+ ui.strong("PI Interrupts");
+ ui.separator();
+
+ Grid::new("pi_ints")
+ .num_columns(3)
+ .striped(true)
+ .min_col_width(0.0)
+ .show(ui, |ui| {
+ ui.label(RichText::new("Source").strong());
+ ui.label(RichText::new("Pending").strong());
+ ui.label(RichText::new("Masked").strong());
+ ui.end_row();
+
+ let sr = &pi.intsr;
+ let mr = &pi.intmr;
+
+ interrupt_row(ui, "GP Error", sr.gp_runtime_error(), mr.gp_runtime_error());
+ interrupt_row(ui, "Reset Switch", sr.reset_switch(), mr.reset_switch());
+ interrupt_row(ui, "DVD", sr.dvd(), mr.dvd());
+ interrupt_row(ui, "Serial", sr.serial(), mr.serial());
+ interrupt_row(ui, "EXI", sr.exi(), mr.exi());
+ interrupt_row(ui, "Streaming", sr.streaming(), mr.streaming());
+ interrupt_row(ui, "DSP", sr.dsp(), mr.dsp());
+ interrupt_row(ui, "Memory", sr.memory(), mr.memory());
+ interrupt_row(ui, "Video", sr.video(), mr.video());
+ interrupt_row(
+ ui,
+ "PE Token",
+ sr.token_assertion_in_cmd_list(),
+ mr.token_assertion_in_cmd_list(),
+ );
+ interrupt_row(ui, "PE Finish", sr.frame_is_ready(), mr.frame_is_ready());
+ interrupt_row(ui, "Cmd FIFO", sr.command_fifo(), mr.command_fifo());
+ interrupt_row(ui, "Debug", sr.debug(), mr.debug());
+ interrupt_row(ui, "Hi-Speed Port", sr.highspeed_port(), mr.highspeed_port());
+ });
+
+ ui.horizontal(|ui| {
+ ui.label("INTSR");
+ ui.monospace(format!("{:#010X}", pi.intsr.raw()));
+ ui.add_space(12.0);
+ ui.label("INTMR");
+ ui.monospace(format!("{:#010X}", pi.intmr.raw()));
+ });
+ });
+}