#define SIG_SCSI_ACK 309
#define SIG_SCSI_RST 310
-class csp_state_utils;
+#if defined(_USE_QT)
+class CSP_Logger;
+extern CSP_Logger *csp_logger;
+
+#endif
class DEVICE
{
protected:
- VM* vm;
+ VM_TEMPLATE* vm;
EMU* emu;
OSD* osd;
- csp_state_utils *state_entry;
+#if defined(_USE_QT)
+ CSP_Logger *p_logger;
+#endif
public:
- DEVICE(VM* parent_vm, EMU* parent_emu) : vm(parent_vm), emu(parent_emu)
+ DEVICE(VM_TEMPLATE* parent_vm, EMU* parent_emu) : vm(parent_vm), emu(parent_emu)
{
#if defined(_USE_QT)
osd = emu->get_osd();
+ p_logger = csp_logger;
#else
osd = NULL;
#endif
-
- strncpy(this_device_name, "Base Device", 128);
+ memset(this_device_name, 0x00, sizeof(this_device_name));
+ strncpy(this_device_name, "Base Device", 128 - 1);
prev_device = vm->last_device;
next_device = NULL;
if(vm->first_device == NULL) {
this_device_id = vm->last_device->this_device_id + 1;
}
vm->last_device = this;
-
// primary event manager
event_manager = NULL;
}
~DEVICE(void) {}
virtual void initialize() { /* osd = emu->get_osd(); */ /* Initializing VM must be after initializing OSD. */ }
+#if defined(_USE_QT)
+ virtual void release() {
+ }
+#else
virtual void release() {}
+#endif
+ // Sound input functions
+ virtual void clear_sound_in_source(int bank) {
+ if(event_manager == NULL) {
+ event_manager = vm->first_device->next_device;
+ }
+ event_manager->clear_sound_in_source(bank);
+ }
+ // this function may be before (or after) initialize().
+ virtual int add_sound_in_source(int rate, int samples, int channels) {
+ if(event_manager == NULL) return -1;
+ return event_manager->add_sound_in_source(rate, samples, channels);
+ }
+ // this function may be before (or after) initialize().
+ virtual int release_sound_in_source(int bank) {
+ if(event_manager == NULL) return -1;
+ return event_manager->release_sound_in_source(bank);
+ }
+ virtual bool is_sound_in_source_exists(int bank) {
+ if(event_manager == NULL) {
+ event_manager = vm->first_device->next_device;
+ }
+ return event_manager->is_sound_in_source_exists(bank);
+ }
+ virtual int get_sound_in_buffers_count() {
+ if(event_manager == NULL) {
+ event_manager = vm->first_device->next_device;
+ }
+ return event_manager->get_sound_in_buffers_count();
+ }
+ virtual int get_sound_in_samples(int bank) {
+ if(event_manager == NULL) {
+ event_manager = vm->first_device->next_device;
+ }
+ return event_manager->get_sound_in_samples(bank);
+ }
+ virtual int get_sound_in_rate(int bank) {
+ if(event_manager == NULL) {
+ event_manager = vm->first_device->next_device;
+ }
+ return event_manager->get_sound_in_rate(bank);
+ }
+ virtual int get_sound_in_channels(int bank) {
+ if(event_manager == NULL) {
+ event_manager = vm->first_device->next_device;
+ }
+ return event_manager->get_sound_in_channels(bank);
+ }
+ // this function may be before (or after) initialize().
+ virtual int16_t* get_sound_in_buf_ptr(int bank) {
+ if(event_manager == NULL) return NULL;
+ return event_manager->get_sound_in_buf_ptr(bank);
+ }
+ virtual int write_sound_in_buffer(int bank, int32_t* src, int samples) {
+ if(event_manager == NULL) {
+ event_manager = vm->first_device->next_device;
+ }
+ return event_manager->write_sound_in_buffer(bank, src, samples);
+
+ }
+ // Add sampled values to sample buffer;value may be -32768 to +32767.
+ // this function may be before (or after) initialize().
+ virtual int get_sound_in_samples(int bank, int32_t* dst, int expect_samples, int expect_rate, int expect_channels) {
+ if(event_manager == NULL) return -1;
+ return event_manager->get_sound_in_samples(bank, dst, expect_samples, expect_rate, expect_channels);
+ }
+
+ virtual void set_high_pass_filter_freq(int freq, double quality) { } // If freq < 0 disable HPF.
+ virtual void set_low_pass_filter_freq(int freq, double quality) { } // If freq <= 0 disable LPF.
+
virtual void update_config() {}
virtual void save_state(FILEIO* state_fio) {}
virtual bool load_state(FILEIO* state_fio)
{
return true;
}
- virtual void decl_state(void) {}
-
// control
virtual void reset() {}
virtual void special_reset()
{
reset();
}
+ virtual bool process_state(FILEIO* state_fio, bool loading)
+ {
+ if(loading) {
+ return load_state(state_fio);
+ } else {
+ save_state(state_fio);
+ return true;
+ }
+ }
// NOTE: the virtual bus interface functions for 16/32bit access invite the cpu is little endian.
// if the cpu is big endian, you need to implement them in the virtual machine memory/io classes.
// z80 daisy chain
virtual void set_context_intr(DEVICE* device, uint32_t bit) {}
virtual void set_context_child(DEVICE* device) {}
+ virtual DEVICE *get_context_child()
+ {
+ return NULL;
+ }
// interrupt device to device
virtual void set_intr_iei(bool val) {}
{
return false;
}
- virtual bool bios_ret_z80(uint16_t PC, pair_t* af, pair_t* bc, pair_t* de, pair_t* hl, pair_t* ix, pair_t* iy, uint8_t* iff1) {
+ virtual bool bios_ret_z80(uint16_t PC, pair32_t* af, pair32_t* bc, pair32_t* de, pair32_t* hl, pair32_t* ix, pair32_t* iy, uint8_t* iff1) {
return false;
}
// misc
}
return event_manager->this_device_id;
}
+ virtual bool is_primary_cpu(DEVICE* device)
+ {
+ if(event_manager == NULL) {
+ event_manager = vm->first_device->next_device;
+ }
+ return event_manager->is_primary_cpu(device);
+ }
+ virtual void update_extra_event(int clock)
+ {
+ if(event_manager == NULL) {
+ event_manager = vm->first_device->next_device;
+ }
+ event_manager->update_extra_event(clock);
+ }
virtual void register_event(DEVICE* device, int event_id, double usec, bool loop, int* register_id)
{
if(event_manager == NULL) {
#endif
}
}
+/*
+ These functions are used for debugging non-cpu device
+ Insert debugger between standard read/write functions and these functions for checking breakpoints
+
+ void DEVICE::write_data8(uint32_t addr, uint32_t data)
+ {
+ if(debugger != NULL && debugger->now_device_debugging) {
+ // debugger->mem = this;
+ // debugger->mem->write_via_debugger_data8(addr, data)
+ debugger->write_via_debugger_data8(addr, data);
+ } else {
+ this->write_via_debugger_data8(addr, data);
+ }
+ }
+ void DEVICE::write_via_debugger_data8(uint32_t addr, uint32_t data)
+ {
+ // write memory
+ }
+*/
+ virtual void write_via_debugger_data8(uint32_t addr, uint32_t data) {}
+ virtual uint32_t read_via_debugger_data8(uint32_t addr)
+ {
+ return 0xff;
+ }
+ virtual void write_via_debugger_data16(uint32_t addr, uint32_t data) {}
+ virtual uint32_t read_via_debugger_data16(uint32_t addr)
+ {
+ return 0xffff;
+ }
+ virtual void write_via_debugger_data32(uint32_t addr, uint32_t data) {}
+ virtual uint32_t read_via_debugger_data32(uint32_t addr)
+ {
+ return 0xffffffff;
+ }
+ virtual void write_via_debugger_data8w(uint32_t addr, uint32_t data, int* wait) {}
+ virtual uint32_t read_via_debugger_data8w(uint32_t addr, int* wait)
+ {
+ return 0xff;
+ }
+ virtual void write_via_debugger_data16w(uint32_t addr, uint32_t data, int* wait) {}
+ virtual uint32_t read_via_debugger_data16w(uint32_t addr, int* wait)
+ {
+ return 0xffff;
+ }
+ virtual void write_via_debugger_data32w(uint32_t addr, uint32_t data, int* wait) {}
+ virtual uint32_t read_via_debugger_data32w(uint32_t addr, int* wait)
+ {
+ return 0xffffffff;
+ }
+ virtual void write_via_debugger_io8(uint32_t addr, uint32_t data) {}
+ virtual uint32_t read_via_debugger_io8(uint32_t addr)
+ {
+ return 0xff;
+ }
+ virtual void write_via_debugger_io16(uint32_t addr, uint32_t data) {}
+ virtual uint32_t read_via_debugger_io16(uint32_t addr)
+ {
+ return 0xffff;
+ }
+ virtual void write_via_debugger_io32(uint32_t addr, uint32_t data) {}
+ virtual uint32_t read_via_debugger_io32(uint32_t addr)
+ {
+ return 0xffffffff;
+ }
+ virtual void write_via_debugger_io8w(uint32_t addr, uint32_t data, int* wait) {}
+ virtual uint32_t read_via_debugger_io8w(uint32_t addr, int* wait)
+ {
+ return 0xff;
+ }
+ virtual void write_via_debugger_io16w(uint32_t addr, uint32_t data, int* wait) {}
+ virtual uint32_t read_via_debugger_io16w(uint32_t addr, int* wait)
+ {
+ return 0xffff;
+ }
+ virtual void write_via_debugger_io32w(uint32_t addr, uint32_t data, int* wait) {}
+ virtual uint32_t read_via_debugger_io32w(uint32_t addr, int* wait)
+ {
+ return 0xffffffff;
+ }
virtual void out_debug_log(const char *fmt, ...)
{
char strbuf[4096];
#ifdef USE_DEBUGGER
// debugger
+ virtual bool is_cpu()
+ {
+ return false;
+ }
+ virtual bool is_debugger()
+ {
+ return false;
+ }
+ virtual bool is_debugger_available()
+ {
+ return false;
+ }
virtual void *get_debugger()
{
return NULL;
{
return 0;
}
- virtual void write_debug_data8(uint32_t addr, uint32_t data) {}
+ virtual uint64_t get_debug_data_addr_space()
+ {
+ // override this function when memory space is not (2 << n)
+ return (uint64_t)get_debug_data_addr_mask() + 1;
+ }
+ virtual void write_debug_data8(uint32_t addr, uint32_t data)
+ {
+// write_data8(addr, data);
+ }
virtual uint32_t read_debug_data8(uint32_t addr)
{
+// return read_data8(addr);
return 0xff;
}
virtual void write_debug_data16(uint32_t addr, uint32_t data)
val |= read_debug_data16(addr + 2) << 16;
return val;
}
- virtual void write_debug_io8(uint32_t addr, uint32_t data) {}
+ virtual void write_debug_io8(uint32_t addr, uint32_t data)
+ {
+// write_io8(addr, data);
+ }
virtual uint32_t read_debug_io8(uint32_t addr)
{
+// return read_io8(addr);
return 0xff;
}
virtual void write_debug_io16(uint32_t addr, uint32_t data)
{
return 0;
}
- virtual void get_debug_regs_info(_TCHAR *buffer, size_t buffer_len) {}
+ virtual bool get_debug_regs_info(_TCHAR *buffer, size_t buffer_len)
+ {
+ return false;
+ }
virtual int debug_dasm(uint32_t pc, _TCHAR *buffer, size_t buffer_len)
{
return 0;
OSDN Git Service
