source/src/vm/libcpu_newdev/device.h

   1 /*
   2         Skelton for retropc emulator
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2006.08.18 -
   6
   7         [ device base class ]
   8 */
   9
  10 #ifndef _LIBCPU_NEWDEV_DEVICE_H_
  11 #define _LIBCPU_NEWDEV_DEVICE_H_
  12
  13 #include <stdarg.h>
  14 #include "vm.h"
  15 #include "../emu.h"
  16 #if defined(_USE_QT)
  17 #include "osd.h"
  18
  19 //#define USE_DEVICE_NAME
  20 #endif
  21 // max devices connected to the output port
  22 #define MAX_OUTPUT      16
  23
  24 // common signal id
  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
  30
  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
  37
  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
  48
  49 #include "vm_template.h"
  50
  51 class CSP_Logger;
  52 class csp_state_utils;
  53 class VM_TEMPLATE;
  54 class EMU;
  55 class OSD;
  56 class DEVICE
  57 {
  58 protected:
  59         VM_TEMPLATE* vm;
  60         EMU* emu;
  61         OSD* osd;
  62         csp_state_utils *state_entry;
  63         CSP_Logger *p_logger;
  64 public:
  65         DEVICE(VM_TEMPLATE* parent_vm, EMU* parent_emu);
  66         ~DEVICE() {}
  67
  68         virtual void initialize() { }
  69         virtual void release();
  70
  71         virtual void update_config() {}
  72         virtual void save_state(FILEIO* state_fio) {}
  73         virtual bool load_state(FILEIO* state_fio)
  74         {
  75                 return true;
  76         }
  77
  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);
  82
  83         // control
  84         virtual void reset() {}
  85         virtual void special_reset()
  86         {
  87                 reset();
  88         }
  89
  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.
  92
  93         // memory bus
  94         virtual void write_data8(uint32_t addr, uint32_t data) {}
  95         virtual uint32_t read_data8(uint32_t addr)
  96         {
  97                 return 0xff;
  98         }
  99         virtual void write_data16(uint32_t addr, uint32_t data)
 100         {
 101                 write_data8(addr, data & 0xff);
 102                 write_data8(addr + 1, (data >> 8) & 0xff);
 103         }
 104         virtual uint32_t read_data16(uint32_t addr)
 105         {
 106                 uint32_t val = read_data8(addr);
 107                 val |= read_data8(addr + 1) << 8;
 108                 return val;
 109         }
 110         virtual void write_data32(uint32_t addr, uint32_t data)
 111         {
 112                 write_data16(addr, data & 0xffff);
 113                 write_data16(addr + 2, (data >> 16) & 0xffff);
 114         }
 115         virtual uint32_t read_data32(uint32_t addr)
 116         {
 117                 uint32_t val = read_data16(addr);
 118                 val |= read_data16(addr + 2) << 16;
 119                 return val;
 120         }
 121         virtual void write_data8w(uint32_t addr, uint32_t data, int* wait)
 122         {
 123                 *wait = 0;
 124                 write_data8(addr, data);
 125         }
 126         virtual uint32_t read_data8w(uint32_t addr, int* wait)
 127         {
 128                 *wait = 0;
 129                 return read_data8(addr);
 130         }
 131         virtual void write_data16w(uint32_t addr, uint32_t data, int* wait)
 132         {
 133                 int wait_l, wait_h;
 134                 write_data8w(addr, data & 0xff, &wait_l);
 135                 write_data8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 136                 *wait = wait_l + wait_h;
 137         }
 138         virtual uint32_t read_data16w(uint32_t addr, int* wait)
 139         {
 140                 int wait_l, wait_h;
 141                 uint32_t val = read_data8w(addr, &wait_l);
 142                 val |= read_data8w(addr + 1, &wait_h) << 8;
 143                 *wait = wait_l + wait_h;
 144                 return val;
 145         }
 146         virtual void write_data32w(uint32_t addr, uint32_t data, int* wait)
 147         {
 148                 int wait_l, wait_h;
 149                 write_data16w(addr, data & 0xffff, &wait_l);
 150                 write_data16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 151                 *wait = wait_l + wait_h;
 152         }
 153         virtual uint32_t read_data32w(uint32_t addr, int* wait)
 154         {
 155                 int wait_l, wait_h;
 156                 uint32_t val = read_data16w(addr, &wait_l);
 157                 val |= read_data16w(addr + 2, &wait_h) << 16;
 158                 *wait = wait_l + wait_h;
 159                 return val;
 160         }
 161         virtual uint32_t fetch_op(uint32_t addr, int *wait)
 162         {
 163                 return read_data8w(addr, wait);
 164         }
 165         virtual void write_dma_data8(uint32_t addr, uint32_t data)
 166         {
 167                 write_data8(addr, data);
 168         }
 169         virtual uint32_t read_dma_data8(uint32_t addr)
 170         {
 171                 return read_data8(addr);
 172         }
 173         virtual void write_dma_data16(uint32_t addr, uint32_t data)
 174         {
 175                 write_data16(addr, data);
 176         }
 177         virtual uint32_t read_dma_data16(uint32_t addr)
 178         {
 179                 return read_data16(addr);
 180         }
 181         virtual void write_dma_data32(uint32_t addr, uint32_t data)
 182         {
 183                 write_data32(addr, data);
 184         }
 185         virtual uint32_t read_dma_data32(uint32_t addr)
 186         {
 187                 return read_data32(addr);
 188         }
 189         virtual void write_dma_data8w(uint32_t addr, uint32_t data, int* wait)
 190         {
 191                 write_data8w(addr, data, wait);
 192         }
 193         virtual uint32_t read_dma_data8w(uint32_t addr, int* wait)
 194         {
 195                 return read_data8w(addr, wait);
 196         }
 197         virtual void write_dma_data16w(uint32_t addr, uint32_t data, int* wait)
 198         {
 199                 write_data16w(addr, data, wait);
 200         }
 201         virtual uint32_t read_dma_data16w(uint32_t addr, int* wait)
 202         {
 203                 return read_data16w(addr, wait);
 204         }
 205         virtual void write_dma_data32w(uint32_t addr, uint32_t data, int* wait)
 206         {
 207                 write_data32w(addr, data, wait);
 208         }
 209         virtual uint32_t read_dma_data32w(uint32_t addr, int* wait)
 210         {
 211                 return read_data32w(addr, wait);
 212         }
 213
 214         // i/o bus
 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)
 218         {
 219                 write_io8(addr, data & 0xff);
 220                 write_io8(addr + 1, (data >> 8) & 0xff);
 221         }
 222         virtual uint32_t read_io16(uint32_t addr)
 223         {
 224                 uint32_t val = read_io8(addr);
 225                 val |= read_io8(addr + 1) << 8;
 226                 return val;
 227         }
 228         virtual void write_io32(uint32_t addr, uint32_t data)
 229         {
 230                 write_io16(addr, data & 0xffff);
 231                 write_io16(addr + 2, (data >> 16) & 0xffff);
 232         }
 233         virtual uint32_t read_io32(uint32_t addr)
 234         {
 235                 uint32_t val = read_io16(addr);
 236                 val |= read_io16(addr + 2) << 16;
 237                 return val;
 238         }
 239         virtual void write_io8w(uint32_t addr, uint32_t data, int* wait)
 240         {
 241                 *wait = 0;
 242                 write_io8(addr, data);
 243         }
 244         virtual uint32_t read_io8w(uint32_t addr, int* wait)
 245         {
 246                 *wait = 0;
 247                 return read_io8(addr);
 248         }
 249         virtual void write_io16w(uint32_t addr, uint32_t data, int* wait)
 250         {
 251                 int wait_l, wait_h;
 252                 write_io8w(addr, data & 0xff, &wait_l);
 253                 write_io8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 254                 *wait = wait_l + wait_h;
 255         }
 256         virtual uint32_t read_io16w(uint32_t addr, int* wait)
 257         {
 258                 int wait_l, wait_h;
 259                 uint32_t val = read_io8w(addr, &wait_l);
 260                 val |= read_io8w(addr + 1, &wait_h) << 8;
 261                 *wait = wait_l + wait_h;
 262                 return val;
 263         }
 264         virtual void write_io32w(uint32_t addr, uint32_t data, int* wait)
 265         {
 266                 int wait_l, wait_h;
 267                 write_io16w(addr, data & 0xffff, &wait_l);
 268                 write_io16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 269                 *wait = wait_l + wait_h;
 270         }
 271         virtual uint32_t read_io32w(uint32_t addr, int* wait)
 272         {
 273                 int wait_l, wait_h;
 274                 uint32_t val = read_io16w(addr, &wait_l);
 275                 val |= read_io16w(addr + 2, &wait_h) << 16;
 276                 *wait = wait_l + wait_h;
 277                 return val;
 278         }
 279         virtual void write_dma_io8(uint32_t addr, uint32_t data)
 280         {
 281                 write_io8(addr, data);
 282         }
 283         virtual uint32_t read_dma_io8(uint32_t addr)
 284         {
 285                 return read_io8(addr);
 286         }
 287         virtual void write_dma_io16(uint32_t addr, uint32_t data)
 288         {
 289                 write_io16(addr, data);
 290         }
 291         virtual uint32_t read_dma_io16(uint32_t addr)
 292         {
 293                 return read_io16(addr);
 294         }
 295         virtual void write_dma_io32(uint32_t addr, uint32_t data)
 296         {
 297                 write_io32(addr, data);
 298         }
 299         virtual uint32_t read_dma_io32(uint32_t addr)
 300         {
 301                 return read_io32(addr);
 302         }
 303         virtual void write_dma_io8w(uint32_t addr, uint32_t data, int* wait)
 304         {
 305                 write_io8w(addr, data, wait);
 306         }
 307         virtual uint32_t read_dma_io8w(uint32_t addr, int* wait)
 308         {
 309                 return read_io8w(addr, wait);
 310         }
 311         virtual void write_dma_io16w(uint32_t addr, uint32_t data, int* wait)
 312         {
 313                 write_io16w(addr, data, wait);
 314         }
 315         virtual uint32_t read_dma_io16w(uint32_t addr, int* wait)
 316         {
 317                 return read_io16w(addr, wait);
 318         }
 319         virtual void write_dma_io32w(uint32_t addr, uint32_t data, int* wait)
 320         {
 321                 write_io32w(addr, data, wait);
 322         }
 323         virtual uint32_t read_dma_io32w(uint32_t addr, int* wait)
 324         {
 325                 return read_io32w(addr, wait);
 326         }
 327
 328         // memory mapped i/o
 329         virtual void write_memory_mapped_io8(uint32_t addr, uint32_t data)
 330         {
 331                 write_io8(addr, data);
 332         }
 333         virtual uint32_t read_memory_mapped_io8(uint32_t addr)
 334         {
 335                 return read_io8(addr);
 336         }
 337         virtual void write_memory_mapped_io16(uint32_t addr, uint32_t data)
 338         {
 339                 write_memory_mapped_io8(addr, data & 0xff);
 340                 write_memory_mapped_io8(addr + 1, (data >> 8) & 0xff);
 341         }
 342         virtual uint32_t read_memory_mapped_io16(uint32_t addr)
 343         {
 344                 uint32_t val = read_memory_mapped_io8(addr);
 345                 val |= read_memory_mapped_io8(addr + 1) << 8;
 346                 return val;
 347         }
 348         virtual void write_memory_mapped_io32(uint32_t addr, uint32_t data)
 349         {
 350                 write_memory_mapped_io16(addr, data & 0xffff);
 351                 write_memory_mapped_io16(addr + 2, (data >> 16) & 0xffff);
 352         }
 353         virtual uint32_t read_memory_mapped_io32(uint32_t addr)
 354         {
 355                 uint32_t val = read_memory_mapped_io16(addr);
 356                 val |= read_memory_mapped_io16(addr + 2) << 16;
 357                 return val;
 358         }
 359         virtual void write_memory_mapped_io8w(uint32_t addr, uint32_t data, int* wait)
 360         {
 361                 *wait = 0;
 362                 write_memory_mapped_io8(addr, data);
 363         }
 364         virtual uint32_t read_memory_mapped_io8w(uint32_t addr, int* wait)
 365         {
 366                 *wait = 0;
 367                 return read_memory_mapped_io8(addr);
 368         }
 369         virtual void write_memory_mapped_io16w(uint32_t addr, uint32_t data, int* wait)
 370         {
 371                 int wait_l, wait_h;
 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;
 375         }
 376         virtual uint32_t read_memory_mapped_io16w(uint32_t addr, int* wait)
 377         {
 378                 int wait_l, wait_h;
 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;
 382                 return val;
 383         }
 384         virtual void write_memory_mapped_io32w(uint32_t addr, uint32_t data, int* wait)
 385         {
 386                 int wait_l, wait_h;
 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;
 390         }
 391         virtual uint32_t read_memory_mapped_io32w(uint32_t addr, int* wait)
 392         {
 393                 int wait_l, wait_h;
 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;
 397                 return val;
 398         }
 399
 400         // device to device
 401         typedef struct {
 402                 DEVICE *device;
 403                 int id;
 404                 uint32_t mask;
 405                 int shift;
 406         } output_t;
 407
 408         typedef struct {
 409                 int count;
 410                 output_t item[MAX_OUTPUT];
 411         } outputs_t;
 412
 413         virtual void initialize_output_signals(outputs_t *items)
 414         {
 415                 items->count = 0;
 416         }
 417         virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask, int shift)
 418         {
 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;
 424         }
 425         virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask)
 426         {
 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;
 432         }
 433         virtual void write_signals(outputs_t *items, uint32_t data)
 434         {
 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);
 441                 }
 442         };
 443         virtual void write_signal(int id, uint32_t data, uint32_t mask) {}
 444         virtual uint32_t read_signal(int ch)
 445         {
 446                 return 0;
 447         }
 448
 449         // z80 daisy chain
 450         virtual void set_context_intr(DEVICE* device, uint32_t bit) {}
 451         virtual void set_context_child(DEVICE* device) {}
 452
 453         // interrupt device to device
 454         virtual void set_intr_iei(bool val) {}
 455
 456         // interrupt device to cpu
 457         virtual void set_intr_line(bool line, bool pending, uint32_t bit) {}
 458
 459         // interrupt cpu to device
 460         virtual uint32_t get_intr_ack()
 461         {
 462                 return 0xff;
 463         }
 464         virtual void notify_intr_reti() {}
 465         virtual void notify_intr_ei() {}
 466
 467         // dma
 468         virtual void do_dma() {}
 469
 470         // cpu
 471         virtual int run(int clock)
 472         {
 473                 // when clock == -1, run one opecode
 474                 return (clock == -1 ? 1 : clock);
 475         }
 476         virtual void set_extra_clock(int clock) {}
 477         virtual int get_extra_clock()
 478         {
 479                 return 0;
 480         }
 481         virtual uint32_t get_pc()
 482         {
 483                 return 0;
 484         }
 485         virtual uint32_t get_next_pc()
 486         {
 487                 return 0;
 488         }
 489
 490         // bios
 491         virtual bool bios_call_far_i86(uint32_t PC, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
 492         {
 493                 return false;
 494         }
 495         virtual bool bios_int_i86(int intnum, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
 496         {
 497                 return false;
 498         }
 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)   {
 500                 return false;
 501         }
 502         // misc
 503         const _TCHAR *get_device_name(void)
 504         {
 505                 return (const _TCHAR *)this_device_name;
 506         }
 507
 508         // event manager
 509         DEVICE* event_manager;
 510
 511         virtual void set_context_event_manager(DEVICE* device)
 512         {
 513                 event_manager = device;
 514         }
 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.
 539         // -- 20161010 K.O
 540         virtual void touch_sound(void);
 541         // Force render per 1 sample automatically.
 542         // See pcm1bit.cpp .
 543         // -- 20161010 K.O
 544         virtual void set_realtime_render(DEVICE *device, bool flag);
 545         virtual void set_realtime_render(bool flag)
 546         {
 547                 set_realtime_render(this, flag);
 548         }
 549         virtual void update_timing(int new_clocks, double new_frames_per_sec, int new_lines_per_frame) {}
 550
 551         // event callback
 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) {}
 557
 558         // sound
 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, ...);
 564
 565         // debugger
 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);
 585
 586         // misc
 587         const _TCHAR *get_lib_common_vm_version(void);
 588
 589         _TCHAR this_device_name[128];
 590
 591         // device node using with iterator.
 592         DEVICE* prev_device;
 593         DEVICE* next_device;
 594         int this_device_id;
 595 };
 596
 597 #endif