2 Skelton for retropc emulator
4 Author : Takeda.Toshiya
18 #include "csp_logger.h"
19 #define USE_DEVICE_NAME
22 #if defined(USE_SHARED_DLL)
23 #include "libcpu_newdev/device.h"
26 // max devices connected to the output port
30 #define SIG_CPU_IRQ 101
31 #define SIG_CPU_FIRQ 102
32 #define SIG_CPU_NMI 103
33 #define SIG_CPU_BUSREQ 104
34 #define SIG_CPU_HALTREQ 105
35 #define SIG_CPU_DEBUG 106
37 #define SIG_PRINTER_DATA 201
38 #define SIG_PRINTER_STROBE 202
39 #define SIG_PRINTER_RESET 203
40 #define SIG_PRINTER_BUSY 204
41 #define SIG_PRINTER_ACK 205
42 #define SIG_PRINTER_SELECT 206
44 #define SIG_SCSI_DAT 301
45 #define SIG_SCSI_BSY 302
46 #define SIG_SCSI_CD 303
47 #define SIG_SCSI_IO 304
48 #define SIG_SCSI_MSG 305
49 #define SIG_SCSI_REQ 306
50 #define SIG_SCSI_SEL 307
51 #define SIG_SCSI_ATN 308
52 #define SIG_SCSI_ACK 309
53 #define SIG_SCSI_RST 310
57 extern CSP_Logger *csp_logger;
71 DEVICE(VM_TEMPLATE* parent_vm, EMU* parent_emu) : vm(parent_vm), emu(parent_emu)
75 p_logger = csp_logger;
79 memset(this_device_name, 0x00, sizeof(this_device_name));
80 strncpy(this_device_name, "Base Device", 128 - 1);
81 prev_device = vm->last_device;
83 if(vm->first_device == NULL) {
84 // this is the first device
85 vm->first_device = this;
88 // this is not the first device
89 vm->last_device->next_device = this;
90 this_device_id = vm->last_device->this_device_id + 1;
92 vm->last_device = this;
94 // primary event manager
97 //ToDo: Will implement real destructor per real classes and below destructor decl. with "virtual".
98 // This makes warning:
99 //"deleting object of polymorphic class type 'DEVICE' which has non-virtual
100 // destructor might cause undefined behavior [-Wdelete-non-virtual-dtor]".
103 virtual void initialize() { /* osd = emu->get_osd(); */ /* Initializing VM must be after initializing OSD. */ }
105 virtual void release() {
108 virtual void release() {}
111 virtual void update_config() {}
112 virtual void save_state(FILEIO* state_fio) {}
113 virtual bool load_state(FILEIO* state_fio)
118 virtual void reset() {}
119 virtual void special_reset()
123 virtual bool process_state(FILEIO* state_fio, bool loading)
126 return load_state(state_fio);
128 save_state(state_fio);
133 // NOTE: the virtual bus interface functions for 16/32bit access invite the cpu is little endian.
134 // if the cpu is big endian, you need to implement them in the virtual machine memory/io classes.
137 virtual void write_data8(uint32_t addr, uint32_t data) {}
138 virtual uint32_t read_data8(uint32_t addr)
142 virtual void write_data16(uint32_t addr, uint32_t data)
144 write_data8(addr, data & 0xff);
145 write_data8(addr + 1, (data >> 8) & 0xff);
147 virtual uint32_t read_data16(uint32_t addr)
149 uint32_t val = read_data8(addr);
150 val |= read_data8(addr + 1) << 8;
153 virtual void write_data32(uint32_t addr, uint32_t data)
155 write_data16(addr, data & 0xffff);
156 write_data16(addr + 2, (data >> 16) & 0xffff);
158 virtual uint32_t read_data32(uint32_t addr)
160 uint32_t val = read_data16(addr);
161 val |= read_data16(addr + 2) << 16;
164 virtual void write_data8w(uint32_t addr, uint32_t data, int* wait)
167 write_data8(addr, data);
169 virtual uint32_t read_data8w(uint32_t addr, int* wait)
172 return read_data8(addr);
174 virtual void write_data16w(uint32_t addr, uint32_t data, int* wait)
177 write_data8w(addr, data & 0xff, &wait_l);
178 write_data8w(addr + 1, (data >> 8) & 0xff, &wait_h);
179 *wait = wait_l + wait_h;
181 virtual uint32_t read_data16w(uint32_t addr, int* wait)
184 uint32_t val = read_data8w(addr, &wait_l);
185 val |= read_data8w(addr + 1, &wait_h) << 8;
186 *wait = wait_l + wait_h;
189 virtual void write_data32w(uint32_t addr, uint32_t data, int* wait)
192 write_data16w(addr, data & 0xffff, &wait_l);
193 write_data16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
194 *wait = wait_l + wait_h;
196 virtual uint32_t read_data32w(uint32_t addr, int* wait)
199 uint32_t val = read_data16w(addr, &wait_l);
200 val |= read_data16w(addr + 2, &wait_h) << 16;
201 *wait = wait_l + wait_h;
204 virtual uint32_t fetch_op(uint32_t addr, int *wait)
206 return read_data8w(addr, wait);
208 virtual void write_dma_data8(uint32_t addr, uint32_t data)
210 write_data8(addr, data);
212 virtual uint32_t read_dma_data8(uint32_t addr)
214 return read_data8(addr);
216 virtual void write_dma_data16(uint32_t addr, uint32_t data)
218 write_data16(addr, data);
220 virtual uint32_t read_dma_data16(uint32_t addr)
222 return read_data16(addr);
224 virtual void write_dma_data32(uint32_t addr, uint32_t data)
226 write_data32(addr, data);
228 virtual uint32_t read_dma_data32(uint32_t addr)
230 return read_data32(addr);
232 virtual void write_dma_data8w(uint32_t addr, uint32_t data, int* wait)
234 write_data8w(addr, data, wait);
236 virtual uint32_t read_dma_data8w(uint32_t addr, int* wait)
238 return read_data8w(addr, wait);
240 virtual void write_dma_data16w(uint32_t addr, uint32_t data, int* wait)
242 write_data16w(addr, data, wait);
244 virtual uint32_t read_dma_data16w(uint32_t addr, int* wait)
246 return read_data16w(addr, wait);
248 virtual void write_dma_data32w(uint32_t addr, uint32_t data, int* wait)
250 write_data32w(addr, data, wait);
252 virtual uint32_t read_dma_data32w(uint32_t addr, int* wait)
254 return read_data32w(addr, wait);
258 virtual void write_io8(uint32_t addr, uint32_t data) {}
259 virtual uint32_t read_io8(uint32_t addr)
261 #ifdef IOBUS_RETURN_ADDR
262 return (addr & 1 ? addr >> 8 : addr) & 0xff;
267 virtual void write_io16(uint32_t addr, uint32_t data)
269 write_io8(addr, data & 0xff);
270 write_io8(addr + 1, (data >> 8) & 0xff);
272 virtual uint32_t read_io16(uint32_t addr)
274 uint32_t val = read_io8(addr);
275 val |= read_io8(addr + 1) << 8;
278 virtual void write_io32(uint32_t addr, uint32_t data)
280 write_io16(addr, data & 0xffff);
281 write_io16(addr + 2, (data >> 16) & 0xffff);
283 virtual uint32_t read_io32(uint32_t addr)
285 uint32_t val = read_io16(addr);
286 val |= read_io16(addr + 2) << 16;
289 virtual void write_io8w(uint32_t addr, uint32_t data, int* wait)
292 write_io8(addr, data);
294 virtual uint32_t read_io8w(uint32_t addr, int* wait)
297 return read_io8(addr);
299 virtual void write_io16w(uint32_t addr, uint32_t data, int* wait)
302 write_io8w(addr, data & 0xff, &wait_l);
303 write_io8w(addr + 1, (data >> 8) & 0xff, &wait_h);
304 *wait = wait_l + wait_h;
306 virtual uint32_t read_io16w(uint32_t addr, int* wait)
309 uint32_t val = read_io8w(addr, &wait_l);
310 val |= read_io8w(addr + 1, &wait_h) << 8;
311 *wait = wait_l + wait_h;
314 virtual void write_io32w(uint32_t addr, uint32_t data, int* wait)
317 write_io16w(addr, data & 0xffff, &wait_l);
318 write_io16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
319 *wait = wait_l + wait_h;
321 virtual uint32_t read_io32w(uint32_t addr, int* wait)
324 uint32_t val = read_io16w(addr, &wait_l);
325 val |= read_io16w(addr + 2, &wait_h) << 16;
326 *wait = wait_l + wait_h;
329 virtual void write_dma_io8(uint32_t addr, uint32_t data)
331 write_io8(addr, data);
333 virtual uint32_t read_dma_io8(uint32_t addr)
335 return read_io8(addr);
337 virtual void write_dma_io16(uint32_t addr, uint32_t data)
339 write_io16(addr, data);
341 virtual uint32_t read_dma_io16(uint32_t addr)
343 return read_io16(addr);
345 virtual void write_dma_io32(uint32_t addr, uint32_t data)
347 write_io32(addr, data);
349 virtual uint32_t read_dma_io32(uint32_t addr)
351 return read_io32(addr);
353 virtual void write_dma_io8w(uint32_t addr, uint32_t data, int* wait)
355 write_io8w(addr, data, wait);
357 virtual uint32_t read_dma_io8w(uint32_t addr, int* wait)
359 return read_io8w(addr, wait);
361 virtual void write_dma_io16w(uint32_t addr, uint32_t data, int* wait)
363 write_io16w(addr, data, wait);
365 virtual uint32_t read_dma_io16w(uint32_t addr, int* wait)
367 return read_io16w(addr, wait);
369 virtual void write_dma_io32w(uint32_t addr, uint32_t data, int* wait)
371 write_io32w(addr, data, wait);
373 virtual uint32_t read_dma_io32w(uint32_t addr, int* wait)
375 return read_io32w(addr, wait);
379 virtual void write_memory_mapped_io8(uint32_t addr, uint32_t data)
381 write_io8(addr, data);
383 virtual uint32_t read_memory_mapped_io8(uint32_t addr)
385 return read_io8(addr);
387 virtual void write_memory_mapped_io16(uint32_t addr, uint32_t data)
389 write_memory_mapped_io8(addr, data & 0xff);
390 write_memory_mapped_io8(addr + 1, (data >> 8) & 0xff);
392 virtual uint32_t read_memory_mapped_io16(uint32_t addr)
394 uint32_t val = read_memory_mapped_io8(addr);
395 val |= read_memory_mapped_io8(addr + 1) << 8;
398 virtual void write_memory_mapped_io32(uint32_t addr, uint32_t data)
400 write_memory_mapped_io16(addr, data & 0xffff);
401 write_memory_mapped_io16(addr + 2, (data >> 16) & 0xffff);
403 virtual uint32_t read_memory_mapped_io32(uint32_t addr)
405 uint32_t val = read_memory_mapped_io16(addr);
406 val |= read_memory_mapped_io16(addr + 2) << 16;
409 virtual void write_memory_mapped_io8w(uint32_t addr, uint32_t data, int* wait)
412 write_memory_mapped_io8(addr, data);
414 virtual uint32_t read_memory_mapped_io8w(uint32_t addr, int* wait)
417 return read_memory_mapped_io8(addr);
419 virtual void write_memory_mapped_io16w(uint32_t addr, uint32_t data, int* wait)
422 write_memory_mapped_io8w(addr, data & 0xff, &wait_l);
423 write_memory_mapped_io8w(addr + 1, (data >> 8) & 0xff, &wait_h);
424 *wait = wait_l + wait_h;
426 virtual uint32_t read_memory_mapped_io16w(uint32_t addr, int* wait)
429 uint32_t val = read_memory_mapped_io8w(addr, &wait_l);
430 val |= read_memory_mapped_io8w(addr + 1, &wait_h) << 8;
431 *wait = wait_l + wait_h;
434 virtual void write_memory_mapped_io32w(uint32_t addr, uint32_t data, int* wait)
437 write_memory_mapped_io16w(addr, data & 0xffff, &wait_l);
438 write_memory_mapped_io16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
439 *wait = wait_l + wait_h;
441 virtual uint32_t read_memory_mapped_io32w(uint32_t addr, int* wait)
444 uint32_t val = read_memory_mapped_io16w(addr, &wait_l);
445 val |= read_memory_mapped_io16w(addr + 2, &wait_h) << 16;
446 *wait = wait_l + wait_h;
460 output_t item[MAX_OUTPUT];
463 virtual void initialize_output_signals(outputs_t *items)
467 virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask, int shift)
469 int c = items->count++;
470 items->item[c].device = device;
471 items->item[c].id = id;
472 items->item[c].mask = mask;
473 items->item[c].shift = shift;
475 virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask)
477 int c = items->count++;
478 items->item[c].device = device;
479 items->item[c].id = id;
480 items->item[c].mask = mask;
481 items->item[c].shift = 0;
483 virtual void write_signals(outputs_t *items, uint32_t data)
485 for(int i = 0; i < items->count; i++) {
486 output_t *item = &items->item[i];
487 int shift = item->shift;
488 uint32_t val = (shift < 0) ? (data >> (-shift)) : (data << shift);
489 uint32_t mask = (shift < 0) ? (item->mask >> (-shift)) : (item->mask << shift);
490 item->device->write_signal(item->id, val, mask);
493 virtual void write_signal(int id, uint32_t data, uint32_t mask) {}
494 virtual uint32_t read_signal(int ch)
500 virtual void set_context_intr(DEVICE* device, uint32_t bit) {}
501 virtual void set_context_child(DEVICE* device) {}
503 // interrupt device to device
504 virtual void set_intr_iei(bool val) {}
506 // interrupt device to cpu
507 virtual void set_intr_line(bool line, bool pending, uint32_t bit) {}
509 // interrupt cpu to device
510 virtual uint32_t get_intr_ack()
514 virtual void notify_intr_reti() {}
515 virtual void notify_intr_ei() {}
518 virtual void do_dma() {}
521 virtual int run(int clock)
523 // when clock == -1, run one opecode
524 return (clock == -1 ? 1 : clock);
526 virtual void set_extra_clock(int clock) {}
527 virtual int get_extra_clock()
531 virtual uint32_t get_pc()
535 virtual uint32_t get_next_pc()
541 virtual bool bios_call_far_i86(uint32_t PC, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
545 virtual bool bios_int_i86(int intnum, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
549 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) {
553 const _TCHAR *get_device_name(void)
555 return (const _TCHAR *)this_device_name;
559 DEVICE* event_manager;
561 virtual void set_context_event_manager(DEVICE* device)
563 event_manager = device;
565 virtual int get_event_manager_id()
567 if(event_manager == NULL) {
568 event_manager = vm->first_device->next_device;
570 return event_manager->this_device_id;
572 virtual void register_event(DEVICE* device, int event_id, double usec, bool loop, int* register_id)
574 if(event_manager == NULL) {
575 event_manager = vm->first_device->next_device;
577 event_manager->register_event(device, event_id, usec, loop, register_id);
579 virtual void register_event_by_clock(DEVICE* device, int event_id, uint64_t clock, bool loop, int* register_id)
581 if(event_manager == NULL) {
582 event_manager = vm->first_device->next_device;
584 event_manager->register_event_by_clock(device, event_id, clock, loop, register_id);
586 virtual void cancel_event(DEVICE* device, int register_id)
588 if(event_manager == NULL) {
589 event_manager = vm->first_device->next_device;
591 event_manager->cancel_event(device, register_id);
593 virtual void register_frame_event(DEVICE* device)
595 if(event_manager == NULL) {
596 event_manager = vm->first_device->next_device;
598 event_manager->register_frame_event(device);
600 virtual void register_vline_event(DEVICE* device)
602 if(event_manager == NULL) {
603 event_manager = vm->first_device->next_device;
605 event_manager->register_vline_event(device);
607 virtual uint32_t get_event_remaining_clock(int register_id)
609 if(event_manager == NULL) {
610 event_manager = vm->first_device->next_device;
612 return event_manager->get_event_remaining_clock(register_id);
614 virtual double get_event_remaining_usec(int register_id)
616 if(event_manager == NULL) {
617 event_manager = vm->first_device->next_device;
619 return event_manager->get_event_remaining_usec(register_id);
621 virtual uint32_t get_current_clock()
623 if(event_manager == NULL) {
624 event_manager = vm->first_device->next_device;
626 return event_manager->get_current_clock();
628 virtual uint32_t get_passed_clock(uint32_t prev)
630 if(event_manager == NULL) {
631 event_manager = vm->first_device->next_device;
633 return event_manager->get_passed_clock(prev);
635 virtual double get_passed_usec(uint32_t prev)
637 if(event_manager == NULL) {
638 event_manager = vm->first_device->next_device;
640 return event_manager->get_passed_usec(prev);
642 virtual uint32_t get_passed_clock_since_vline()
644 if(event_manager == NULL) {
645 event_manager = vm->first_device->next_device;
647 return event_manager->get_passed_clock_since_vline();
649 virtual double get_passed_usec_since_vline()
651 if(event_manager == NULL) {
652 event_manager = vm->first_device->next_device;
654 return event_manager->get_passed_usec_since_vline();
656 virtual int get_cur_vline()
658 if(event_manager == NULL) {
659 event_manager = vm->first_device->next_device;
661 return event_manager->get_cur_vline();
663 virtual int get_cur_vline_clocks()
665 if(event_manager == NULL) {
666 event_manager = vm->first_device->next_device;
668 return event_manager->get_cur_vline_clocks();
670 virtual uint32_t get_cpu_pc(int index)
672 if(event_manager == NULL) {
673 event_manager = vm->first_device->next_device;
675 return event_manager->get_cpu_pc(index);
677 virtual void request_skip_frames()
679 if(event_manager == NULL) {
680 event_manager = vm->first_device->next_device;
682 event_manager->request_skip_frames();
684 virtual void set_frames_per_sec(double frames)
686 if(event_manager == NULL) {
687 event_manager = vm->first_device->next_device;
689 event_manager->set_frames_per_sec(frames);
691 virtual void set_lines_per_frame(int lines)
693 if(event_manager == NULL) {
694 event_manager = vm->first_device->next_device;
696 event_manager->set_lines_per_frame(lines);
698 virtual int get_lines_per_frame()
700 if(event_manager == NULL) {
701 event_manager = vm->first_device->next_device;
703 return event_manager->get_lines_per_frame();
705 // Force reder sound immediately when device's status has changed.
706 // You must call this after you changing registers (or enything).
707 // If has problems, try set_realtime_render.
708 // See mb8877.cpp and ym2203.cpp.
710 virtual void touch_sound(void)
712 if(event_manager == NULL) {
713 event_manager = vm->first_device->next_device;
715 event_manager->touch_sound();
717 // Force render per 1 sample automatically.
720 virtual void set_realtime_render(DEVICE* device, bool flag = true)
722 if(event_manager == NULL) {
723 event_manager = vm->first_device->next_device;
725 if(device != event_manager) event_manager->set_realtime_render(device, flag);
727 virtual void set_realtime_render(bool flag)
729 set_realtime_render(this, flag);
731 virtual void update_timing(int new_clocks, double new_frames_per_sec, int new_lines_per_frame) {}
734 virtual void event_callback(int event_id, int err) {}
735 virtual void event_pre_frame() {} // this event is to update timing settings
736 virtual void event_frame() {}
737 virtual void event_vline(int v, int clock) {}
738 virtual void event_hsync(int v, int h, int clock) {}
741 virtual void mix(int32_t* buffer, int cnt) {}
742 virtual void set_volume(int ch, int decibel_l, int decibel_r) {} // +1 equals +0.5dB (same as fmgen)
743 virtual void set_device_name(const _TCHAR *format, ...)
749 va_start(ap, format);
750 my_vstprintf_s(buffer, 1024, format, ap);
753 my_tcscpy_s(this_device_name, 128, buffer);
755 emu->get_osd()->set_vm_node(this_device_id, buffer);
759 virtual void out_debug_log(const char *fmt, ...)
765 vsnprintf(strbuf, 4095, fmt, ap);
766 emu->out_debug_log("%s", strbuf);
769 virtual void force_out_debug_log(const char *fmt, ...)
775 vsnprintf(strbuf, 4095, fmt, ap);
776 emu->force_out_debug_log("%s", strbuf);
782 virtual void *get_debugger()
786 virtual uint32_t get_debug_prog_addr_mask()
790 virtual uint32_t get_debug_data_addr_mask()
794 virtual void write_debug_data8(uint32_t addr, uint32_t data) {}
795 virtual uint32_t read_debug_data8(uint32_t addr)
799 virtual void write_debug_data16(uint32_t addr, uint32_t data)
801 write_debug_data8(addr, data & 0xff);
802 write_debug_data8(addr + 1, (data >> 8) & 0xff);
804 virtual uint32_t read_debug_data16(uint32_t addr)
806 uint32_t val = read_debug_data8(addr);
807 val |= read_debug_data8(addr + 1) << 8;
810 virtual void write_debug_data32(uint32_t addr, uint32_t data)
812 write_debug_data16(addr, data & 0xffff);
813 write_debug_data16(addr + 2, (data >> 16) & 0xffff);
815 virtual uint32_t read_debug_data32(uint32_t addr)
817 uint32_t val = read_debug_data16(addr);
818 val |= read_debug_data16(addr + 2) << 16;
821 virtual void write_debug_io8(uint32_t addr, uint32_t data) {}
822 virtual uint32_t read_debug_io8(uint32_t addr)
826 virtual void write_debug_io16(uint32_t addr, uint32_t data)
828 write_debug_io8(addr, data & 0xff);
829 write_debug_io8(addr + 1, (data >> 8) & 0xff);
831 virtual uint32_t read_debug_io16(uint32_t addr)
833 uint32_t val = read_debug_io8(addr);
834 val |= read_debug_io8(addr + 1) << 8;
837 virtual void write_debug_io32(uint32_t addr, uint32_t data)
839 write_debug_io16(addr, data & 0xffff);
840 write_debug_io16(addr + 2, (data >> 16) & 0xffff);
842 virtual uint32_t read_debug_io32(uint32_t addr)
844 uint32_t val = read_debug_io16(addr);
845 val |= read_debug_io16(addr + 2) << 16;
848 virtual bool write_debug_reg(const _TCHAR *reg, uint32_t data)
852 virtual uint32_t read_debug_reg(const _TCHAR *reg)
856 virtual void get_debug_regs_info(_TCHAR *buffer, size_t buffer_len) {}
857 virtual int debug_dasm(uint32_t pc, _TCHAR *buffer, size_t buffer_len)
862 _TCHAR this_device_name[128];
868 #endif // USE_SHARED_DLL