2 Skelton for retropc emulator
4 Author : Takeda.Toshiya
10 #ifndef _LIBCPU_NEWDEV_DEVICE_H_
11 #define _LIBCPU_NEWDEV_DEVICE_H_
19 //#define USE_DEVICE_NAME
21 // max devices connected to the output port
25 #define SIG_CPU_IRQ 101
26 #define SIG_CPU_FIRQ 102
27 #define SIG_CPU_NMI 103
28 #define SIG_CPU_BUSREQ 104
29 #define SIG_CPU_DEBUG 105
31 #define SIG_PRINTER_DATA 201
32 #define SIG_PRINTER_STROBE 202
33 #define SIG_PRINTER_RESET 203
34 #define SIG_PRINTER_BUSY 204
35 #define SIG_PRINTER_ACK 205
36 #define SIG_PRINTER_SELECT 206
38 #define SIG_SCSI_DAT 301
39 #define SIG_SCSI_BSY 302
40 #define SIG_SCSI_CD 303
41 #define SIG_SCSI_IO 304
42 #define SIG_SCSI_MSG 305
43 #define SIG_SCSI_REQ 306
44 #define SIG_SCSI_SEL 307
45 #define SIG_SCSI_ATN 308
46 #define SIG_SCSI_ACK 309
47 #define SIG_SCSI_RST 310
49 #include "vm_template.h"
52 class csp_state_utils;
62 csp_state_utils *state_entry;
65 DEVICE(VM_TEMPLATE* parent_vm, EMU* parent_emu);
68 virtual void initialize() { }
69 virtual void release();
71 virtual void update_config() {}
72 virtual void save_state(FILEIO* state_fio) {}
73 virtual bool load_state(FILEIO* state_fio)
78 virtual void decl_state(void);
79 virtual void enter_decl_state(int version);
80 virtual void enter_decl_state(int version, _TCHAR *name);
81 virtual void leave_decl_state(void);
84 virtual void reset() {}
85 virtual void special_reset()
90 // NOTE: the virtual bus interface functions for 16/32bit access invite the cpu is little endian.
91 // if the cpu is big endian, you need to implement them in the virtual machine memory/io classes.
94 virtual void write_data8(uint32_t addr, uint32_t data) {}
95 virtual uint32_t read_data8(uint32_t addr)
99 virtual void write_data16(uint32_t addr, uint32_t data)
101 write_data8(addr, data & 0xff);
102 write_data8(addr + 1, (data >> 8) & 0xff);
104 virtual uint32_t read_data16(uint32_t addr)
106 uint32_t val = read_data8(addr);
107 val |= read_data8(addr + 1) << 8;
110 virtual void write_data32(uint32_t addr, uint32_t data)
112 write_data16(addr, data & 0xffff);
113 write_data16(addr + 2, (data >> 16) & 0xffff);
115 virtual uint32_t read_data32(uint32_t addr)
117 uint32_t val = read_data16(addr);
118 val |= read_data16(addr + 2) << 16;
121 virtual void write_data8w(uint32_t addr, uint32_t data, int* wait)
124 write_data8(addr, data);
126 virtual uint32_t read_data8w(uint32_t addr, int* wait)
129 return read_data8(addr);
131 virtual void write_data16w(uint32_t addr, uint32_t data, int* wait)
134 write_data8w(addr, data & 0xff, &wait_l);
135 write_data8w(addr + 1, (data >> 8) & 0xff, &wait_h);
136 *wait = wait_l + wait_h;
138 virtual uint32_t read_data16w(uint32_t addr, int* wait)
141 uint32_t val = read_data8w(addr, &wait_l);
142 val |= read_data8w(addr + 1, &wait_h) << 8;
143 *wait = wait_l + wait_h;
146 virtual void write_data32w(uint32_t addr, uint32_t data, int* wait)
149 write_data16w(addr, data & 0xffff, &wait_l);
150 write_data16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
151 *wait = wait_l + wait_h;
153 virtual uint32_t read_data32w(uint32_t addr, int* wait)
156 uint32_t val = read_data16w(addr, &wait_l);
157 val |= read_data16w(addr + 2, &wait_h) << 16;
158 *wait = wait_l + wait_h;
161 virtual uint32_t fetch_op(uint32_t addr, int *wait)
163 return read_data8w(addr, wait);
165 virtual void write_dma_data8(uint32_t addr, uint32_t data)
167 write_data8(addr, data);
169 virtual uint32_t read_dma_data8(uint32_t addr)
171 return read_data8(addr);
173 virtual void write_dma_data16(uint32_t addr, uint32_t data)
175 write_data16(addr, data);
177 virtual uint32_t read_dma_data16(uint32_t addr)
179 return read_data16(addr);
181 virtual void write_dma_data32(uint32_t addr, uint32_t data)
183 write_data32(addr, data);
185 virtual uint32_t read_dma_data32(uint32_t addr)
187 return read_data32(addr);
189 virtual void write_dma_data8w(uint32_t addr, uint32_t data, int* wait)
191 write_data8w(addr, data, wait);
193 virtual uint32_t read_dma_data8w(uint32_t addr, int* wait)
195 return read_data8w(addr, wait);
197 virtual void write_dma_data16w(uint32_t addr, uint32_t data, int* wait)
199 write_data16w(addr, data, wait);
201 virtual uint32_t read_dma_data16w(uint32_t addr, int* wait)
203 return read_data16w(addr, wait);
205 virtual void write_dma_data32w(uint32_t addr, uint32_t data, int* wait)
207 write_data32w(addr, data, wait);
209 virtual uint32_t read_dma_data32w(uint32_t addr, int* wait)
211 return read_data32w(addr, wait);
215 virtual void write_io8(uint32_t addr, uint32_t data) {}
216 virtual uint32_t read_io8(uint32_t addr);
217 virtual void write_io16(uint32_t addr, uint32_t data)
219 write_io8(addr, data & 0xff);
220 write_io8(addr + 1, (data >> 8) & 0xff);
222 virtual uint32_t read_io16(uint32_t addr)
224 uint32_t val = read_io8(addr);
225 val |= read_io8(addr + 1) << 8;
228 virtual void write_io32(uint32_t addr, uint32_t data)
230 write_io16(addr, data & 0xffff);
231 write_io16(addr + 2, (data >> 16) & 0xffff);
233 virtual uint32_t read_io32(uint32_t addr)
235 uint32_t val = read_io16(addr);
236 val |= read_io16(addr + 2) << 16;
239 virtual void write_io8w(uint32_t addr, uint32_t data, int* wait)
242 write_io8(addr, data);
244 virtual uint32_t read_io8w(uint32_t addr, int* wait)
247 return read_io8(addr);
249 virtual void write_io16w(uint32_t addr, uint32_t data, int* wait)
252 write_io8w(addr, data & 0xff, &wait_l);
253 write_io8w(addr + 1, (data >> 8) & 0xff, &wait_h);
254 *wait = wait_l + wait_h;
256 virtual uint32_t read_io16w(uint32_t addr, int* wait)
259 uint32_t val = read_io8w(addr, &wait_l);
260 val |= read_io8w(addr + 1, &wait_h) << 8;
261 *wait = wait_l + wait_h;
264 virtual void write_io32w(uint32_t addr, uint32_t data, int* wait)
267 write_io16w(addr, data & 0xffff, &wait_l);
268 write_io16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
269 *wait = wait_l + wait_h;
271 virtual uint32_t read_io32w(uint32_t addr, int* wait)
274 uint32_t val = read_io16w(addr, &wait_l);
275 val |= read_io16w(addr + 2, &wait_h) << 16;
276 *wait = wait_l + wait_h;
279 virtual void write_dma_io8(uint32_t addr, uint32_t data)
281 write_io8(addr, data);
283 virtual uint32_t read_dma_io8(uint32_t addr)
285 return read_io8(addr);
287 virtual void write_dma_io16(uint32_t addr, uint32_t data)
289 write_io16(addr, data);
291 virtual uint32_t read_dma_io16(uint32_t addr)
293 return read_io16(addr);
295 virtual void write_dma_io32(uint32_t addr, uint32_t data)
297 write_io32(addr, data);
299 virtual uint32_t read_dma_io32(uint32_t addr)
301 return read_io32(addr);
303 virtual void write_dma_io8w(uint32_t addr, uint32_t data, int* wait)
305 write_io8w(addr, data, wait);
307 virtual uint32_t read_dma_io8w(uint32_t addr, int* wait)
309 return read_io8w(addr, wait);
311 virtual void write_dma_io16w(uint32_t addr, uint32_t data, int* wait)
313 write_io16w(addr, data, wait);
315 virtual uint32_t read_dma_io16w(uint32_t addr, int* wait)
317 return read_io16w(addr, wait);
319 virtual void write_dma_io32w(uint32_t addr, uint32_t data, int* wait)
321 write_io32w(addr, data, wait);
323 virtual uint32_t read_dma_io32w(uint32_t addr, int* wait)
325 return read_io32w(addr, wait);
329 virtual void write_memory_mapped_io8(uint32_t addr, uint32_t data)
331 write_io8(addr, data);
333 virtual uint32_t read_memory_mapped_io8(uint32_t addr)
335 return read_io8(addr);
337 virtual void write_memory_mapped_io16(uint32_t addr, uint32_t data)
339 write_memory_mapped_io8(addr, data & 0xff);
340 write_memory_mapped_io8(addr + 1, (data >> 8) & 0xff);
342 virtual uint32_t read_memory_mapped_io16(uint32_t addr)
344 uint32_t val = read_memory_mapped_io8(addr);
345 val |= read_memory_mapped_io8(addr + 1) << 8;
348 virtual void write_memory_mapped_io32(uint32_t addr, uint32_t data)
350 write_memory_mapped_io16(addr, data & 0xffff);
351 write_memory_mapped_io16(addr + 2, (data >> 16) & 0xffff);
353 virtual uint32_t read_memory_mapped_io32(uint32_t addr)
355 uint32_t val = read_memory_mapped_io16(addr);
356 val |= read_memory_mapped_io16(addr + 2) << 16;
359 virtual void write_memory_mapped_io8w(uint32_t addr, uint32_t data, int* wait)
362 write_memory_mapped_io8(addr, data);
364 virtual uint32_t read_memory_mapped_io8w(uint32_t addr, int* wait)
367 return read_memory_mapped_io8(addr);
369 virtual void write_memory_mapped_io16w(uint32_t addr, uint32_t data, int* wait)
372 write_memory_mapped_io8w(addr, data & 0xff, &wait_l);
373 write_memory_mapped_io8w(addr + 1, (data >> 8) & 0xff, &wait_h);
374 *wait = wait_l + wait_h;
376 virtual uint32_t read_memory_mapped_io16w(uint32_t addr, int* wait)
379 uint32_t val = read_memory_mapped_io8w(addr, &wait_l);
380 val |= read_memory_mapped_io8w(addr + 1, &wait_h) << 8;
381 *wait = wait_l + wait_h;
384 virtual void write_memory_mapped_io32w(uint32_t addr, uint32_t data, int* wait)
387 write_memory_mapped_io16w(addr, data & 0xffff, &wait_l);
388 write_memory_mapped_io16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
389 *wait = wait_l + wait_h;
391 virtual uint32_t read_memory_mapped_io32w(uint32_t addr, int* wait)
394 uint32_t val = read_memory_mapped_io16w(addr, &wait_l);
395 val |= read_memory_mapped_io16w(addr + 2, &wait_h) << 16;
396 *wait = wait_l + wait_h;
410 output_t item[MAX_OUTPUT];
413 virtual void initialize_output_signals(outputs_t *items)
417 virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask, int shift)
419 int c = items->count++;
420 items->item[c].device = device;
421 items->item[c].id = id;
422 items->item[c].mask = mask;
423 items->item[c].shift = shift;
425 virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask)
427 int c = items->count++;
428 items->item[c].device = device;
429 items->item[c].id = id;
430 items->item[c].mask = mask;
431 items->item[c].shift = 0;
433 virtual void write_signals(outputs_t *items, uint32_t data)
435 for(int i = 0; i < items->count; i++) {
436 output_t *item = &items->item[i];
437 int shift = item->shift;
438 uint32_t val = (shift < 0) ? (data >> (-shift)) : (data << shift);
439 uint32_t mask = (shift < 0) ? (item->mask >> (-shift)) : (item->mask << shift);
440 item->device->write_signal(item->id, val, mask);
443 virtual void write_signal(int id, uint32_t data, uint32_t mask) {}
444 virtual uint32_t read_signal(int ch)
450 virtual void set_context_intr(DEVICE* device, uint32_t bit) {}
451 virtual void set_context_child(DEVICE* device) {}
453 // interrupt device to device
454 virtual void set_intr_iei(bool val) {}
456 // interrupt device to cpu
457 virtual void set_intr_line(bool line, bool pending, uint32_t bit) {}
459 // interrupt cpu to device
460 virtual uint32_t get_intr_ack()
464 virtual void notify_intr_reti() {}
465 virtual void notify_intr_ei() {}
468 virtual void do_dma() {}
471 virtual int run(int clock)
473 // when clock == -1, run one opecode
474 return (clock == -1 ? 1 : clock);
476 virtual void set_extra_clock(int clock) {}
477 virtual int get_extra_clock()
481 virtual uint32_t get_pc()
485 virtual uint32_t get_next_pc()
491 virtual bool bios_call_far_i86(uint32_t PC, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
495 virtual bool bios_int_i86(int intnum, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
499 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) {
503 const _TCHAR *get_device_name(void)
505 return (const _TCHAR *)this_device_name;
509 DEVICE* event_manager;
511 virtual void set_context_event_manager(DEVICE* device)
513 event_manager = device;
515 virtual int get_event_manager_id();
516 virtual void register_event(DEVICE* device, int event_id, double usec, bool loop, int* register_id);
517 virtual void register_event_by_clock(DEVICE* device, int event_id, uint64_t clock, bool loop, int* register_id);
518 virtual void cancel_event(DEVICE* device, int register_id);
519 virtual void register_frame_event(DEVICE* device);
520 virtual void register_vline_event(DEVICE* device);
521 virtual uint32_t get_event_remaining_clock(int register_id);
522 virtual double get_event_remaining_usec(int register_id);
523 virtual uint32_t get_current_clock();
524 virtual uint32_t get_passed_clock(uint32_t prev);
525 virtual double get_passed_usec(uint32_t prev);
526 virtual uint32_t get_passed_clock_since_vline();
527 virtual double get_passed_usec_since_vline();
528 virtual int get_cur_vline();
529 virtual int get_cur_vline_clocks();
530 virtual uint32_t get_cpu_pc(int index);
531 virtual void request_skip_frames();
532 virtual void set_frames_per_sec(double frames);
533 virtual void set_lines_per_frame(int lines);
534 virtual int get_lines_per_frame(void);
535 // Force render sound immediately when device's status has changed.
536 // You must call this after you changing registers (or enything).
537 // If has problems, try set_realtime_render.
538 // See mb8877.cpp and ym2203.cpp.
540 virtual void touch_sound(void);
541 // Force render per 1 sample automatically.
544 virtual void set_realtime_render(DEVICE *device, bool flag);
545 virtual void set_realtime_render(bool flag)
547 set_realtime_render(this, flag);
549 virtual void update_timing(int new_clocks, double new_frames_per_sec, int new_lines_per_frame) {}
552 virtual void event_callback(int event_id, int err) {}
553 virtual void event_pre_frame() {} // this event is to update timing settings
554 virtual void event_frame() {}
555 virtual void event_vline(int v, int clock) {}
556 virtual void event_hsync(int v, int h, int clock) {}
559 virtual void mix(int32_t* buffer, int cnt) {}
560 virtual void set_volume(int ch, int decibel_l, int decibel_r) {} // +1 equals +0.5dB (same as fmgen)
561 virtual void set_device_name(const _TCHAR *format, ...);
562 virtual void out_debug_log(const char *fmt, ...);
563 virtual void force_out_debug_log(const char *fmt, ...);
566 // DEBUGGER is enabled by default.
567 virtual void *get_debugger();
568 virtual uint32_t get_debug_prog_addr_mask();
569 virtual uint32_t get_debug_data_addr_mask();
570 virtual void write_debug_data8(uint32_t addr, uint32_t data);
571 virtual uint32_t read_debug_data8(uint32_t addr);
572 virtual void write_debug_data16(uint32_t addr, uint32_t data);
573 virtual uint32_t read_debug_data16(uint32_t addr);
574 virtual void write_debug_data32(uint32_t addr, uint32_t data);
575 virtual uint32_t read_debug_data32(uint32_t addr);
576 virtual void write_debug_io8(uint32_t addr, uint32_t data);
577 virtual uint32_t read_debug_io8(uint32_t addr);
578 virtual void write_debug_io16(uint32_t addr, uint32_t data);
579 virtual uint32_t read_debug_io16(uint32_t addr);
580 virtual void write_debug_io32(uint32_t addr, uint32_t data);
581 virtual uint32_t read_debug_io32(uint32_t addr);
582 virtual bool write_debug_reg(const _TCHAR *reg, uint32_t data);
583 virtual void get_debug_regs_info(_TCHAR *buffer, size_t buffer_len);
584 virtual int debug_dasm(uint32_t pc, _TCHAR *buffer, size_t buffer_len);
587 const _TCHAR *get_lib_common_vm_version(void);
589 _TCHAR this_device_name[128];
591 // device node using with iterator.