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 class CSP_Logger;
  50 class csp_state_utils;
  51 class VM;
  52 class EMU;
  53 class OSD;
  54 class DEVICE
  55 {
  56 protected:
  57         VM* vm;
  58         EMU* emu;
  59         OSD* osd;
  60         csp_state_utils *state_entry;
  61         CSP_Logger *p_logger;
  62 public:
  63         DEVICE(VM* parent_vm, EMU* parent_emu);
  64         //ToDo: Will implement real destructor per real classes and below destructor decl. with "virtual".
  65         // This makes warning:
  66         //"deleting object of polymorphic class type 'DEVICE' which has non-virtual
  67         // destructor might cause undefined behavior [-Wdelete-non-virtual-dtor]".
  68         //~DEVICE(void);
  69         virtual ~DEVICE() {}
  70
  71         virtual void initialize() { /* osd = emu->get_osd(); */}
  72         virtual void release();
  73
  74         virtual void update_config() {}
  75         virtual void save_state(FILEIO* state_fio) {}
  76         virtual bool load_state(FILEIO* state_fio)
  77         {
  78                 return true;
  79         }
  80
  81         virtual void decl_state(void);
  82         virtual void enter_decl_state(int version);
  83         virtual void enter_decl_state(int version,  _TCHAR *name);
  84         virtual void leave_decl_state(void);
  85
  86         // control
  87         virtual void reset() {}
  88         virtual void special_reset()
  89         {
  90                 reset();
  91         }
  92
  93         // NOTE: the virtual bus interface functions for 16/32bit access invite the cpu is little endian.
  94         // if the cpu is big endian, you need to implement them in the virtual machine memory/io classes.
  95
  96         // memory bus
  97         virtual void write_data8(uint32_t addr, uint32_t data) {}
  98         virtual uint32_t read_data8(uint32_t addr)
  99         {
 100                 return 0xff;
 101         }
 102         virtual void write_data16(uint32_t addr, uint32_t data)
 103         {
 104                 write_data8(addr, data & 0xff);
 105                 write_data8(addr + 1, (data >> 8) & 0xff);
 106         }
 107         virtual uint32_t read_data16(uint32_t addr)
 108         {
 109                 uint32_t val = read_data8(addr);
 110                 val |= read_data8(addr + 1) << 8;
 111                 return val;
 112         }
 113         virtual void write_data32(uint32_t addr, uint32_t data)
 114         {
 115                 write_data16(addr, data & 0xffff);
 116                 write_data16(addr + 2, (data >> 16) & 0xffff);
 117         }
 118         virtual uint32_t read_data32(uint32_t addr)
 119         {
 120                 uint32_t val = read_data16(addr);
 121                 val |= read_data16(addr + 2) << 16;
 122                 return val;
 123         }
 124         virtual void write_data8w(uint32_t addr, uint32_t data, int* wait)
 125         {
 126                 *wait = 0;
 127                 write_data8(addr, data);
 128         }
 129         virtual uint32_t read_data8w(uint32_t addr, int* wait)
 130         {
 131                 *wait = 0;
 132                 return read_data8(addr);
 133         }
 134         virtual void write_data16w(uint32_t addr, uint32_t data, int* wait)
 135         {
 136                 int wait_l, wait_h;
 137                 write_data8w(addr, data & 0xff, &wait_l);
 138                 write_data8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 139                 *wait = wait_l + wait_h;
 140         }
 141         virtual uint32_t read_data16w(uint32_t addr, int* wait)
 142         {
 143                 int wait_l, wait_h;
 144                 uint32_t val = read_data8w(addr, &wait_l);
 145                 val |= read_data8w(addr + 1, &wait_h) << 8;
 146                 *wait = wait_l + wait_h;
 147                 return val;
 148         }
 149         virtual void write_data32w(uint32_t addr, uint32_t data, int* wait)
 150         {
 151                 int wait_l, wait_h;
 152                 write_data16w(addr, data & 0xffff, &wait_l);
 153                 write_data16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 154                 *wait = wait_l + wait_h;
 155         }
 156         virtual uint32_t read_data32w(uint32_t addr, int* wait)
 157         {
 158                 int wait_l, wait_h;
 159                 uint32_t val = read_data16w(addr, &wait_l);
 160                 val |= read_data16w(addr + 2, &wait_h) << 16;
 161                 *wait = wait_l + wait_h;
 162                 return val;
 163         }
 164         virtual uint32_t fetch_op(uint32_t addr, int *wait)
 165         {
 166                 return read_data8w(addr, wait);
 167         }
 168         virtual void write_dma_data8(uint32_t addr, uint32_t data)
 169         {
 170                 write_data8(addr, data);
 171         }
 172         virtual uint32_t read_dma_data8(uint32_t addr)
 173         {
 174                 return read_data8(addr);
 175         }
 176         virtual void write_dma_data16(uint32_t addr, uint32_t data)
 177         {
 178                 write_data16(addr, data);
 179         }
 180         virtual uint32_t read_dma_data16(uint32_t addr)
 181         {
 182                 return read_data16(addr);
 183         }
 184         virtual void write_dma_data32(uint32_t addr, uint32_t data)
 185         {
 186                 write_data32(addr, data);
 187         }
 188         virtual uint32_t read_dma_data32(uint32_t addr)
 189         {
 190                 return read_data32(addr);
 191         }
 192         virtual void write_dma_data8w(uint32_t addr, uint32_t data, int* wait)
 193         {
 194                 write_data8w(addr, data, wait);
 195         }
 196         virtual uint32_t read_dma_data8w(uint32_t addr, int* wait)
 197         {
 198                 return read_data8w(addr, wait);
 199         }
 200         virtual void write_dma_data16w(uint32_t addr, uint32_t data, int* wait)
 201         {
 202                 write_data16w(addr, data, wait);
 203         }
 204         virtual uint32_t read_dma_data16w(uint32_t addr, int* wait)
 205         {
 206                 return read_data16w(addr, wait);
 207         }
 208         virtual void write_dma_data32w(uint32_t addr, uint32_t data, int* wait)
 209         {
 210                 write_data32w(addr, data, wait);
 211         }
 212         virtual uint32_t read_dma_data32w(uint32_t addr, int* wait)
 213         {
 214                 return read_data32w(addr, wait);
 215         }
 216
 217         // i/o bus
 218         virtual void write_io8(uint32_t addr, uint32_t data) {}
 219         virtual uint32_t read_io8(uint32_t addr);
 220         virtual void write_io16(uint32_t addr, uint32_t data)
 221         {
 222                 write_io8(addr, data & 0xff);
 223                 write_io8(addr + 1, (data >> 8) & 0xff);
 224         }
 225         virtual uint32_t read_io16(uint32_t addr)
 226         {
 227                 uint32_t val = read_io8(addr);
 228                 val |= read_io8(addr + 1) << 8;
 229                 return val;
 230         }
 231         virtual void write_io32(uint32_t addr, uint32_t data)
 232         {
 233                 write_io16(addr, data & 0xffff);
 234                 write_io16(addr + 2, (data >> 16) & 0xffff);
 235         }
 236         virtual uint32_t read_io32(uint32_t addr)
 237         {
 238                 uint32_t val = read_io16(addr);
 239                 val |= read_io16(addr + 2) << 16;
 240                 return val;
 241         }
 242         virtual void write_io8w(uint32_t addr, uint32_t data, int* wait)
 243         {
 244                 *wait = 0;
 245                 write_io8(addr, data);
 246         }
 247         virtual uint32_t read_io8w(uint32_t addr, int* wait)
 248         {
 249                 *wait = 0;
 250                 return read_io8(addr);
 251         }
 252         virtual void write_io16w(uint32_t addr, uint32_t data, int* wait)
 253         {
 254                 int wait_l, wait_h;
 255                 write_io8w(addr, data & 0xff, &wait_l);
 256                 write_io8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 257                 *wait = wait_l + wait_h;
 258         }
 259         virtual uint32_t read_io16w(uint32_t addr, int* wait)
 260         {
 261                 int wait_l, wait_h;
 262                 uint32_t val = read_io8w(addr, &wait_l);
 263                 val |= read_io8w(addr + 1, &wait_h) << 8;
 264                 *wait = wait_l + wait_h;
 265                 return val;
 266         }
 267         virtual void write_io32w(uint32_t addr, uint32_t data, int* wait)
 268         {
 269                 int wait_l, wait_h;
 270                 write_io16w(addr, data & 0xffff, &wait_l);
 271                 write_io16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 272                 *wait = wait_l + wait_h;
 273         }
 274         virtual uint32_t read_io32w(uint32_t addr, int* wait)
 275         {
 276                 int wait_l, wait_h;
 277                 uint32_t val = read_io16w(addr, &wait_l);
 278                 val |= read_io16w(addr + 2, &wait_h) << 16;
 279                 *wait = wait_l + wait_h;
 280                 return val;
 281         }
 282         virtual void write_dma_io8(uint32_t addr, uint32_t data)
 283         {
 284                 write_io8(addr, data);
 285         }
 286         virtual uint32_t read_dma_io8(uint32_t addr)
 287         {
 288                 return read_io8(addr);
 289         }
 290         virtual void write_dma_io16(uint32_t addr, uint32_t data)
 291         {
 292                 write_io16(addr, data);
 293         }
 294         virtual uint32_t read_dma_io16(uint32_t addr)
 295         {
 296                 return read_io16(addr);
 297         }
 298         virtual void write_dma_io32(uint32_t addr, uint32_t data)
 299         {
 300                 write_io32(addr, data);
 301         }
 302         virtual uint32_t read_dma_io32(uint32_t addr)
 303         {
 304                 return read_io32(addr);
 305         }
 306         virtual void write_dma_io8w(uint32_t addr, uint32_t data, int* wait)
 307         {
 308                 write_io8w(addr, data, wait);
 309         }
 310         virtual uint32_t read_dma_io8w(uint32_t addr, int* wait)
 311         {
 312                 return read_io8w(addr, wait);
 313         }
 314         virtual void write_dma_io16w(uint32_t addr, uint32_t data, int* wait)
 315         {
 316                 write_io16w(addr, data, wait);
 317         }
 318         virtual uint32_t read_dma_io16w(uint32_t addr, int* wait)
 319         {
 320                 return read_io16w(addr, wait);
 321         }
 322         virtual void write_dma_io32w(uint32_t addr, uint32_t data, int* wait)
 323         {
 324                 write_io32w(addr, data, wait);
 325         }
 326         virtual uint32_t read_dma_io32w(uint32_t addr, int* wait)
 327         {
 328                 return read_io32w(addr, wait);
 329         }
 330
 331         // memory mapped i/o
 332         virtual void write_memory_mapped_io8(uint32_t addr, uint32_t data)
 333         {
 334                 write_io8(addr, data);
 335         }
 336         virtual uint32_t read_memory_mapped_io8(uint32_t addr)
 337         {
 338                 return read_io8(addr);
 339         }
 340         virtual void write_memory_mapped_io16(uint32_t addr, uint32_t data)
 341         {
 342                 write_memory_mapped_io8(addr, data & 0xff);
 343                 write_memory_mapped_io8(addr + 1, (data >> 8) & 0xff);
 344         }
 345         virtual uint32_t read_memory_mapped_io16(uint32_t addr)
 346         {
 347                 uint32_t val = read_memory_mapped_io8(addr);
 348                 val |= read_memory_mapped_io8(addr + 1) << 8;
 349                 return val;
 350         }
 351         virtual void write_memory_mapped_io32(uint32_t addr, uint32_t data)
 352         {
 353                 write_memory_mapped_io16(addr, data & 0xffff);
 354                 write_memory_mapped_io16(addr + 2, (data >> 16) & 0xffff);
 355         }
 356         virtual uint32_t read_memory_mapped_io32(uint32_t addr)
 357         {
 358                 uint32_t val = read_memory_mapped_io16(addr);
 359                 val |= read_memory_mapped_io16(addr + 2) << 16;
 360                 return val;
 361         }
 362         virtual void write_memory_mapped_io8w(uint32_t addr, uint32_t data, int* wait)
 363         {
 364                 *wait = 0;
 365                 write_memory_mapped_io8(addr, data);
 366         }
 367         virtual uint32_t read_memory_mapped_io8w(uint32_t addr, int* wait)
 368         {
 369                 *wait = 0;
 370                 return read_memory_mapped_io8(addr);
 371         }
 372         virtual void write_memory_mapped_io16w(uint32_t addr, uint32_t data, int* wait)
 373         {
 374                 int wait_l, wait_h;
 375                 write_memory_mapped_io8w(addr, data & 0xff, &wait_l);
 376                 write_memory_mapped_io8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 377                 *wait = wait_l + wait_h;
 378         }
 379         virtual uint32_t read_memory_mapped_io16w(uint32_t addr, int* wait)
 380         {
 381                 int wait_l, wait_h;
 382                 uint32_t val = read_memory_mapped_io8w(addr, &wait_l);
 383                 val |= read_memory_mapped_io8w(addr + 1, &wait_h) << 8;
 384                 *wait = wait_l + wait_h;
 385                 return val;
 386         }
 387         virtual void write_memory_mapped_io32w(uint32_t addr, uint32_t data, int* wait)
 388         {
 389                 int wait_l, wait_h;
 390                 write_memory_mapped_io16w(addr, data & 0xffff, &wait_l);
 391                 write_memory_mapped_io16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 392                 *wait = wait_l + wait_h;
 393         }
 394         virtual uint32_t read_memory_mapped_io32w(uint32_t addr, int* wait)
 395         {
 396                 int wait_l, wait_h;
 397                 uint32_t val = read_memory_mapped_io16w(addr, &wait_l);
 398                 val |= read_memory_mapped_io16w(addr + 2, &wait_h) << 16;
 399                 *wait = wait_l + wait_h;
 400                 return val;
 401         }
 402
 403         // device to device
 404         typedef struct {
 405                 DEVICE *device;
 406                 int id;
 407                 uint32_t mask;
 408                 int shift;
 409         } output_t;
 410
 411         typedef struct {
 412                 int count;
 413                 output_t item[MAX_OUTPUT];
 414         } outputs_t;
 415
 416         virtual void initialize_output_signals(outputs_t *items)
 417         {
 418                 items->count = 0;
 419         }
 420         virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask, int shift)
 421         {
 422                 int c = items->count++;
 423                 items->item[c].device = device;
 424                 items->item[c].id = id;
 425                 items->item[c].mask = mask;
 426                 items->item[c].shift = shift;
 427         }
 428         virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask)
 429         {
 430                 int c = items->count++;
 431                 items->item[c].device = device;
 432                 items->item[c].id = id;
 433                 items->item[c].mask = mask;
 434                 items->item[c].shift = 0;
 435         }
 436         virtual void write_signals(outputs_t *items, uint32_t data)
 437         {
 438                 for(int i = 0; i < items->count; i++) {
 439                         output_t *item = &items->item[i];
 440                         int shift = item->shift;
 441                         uint32_t val = (shift < 0) ? (data >> (-shift)) : (data << shift);
 442                         uint32_t mask = (shift < 0) ? (item->mask >> (-shift)) : (item->mask << shift);
 443                         item->device->write_signal(item->id, val, mask);
 444                 }
 445         };
 446         virtual void write_signal(int id, uint32_t data, uint32_t mask) {}
 447         virtual uint32_t read_signal(int ch)
 448         {
 449                 return 0;
 450         }
 451
 452         // z80 daisy chain
 453         virtual void set_context_intr(DEVICE* device, uint32_t bit) {}
 454         virtual void set_context_child(DEVICE* device) {}
 455
 456         // interrupt device to device
 457         virtual void set_intr_iei(bool val) {}
 458
 459         // interrupt device to cpu
 460         virtual void set_intr_line(bool line, bool pending, uint32_t bit) {}
 461
 462         // interrupt cpu to device
 463         virtual uint32_t get_intr_ack()
 464         {
 465                 return 0xff;
 466         }
 467         virtual void notify_intr_reti() {}
 468         virtual void notify_intr_ei() {}
 469
 470         // dma
 471         virtual void do_dma() {}
 472
 473         // cpu
 474         virtual int run(int clock)
 475         {
 476                 // when clock == -1, run one opecode
 477                 return (clock == -1 ? 1 : clock);
 478         }
 479         virtual void set_extra_clock(int clock) {}
 480         virtual int get_extra_clock()
 481         {
 482                 return 0;
 483         }
 484         virtual uint32_t get_pc()
 485         {
 486                 return 0;
 487         }
 488         virtual uint32_t get_next_pc()
 489         {
 490                 return 0;
 491         }
 492
 493         // bios
 494         virtual bool bios_call_far_i86(uint32_t PC, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
 495         {
 496                 return false;
 497         }
 498         virtual bool bios_int_i86(int intnum, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
 499         {
 500                 return false;
 501         }
 502         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                 return false;
 504         }
 505         // misc
 506         const _TCHAR *get_device_name(void)
 507         {
 508                 return (const _TCHAR *)this_device_name;
 509         }
 510
 511         // event manager
 512         DEVICE* event_manager;
 513
 514         virtual void set_context_event_manager(DEVICE* device)
 515         {
 516                 event_manager = device;
 517         }
 518         virtual int get_event_manager_id();
 519         virtual void register_event(DEVICE* device, int event_id, double usec, bool loop, int* register_id);
 520         virtual void register_event_by_clock(DEVICE* device, int event_id, uint64_t clock, bool loop, int* register_id);
 521         virtual void cancel_event(DEVICE* device, int register_id);
 522         virtual void register_frame_event(DEVICE* device);
 523         virtual void register_vline_event(DEVICE* device);
 524         virtual uint32_t get_event_remaining_clock(int register_id);
 525         virtual double get_event_remaining_usec(int register_id);
 526         virtual uint32_t get_current_clock();
 527         virtual uint32_t get_passed_clock(uint32_t prev);
 528         virtual double get_passed_usec(uint32_t prev);
 529         virtual uint32_t get_passed_clock_since_vline();
 530         virtual double get_passed_usec_since_vline();
 531         virtual int get_cur_vline();
 532         virtual int get_cur_vline_clocks();
 533         virtual uint32_t get_cpu_pc(int index);
 534         virtual void request_skip_frames();
 535         virtual void set_frames_per_sec(double frames);
 536         virtual void set_lines_per_frame(int lines);
 537         virtual int get_lines_per_frame(void);
 538         // Force render sound immediately when device's status has changed.
 539         // You must call this after you changing registers (or enything).
 540         // If has problems, try set_realtime_render.
 541         // See mb8877.cpp and ym2203.cpp.
 542         // -- 20161010 K.O
 543         virtual void touch_sound(void);
 544         // Force render per 1 sample automatically.
 545         // See pcm1bit.cpp .
 546         // -- 20161010 K.O
 547         virtual void set_realtime_render(DEVICE *device, bool flag);
 548         virtual void set_realtime_render(bool flag)
 549         {
 550                 set_realtime_render(this, flag);
 551         }
 552         virtual void update_timing(int new_clocks, double new_frames_per_sec, int new_lines_per_frame) {}
 553
 554         // event callback
 555         virtual void event_callback(int event_id, int err) {}
 556         virtual void event_pre_frame() {}       // this event is to update timing settings
 557         virtual void event_frame() {}
 558         virtual void event_vline(int v, int clock) {}
 559         virtual void event_hsync(int v, int h, int clock) {}
 560
 561         // sound
 562         virtual void mix(int32_t* buffer, int cnt) {}
 563         virtual void set_volume(int ch, int decibel_l, int decibel_r) {} // +1 equals +0.5dB (same as fmgen)
 564         virtual void set_device_name(const _TCHAR *format, ...);
 565         virtual void out_debug_log(const char *fmt, ...);
 566         virtual void force_out_debug_log(const char *fmt, ...);
 567 #if 1
 568         // debugger
 569         // DEBUGGER is enabled by default.
 570         virtual void *get_debugger();
 571         virtual uint32_t get_debug_prog_addr_mask();
 572         virtual uint32_t get_debug_data_addr_mask();
 573         virtual void write_debug_data8(uint32_t addr, uint32_t data);
 574         virtual uint32_t read_debug_data8(uint32_t addr);
 575         virtual void write_debug_data16(uint32_t addr, uint32_t data);
 576         virtual uint32_t read_debug_data16(uint32_t addr);
 577         virtual void write_debug_data32(uint32_t addr, uint32_t data);
 578         virtual uint32_t read_debug_data32(uint32_t addr);
 579         virtual void write_debug_io8(uint32_t addr, uint32_t data);
 580         virtual uint32_t read_debug_io8(uint32_t addr);
 581         virtual void write_debug_io16(uint32_t addr, uint32_t data);
 582         virtual uint32_t read_debug_io16(uint32_t addr);
 583         virtual void write_debug_io32(uint32_t addr, uint32_t data);
 584         virtual uint32_t read_debug_io32(uint32_t addr);
 585         virtual bool write_debug_reg(const _TCHAR *reg, uint32_t data);
 586         virtual void get_debug_regs_info(_TCHAR *buffer, size_t buffer_len);
 587         virtual int debug_dasm(uint32_t pc, _TCHAR *buffer, size_t buffer_len);
 588 #endif
 589         _TCHAR this_device_name[128];
 590
 591         DEVICE* prev_device;
 592         DEVICE* next_device;
 593         int this_device_id;
 594 };
 595
 596 #endif