source/src/vm/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 _DEVICE_H_
  11 #define _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 #include "csp_logger.h"
  19 #define USE_DEVICE_NAME
  20 #endif
  21
  22 #if defined(USE_SHARED_DLL)
  23 #include "libcpu_newdev/device.h"
  24
  25 #else
  26 // max devices connected to the output port
  27 #define MAX_OUTPUT      16
  28
  29 // common signal id
  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
  36
  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
  43
  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
  54
  55 #if defined(_USE_QT)
  56 class CSP_Logger;
  57 class csp_state_utils;
  58
  59 extern CSP_Logger *csp_logger;
  60
  61 #endif
  62 class DEVICE
  63 {
  64 protected:
  65         VM_TEMPLATE* vm;
  66         EMU* emu;
  67         OSD* osd;
  68 #if defined(_USE_QT)
  69         CSP_Logger *p_logger;
  70         csp_state_utils *state_entry;
  71 #endif
  72
  73 public:
  74         DEVICE(VM_TEMPLATE* parent_vm, EMU* parent_emu) : vm(parent_vm), emu(parent_emu)
  75         {
  76 #if defined(_USE_QT)
  77                 osd = emu->get_osd();
  78                 p_logger = csp_logger;
  79                 state_entry = NULL;
  80 #else
  81                 osd = NULL;
  82 #endif
  83                 memset(this_device_name, 0x00, sizeof(this_device_name));
  84                 strncpy(this_device_name, "Base Device", 128 - 1);
  85                 prev_device = vm->last_device;
  86                 next_device = NULL;
  87                 if(vm->first_device == NULL) {
  88                         // this is the first device
  89                         vm->first_device = this;
  90                         this_device_id = 0;
  91                 } else {
  92                         // this is not the first device
  93                         vm->last_device->next_device = this;
  94                         this_device_id = vm->last_device->this_device_id + 1;
  95                 }
  96                 vm->last_device = this;
  97
  98                 // primary event manager
  99                 event_manager = NULL;
 100         }
 101         //ToDo: Will implement real destructor per real classes and below destructor decl. with "virtual".
 102         // This makes warning:
 103         //"deleting object of polymorphic class type 'DEVICE' which has non-virtual
 104         // destructor might cause undefined behavior [-Wdelete-non-virtual-dtor]".
 105         ~DEVICE(void) {}
 106
 107         virtual void initialize() {     /* osd = emu->get_osd(); */ /* Initializing VM must be after initializing OSD. */ }
 108 #if defined(_USE_QT)
 109         virtual void release() {
 110                 if(state_entry != NULL) delete state_entry;
 111                 state_entry = NULL;
 112         }
 113 #else
 114         virtual void release() {}
 115 #endif
 116
 117         virtual void update_config() {}
 118         virtual void save_state(FILEIO* state_fio) {}
 119         virtual bool load_state(FILEIO* state_fio)
 120         {
 121                 return true;
 122         }
 123         // control
 124         virtual void reset() {}
 125         virtual void special_reset()
 126         {
 127                 reset();
 128         }
 129         virtual bool process_state(FILEIO* state_fio, bool loading)
 130         {
 131                 if(loading) {
 132                         return load_state(state_fio);
 133                 } else {
 134                         save_state(state_fio);
 135                         return true;
 136                 }
 137         }
 138
 139         // NOTE: the virtual bus interface functions for 16/32bit access invite the cpu is little endian.
 140         // if the cpu is big endian, you need to implement them in the virtual machine memory/io classes.
 141
 142         // memory bus
 143         virtual void write_data8(uint32_t addr, uint32_t data) {}
 144         virtual uint32_t read_data8(uint32_t addr)
 145         {
 146                 return 0xff;
 147         }
 148         virtual void write_data16(uint32_t addr, uint32_t data)
 149         {
 150                 write_data8(addr, data & 0xff);
 151                 write_data8(addr + 1, (data >> 8) & 0xff);
 152         }
 153         virtual uint32_t read_data16(uint32_t addr)
 154         {
 155                 uint32_t val = read_data8(addr);
 156                 val |= read_data8(addr + 1) << 8;
 157                 return val;
 158         }
 159         virtual void write_data32(uint32_t addr, uint32_t data)
 160         {
 161                 write_data16(addr, data & 0xffff);
 162                 write_data16(addr + 2, (data >> 16) & 0xffff);
 163         }
 164         virtual uint32_t read_data32(uint32_t addr)
 165         {
 166                 uint32_t val = read_data16(addr);
 167                 val |= read_data16(addr + 2) << 16;
 168                 return val;
 169         }
 170         virtual void write_data8w(uint32_t addr, uint32_t data, int* wait)
 171         {
 172                 *wait = 0;
 173                 write_data8(addr, data);
 174         }
 175         virtual uint32_t read_data8w(uint32_t addr, int* wait)
 176         {
 177                 *wait = 0;
 178                 return read_data8(addr);
 179         }
 180         virtual void write_data16w(uint32_t addr, uint32_t data, int* wait)
 181         {
 182                 int wait_l, wait_h;
 183                 write_data8w(addr, data & 0xff, &wait_l);
 184                 write_data8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 185                 *wait = wait_l + wait_h;
 186         }
 187         virtual uint32_t read_data16w(uint32_t addr, int* wait)
 188         {
 189                 int wait_l, wait_h;
 190                 uint32_t val = read_data8w(addr, &wait_l);
 191                 val |= read_data8w(addr + 1, &wait_h) << 8;
 192                 *wait = wait_l + wait_h;
 193                 return val;
 194         }
 195         virtual void write_data32w(uint32_t addr, uint32_t data, int* wait)
 196         {
 197                 int wait_l, wait_h;
 198                 write_data16w(addr, data & 0xffff, &wait_l);
 199                 write_data16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 200                 *wait = wait_l + wait_h;
 201         }
 202         virtual uint32_t read_data32w(uint32_t addr, int* wait)
 203         {
 204                 int wait_l, wait_h;
 205                 uint32_t val = read_data16w(addr, &wait_l);
 206                 val |= read_data16w(addr + 2, &wait_h) << 16;
 207                 *wait = wait_l + wait_h;
 208                 return val;
 209         }
 210         virtual uint32_t fetch_op(uint32_t addr, int *wait)
 211         {
 212                 return read_data8w(addr, wait);
 213         }
 214         virtual void write_dma_data8(uint32_t addr, uint32_t data)
 215         {
 216                 write_data8(addr, data);
 217         }
 218         virtual uint32_t read_dma_data8(uint32_t addr)
 219         {
 220                 return read_data8(addr);
 221         }
 222         virtual void write_dma_data16(uint32_t addr, uint32_t data)
 223         {
 224                 write_data16(addr, data);
 225         }
 226         virtual uint32_t read_dma_data16(uint32_t addr)
 227         {
 228                 return read_data16(addr);
 229         }
 230         virtual void write_dma_data32(uint32_t addr, uint32_t data)
 231         {
 232                 write_data32(addr, data);
 233         }
 234         virtual uint32_t read_dma_data32(uint32_t addr)
 235         {
 236                 return read_data32(addr);
 237         }
 238         virtual void write_dma_data8w(uint32_t addr, uint32_t data, int* wait)
 239         {
 240                 write_data8w(addr, data, wait);
 241         }
 242         virtual uint32_t read_dma_data8w(uint32_t addr, int* wait)
 243         {
 244                 return read_data8w(addr, wait);
 245         }
 246         virtual void write_dma_data16w(uint32_t addr, uint32_t data, int* wait)
 247         {
 248                 write_data16w(addr, data, wait);
 249         }
 250         virtual uint32_t read_dma_data16w(uint32_t addr, int* wait)
 251         {
 252                 return read_data16w(addr, wait);
 253         }
 254         virtual void write_dma_data32w(uint32_t addr, uint32_t data, int* wait)
 255         {
 256                 write_data32w(addr, data, wait);
 257         }
 258         virtual uint32_t read_dma_data32w(uint32_t addr, int* wait)
 259         {
 260                 return read_data32w(addr, wait);
 261         }
 262
 263         // i/o bus
 264         virtual void write_io8(uint32_t addr, uint32_t data) {}
 265         virtual uint32_t read_io8(uint32_t addr)
 266         {
 267 #ifdef IOBUS_RETURN_ADDR
 268                 return (addr & 1 ? addr >> 8 : addr) & 0xff;
 269 #else
 270                 return 0xff;
 271 #endif
 272         }
 273         virtual void write_io16(uint32_t addr, uint32_t data)
 274         {
 275                 write_io8(addr, data & 0xff);
 276                 write_io8(addr + 1, (data >> 8) & 0xff);
 277         }
 278         virtual uint32_t read_io16(uint32_t addr)
 279         {
 280                 uint32_t val = read_io8(addr);
 281                 val |= read_io8(addr + 1) << 8;
 282                 return val;
 283         }
 284         virtual void write_io32(uint32_t addr, uint32_t data)
 285         {
 286                 write_io16(addr, data & 0xffff);
 287                 write_io16(addr + 2, (data >> 16) & 0xffff);
 288         }
 289         virtual uint32_t read_io32(uint32_t addr)
 290         {
 291                 uint32_t val = read_io16(addr);
 292                 val |= read_io16(addr + 2) << 16;
 293                 return val;
 294         }
 295         virtual void write_io8w(uint32_t addr, uint32_t data, int* wait)
 296         {
 297                 *wait = 0;
 298                 write_io8(addr, data);
 299         }
 300         virtual uint32_t read_io8w(uint32_t addr, int* wait)
 301         {
 302                 *wait = 0;
 303                 return read_io8(addr);
 304         }
 305         virtual void write_io16w(uint32_t addr, uint32_t data, int* wait)
 306         {
 307                 int wait_l, wait_h;
 308                 write_io8w(addr, data & 0xff, &wait_l);
 309                 write_io8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 310                 *wait = wait_l + wait_h;
 311         }
 312         virtual uint32_t read_io16w(uint32_t addr, int* wait)
 313         {
 314                 int wait_l, wait_h;
 315                 uint32_t val = read_io8w(addr, &wait_l);
 316                 val |= read_io8w(addr + 1, &wait_h) << 8;
 317                 *wait = wait_l + wait_h;
 318                 return val;
 319         }
 320         virtual void write_io32w(uint32_t addr, uint32_t data, int* wait)
 321         {
 322                 int wait_l, wait_h;
 323                 write_io16w(addr, data & 0xffff, &wait_l);
 324                 write_io16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 325                 *wait = wait_l + wait_h;
 326         }
 327         virtual uint32_t read_io32w(uint32_t addr, int* wait)
 328         {
 329                 int wait_l, wait_h;
 330                 uint32_t val = read_io16w(addr, &wait_l);
 331                 val |= read_io16w(addr + 2, &wait_h) << 16;
 332                 *wait = wait_l + wait_h;
 333                 return val;
 334         }
 335         virtual void write_dma_io8(uint32_t addr, uint32_t data)
 336         {
 337                 write_io8(addr, data);
 338         }
 339         virtual uint32_t read_dma_io8(uint32_t addr)
 340         {
 341                 return read_io8(addr);
 342         }
 343         virtual void write_dma_io16(uint32_t addr, uint32_t data)
 344         {
 345                 write_io16(addr, data);
 346         }
 347         virtual uint32_t read_dma_io16(uint32_t addr)
 348         {
 349                 return read_io16(addr);
 350         }
 351         virtual void write_dma_io32(uint32_t addr, uint32_t data)
 352         {
 353                 write_io32(addr, data);
 354         }
 355         virtual uint32_t read_dma_io32(uint32_t addr)
 356         {
 357                 return read_io32(addr);
 358         }
 359         virtual void write_dma_io8w(uint32_t addr, uint32_t data, int* wait)
 360         {
 361                 write_io8w(addr, data, wait);
 362         }
 363         virtual uint32_t read_dma_io8w(uint32_t addr, int* wait)
 364         {
 365                 return read_io8w(addr, wait);
 366         }
 367         virtual void write_dma_io16w(uint32_t addr, uint32_t data, int* wait)
 368         {
 369                 write_io16w(addr, data, wait);
 370         }
 371         virtual uint32_t read_dma_io16w(uint32_t addr, int* wait)
 372         {
 373                 return read_io16w(addr, wait);
 374         }
 375         virtual void write_dma_io32w(uint32_t addr, uint32_t data, int* wait)
 376         {
 377                 write_io32w(addr, data, wait);
 378         }
 379         virtual uint32_t read_dma_io32w(uint32_t addr, int* wait)
 380         {
 381                 return read_io32w(addr, wait);
 382         }
 383
 384         // memory mapped i/o
 385         virtual void write_memory_mapped_io8(uint32_t addr, uint32_t data)
 386         {
 387                 write_io8(addr, data);
 388         }
 389         virtual uint32_t read_memory_mapped_io8(uint32_t addr)
 390         {
 391                 return read_io8(addr);
 392         }
 393         virtual void write_memory_mapped_io16(uint32_t addr, uint32_t data)
 394         {
 395                 write_memory_mapped_io8(addr, data & 0xff);
 396                 write_memory_mapped_io8(addr + 1, (data >> 8) & 0xff);
 397         }
 398         virtual uint32_t read_memory_mapped_io16(uint32_t addr)
 399         {
 400                 uint32_t val = read_memory_mapped_io8(addr);
 401                 val |= read_memory_mapped_io8(addr + 1) << 8;
 402                 return val;
 403         }
 404         virtual void write_memory_mapped_io32(uint32_t addr, uint32_t data)
 405         {
 406                 write_memory_mapped_io16(addr, data & 0xffff);
 407                 write_memory_mapped_io16(addr + 2, (data >> 16) & 0xffff);
 408         }
 409         virtual uint32_t read_memory_mapped_io32(uint32_t addr)
 410         {
 411                 uint32_t val = read_memory_mapped_io16(addr);
 412                 val |= read_memory_mapped_io16(addr + 2) << 16;
 413                 return val;
 414         }
 415         virtual void write_memory_mapped_io8w(uint32_t addr, uint32_t data, int* wait)
 416         {
 417                 *wait = 0;
 418                 write_memory_mapped_io8(addr, data);
 419         }
 420         virtual uint32_t read_memory_mapped_io8w(uint32_t addr, int* wait)
 421         {
 422                 *wait = 0;
 423                 return read_memory_mapped_io8(addr);
 424         }
 425         virtual void write_memory_mapped_io16w(uint32_t addr, uint32_t data, int* wait)
 426         {
 427                 int wait_l, wait_h;
 428                 write_memory_mapped_io8w(addr, data & 0xff, &wait_l);
 429                 write_memory_mapped_io8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 430                 *wait = wait_l + wait_h;
 431         }
 432         virtual uint32_t read_memory_mapped_io16w(uint32_t addr, int* wait)
 433         {
 434                 int wait_l, wait_h;
 435                 uint32_t val = read_memory_mapped_io8w(addr, &wait_l);
 436                 val |= read_memory_mapped_io8w(addr + 1, &wait_h) << 8;
 437                 *wait = wait_l + wait_h;
 438                 return val;
 439         }
 440         virtual void write_memory_mapped_io32w(uint32_t addr, uint32_t data, int* wait)
 441         {
 442                 int wait_l, wait_h;
 443                 write_memory_mapped_io16w(addr, data & 0xffff, &wait_l);
 444                 write_memory_mapped_io16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 445                 *wait = wait_l + wait_h;
 446         }
 447         virtual uint32_t read_memory_mapped_io32w(uint32_t addr, int* wait)
 448         {
 449                 int wait_l, wait_h;
 450                 uint32_t val = read_memory_mapped_io16w(addr, &wait_l);
 451                 val |= read_memory_mapped_io16w(addr + 2, &wait_h) << 16;
 452                 *wait = wait_l + wait_h;
 453                 return val;
 454         }
 455
 456         // device to device
 457         typedef struct {
 458                 DEVICE *device;
 459                 int id;
 460                 uint32_t mask;
 461                 int shift;
 462         } output_t;
 463
 464         typedef struct {
 465                 int count;
 466                 output_t item[MAX_OUTPUT];
 467         } outputs_t;
 468
 469         virtual void initialize_output_signals(outputs_t *items)
 470         {
 471                 items->count = 0;
 472         }
 473         virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask, int shift)
 474         {
 475                 int c = items->count++;
 476                 items->item[c].device = device;
 477                 items->item[c].id = id;
 478                 items->item[c].mask = mask;
 479                 items->item[c].shift = shift;
 480         }
 481         virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask)
 482         {
 483                 int c = items->count++;
 484                 items->item[c].device = device;
 485                 items->item[c].id = id;
 486                 items->item[c].mask = mask;
 487                 items->item[c].shift = 0;
 488         }
 489         virtual void write_signals(outputs_t *items, uint32_t data)
 490         {
 491                 for(int i = 0; i < items->count; i++) {
 492                         output_t *item = &items->item[i];
 493                         int shift = item->shift;
 494                         uint32_t val = (shift < 0) ? (data >> (-shift)) : (data << shift);
 495                         uint32_t mask = (shift < 0) ? (item->mask >> (-shift)) : (item->mask << shift);
 496                         item->device->write_signal(item->id, val, mask);
 497                 }
 498         };
 499         virtual void write_signal(int id, uint32_t data, uint32_t mask) {}
 500         virtual uint32_t read_signal(int ch)
 501         {
 502                 return 0;
 503         }
 504
 505         // z80 daisy chain
 506         virtual void set_context_intr(DEVICE* device, uint32_t bit) {}
 507         virtual void set_context_child(DEVICE* device) {}
 508
 509         // interrupt device to device
 510         virtual void set_intr_iei(bool val) {}
 511
 512         // interrupt device to cpu
 513         virtual void set_intr_line(bool line, bool pending, uint32_t bit) {}
 514
 515         // interrupt cpu to device
 516         virtual uint32_t get_intr_ack()
 517         {
 518                 return 0xff;
 519         }
 520         virtual void notify_intr_reti() {}
 521         virtual void notify_intr_ei() {}
 522
 523         // dma
 524         virtual void do_dma() {}
 525
 526         // cpu
 527         virtual int run(int clock)
 528         {
 529                 // when clock == -1, run one opecode
 530                 return (clock == -1 ? 1 : clock);
 531         }
 532         virtual void set_extra_clock(int clock) {}
 533         virtual int get_extra_clock()
 534         {
 535                 return 0;
 536         }
 537         virtual uint32_t get_pc()
 538         {
 539                 return 0;
 540         }
 541         virtual uint32_t get_next_pc()
 542         {
 543                 return 0;
 544         }
 545
 546         // bios
 547         virtual bool bios_call_far_i86(uint32_t PC, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
 548         {
 549                 return false;
 550         }
 551         virtual bool bios_int_i86(int intnum, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
 552         {
 553                 return false;
 554         }
 555         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)   {
 556                 return false;
 557         }
 558         // misc
 559         const _TCHAR *get_device_name(void)
 560         {
 561                 return (const _TCHAR *)this_device_name;
 562         }
 563
 564         // event manager
 565         DEVICE* event_manager;
 566
 567         virtual void set_context_event_manager(DEVICE* device)
 568         {
 569                 event_manager = device;
 570         }
 571         virtual int get_event_manager_id()
 572         {
 573                 if(event_manager == NULL) {
 574                         event_manager = vm->first_device->next_device;
 575                 }
 576                 return event_manager->this_device_id;
 577         }
 578         virtual void register_event(DEVICE* device, int event_id, double usec, bool loop, int* register_id)
 579         {
 580                 if(event_manager == NULL) {
 581                         event_manager = vm->first_device->next_device;
 582                 }
 583                 event_manager->register_event(device, event_id, usec, loop, register_id);
 584         }
 585         virtual void register_event_by_clock(DEVICE* device, int event_id, uint64_t clock, bool loop, int* register_id)
 586         {
 587                 if(event_manager == NULL) {
 588                         event_manager = vm->first_device->next_device;
 589                 }
 590                 event_manager->register_event_by_clock(device, event_id, clock, loop, register_id);
 591         }
 592         virtual void cancel_event(DEVICE* device, int register_id)
 593         {
 594                 if(event_manager == NULL) {
 595                         event_manager = vm->first_device->next_device;
 596                 }
 597                 event_manager->cancel_event(device, register_id);
 598         }
 599         virtual void register_frame_event(DEVICE* device)
 600         {
 601                 if(event_manager == NULL) {
 602                         event_manager = vm->first_device->next_device;
 603                 }
 604                 event_manager->register_frame_event(device);
 605         }
 606         virtual void register_vline_event(DEVICE* device)
 607         {
 608                 if(event_manager == NULL) {
 609                         event_manager = vm->first_device->next_device;
 610                 }
 611                 event_manager->register_vline_event(device);
 612         }
 613         virtual uint32_t get_event_remaining_clock(int register_id)
 614         {
 615                 if(event_manager == NULL) {
 616                         event_manager = vm->first_device->next_device;
 617                 }
 618                 return event_manager->get_event_remaining_clock(register_id);
 619         }
 620         virtual double get_event_remaining_usec(int register_id)
 621         {
 622                 if(event_manager == NULL) {
 623                         event_manager = vm->first_device->next_device;
 624                 }
 625                 return event_manager->get_event_remaining_usec(register_id);
 626         }
 627         virtual uint32_t get_current_clock()
 628         {
 629                 if(event_manager == NULL) {
 630                         event_manager = vm->first_device->next_device;
 631                 }
 632                 return event_manager->get_current_clock();
 633         }
 634         virtual uint32_t get_passed_clock(uint32_t prev)
 635         {
 636                 if(event_manager == NULL) {
 637                         event_manager = vm->first_device->next_device;
 638                 }
 639                 return event_manager->get_passed_clock(prev);
 640         }
 641         virtual double get_passed_usec(uint32_t prev)
 642         {
 643                 if(event_manager == NULL) {
 644                         event_manager = vm->first_device->next_device;
 645                 }
 646                 return event_manager->get_passed_usec(prev);
 647         }
 648         virtual uint32_t get_passed_clock_since_vline()
 649         {
 650                 if(event_manager == NULL) {
 651                         event_manager = vm->first_device->next_device;
 652                 }
 653                 return event_manager->get_passed_clock_since_vline();
 654         }
 655         virtual double get_passed_usec_since_vline()
 656         {
 657                 if(event_manager == NULL) {
 658                         event_manager = vm->first_device->next_device;
 659                 }
 660                 return event_manager->get_passed_usec_since_vline();
 661         }
 662         virtual int get_cur_vline()
 663         {
 664                 if(event_manager == NULL) {
 665                         event_manager = vm->first_device->next_device;
 666                 }
 667                 return event_manager->get_cur_vline();
 668         }
 669         virtual int get_cur_vline_clocks()
 670         {
 671                 if(event_manager == NULL) {
 672                         event_manager = vm->first_device->next_device;
 673                 }
 674                 return event_manager->get_cur_vline_clocks();
 675         }
 676         virtual uint32_t get_cpu_pc(int index)
 677         {
 678                 if(event_manager == NULL) {
 679                         event_manager = vm->first_device->next_device;
 680                 }
 681                 return event_manager->get_cpu_pc(index);
 682         }
 683         virtual void request_skip_frames()
 684         {
 685                 if(event_manager == NULL) {
 686                         event_manager = vm->first_device->next_device;
 687                 }
 688                 event_manager->request_skip_frames();
 689         }
 690         virtual void set_frames_per_sec(double frames)
 691         {
 692                 if(event_manager == NULL) {
 693                         event_manager = vm->first_device->next_device;
 694                 }
 695                 event_manager->set_frames_per_sec(frames);
 696         }
 697         virtual void set_lines_per_frame(int lines)
 698         {
 699                 if(event_manager == NULL) {
 700                         event_manager = vm->first_device->next_device;
 701                 }
 702                 event_manager->set_lines_per_frame(lines);
 703         }
 704         virtual int get_lines_per_frame()
 705         {
 706                 if(event_manager == NULL) {
 707                         event_manager = vm->first_device->next_device;
 708                 }
 709                 return event_manager->get_lines_per_frame();
 710         }
 711         // Force reder sound immediately when device's status has changed.
 712         // You must call this after you changing registers (or enything).
 713         // If has problems, try set_realtime_render.
 714         // See mb8877.cpp and ym2203.cpp.
 715         // -- 20161010 K.O
 716         virtual void touch_sound(void)
 717         {
 718                 if(event_manager == NULL) {
 719                         event_manager = vm->first_device->next_device;
 720                 }
 721                 event_manager->touch_sound();
 722         }
 723         // Force render per 1 sample automatically.
 724         // See pcm1bit.cpp .
 725         // -- 20161010 K.O
 726         virtual void set_realtime_render(DEVICE* device, bool flag = true)
 727         {
 728                 if(event_manager == NULL) {
 729                         event_manager = vm->first_device->next_device;
 730                 }
 731                 if(device != event_manager) event_manager->set_realtime_render(device, flag);
 732         }
 733         virtual void set_realtime_render(bool flag)
 734         {
 735                 set_realtime_render(this, flag);
 736         }
 737         virtual void update_timing(int new_clocks, double new_frames_per_sec, int new_lines_per_frame) {}
 738
 739         // event callback
 740         virtual void event_callback(int event_id, int err) {}
 741         virtual void event_pre_frame() {}       // this event is to update timing settings
 742         virtual void event_frame() {}
 743         virtual void event_vline(int v, int clock) {}
 744         virtual void event_hsync(int v, int h, int clock) {}
 745
 746         // sound
 747         virtual void mix(int32_t* buffer, int cnt) {}
 748         virtual void set_volume(int ch, int decibel_l, int decibel_r) {} // +1 equals +0.5dB (same as fmgen)
 749         virtual void set_device_name(const _TCHAR *format, ...)
 750         {
 751                 if(format != NULL) {
 752                         va_list ap;
 753                         _TCHAR buffer[1024];
 754
 755                         va_start(ap, format);
 756                         my_vstprintf_s(buffer, 1024, format, ap);
 757                         va_end(ap);
 758
 759                         my_tcscpy_s(this_device_name, 128, buffer);
 760 #ifdef _USE_QT
 761                         emu->get_osd()->set_vm_node(this_device_id, buffer);
 762 #endif
 763                 }
 764         }
 765         virtual void out_debug_log(const char *fmt, ...)
 766         {
 767                 char strbuf[4096];
 768                 va_list ap;
 769
 770                 va_start(ap, fmt);
 771                 vsnprintf(strbuf, 4095, fmt, ap);
 772                 emu->out_debug_log("%s", strbuf);
 773                 va_end(ap);
 774         }
 775         virtual void force_out_debug_log(const char *fmt, ...)
 776         {
 777                 char strbuf[4096];
 778                 va_list ap;
 779
 780                 va_start(ap, fmt);
 781                 vsnprintf(strbuf, 4095, fmt, ap);
 782                 emu->force_out_debug_log("%s", strbuf);
 783                 va_end(ap);
 784         }
 785
 786 #ifdef USE_DEBUGGER
 787         // debugger
 788         virtual void *get_debugger()
 789         {
 790                 return NULL;
 791         }
 792         virtual uint32_t get_debug_prog_addr_mask()
 793         {
 794                 return 0;
 795         }
 796         virtual uint32_t get_debug_data_addr_mask()
 797         {
 798                 return 0;
 799         }
 800         virtual void write_debug_data8(uint32_t addr, uint32_t data) {}
 801         virtual uint32_t read_debug_data8(uint32_t addr)
 802         {
 803                 return 0xff;
 804         }
 805         virtual void write_debug_data16(uint32_t addr, uint32_t data)
 806         {
 807                 write_debug_data8(addr, data & 0xff);
 808                 write_debug_data8(addr + 1, (data >> 8) & 0xff);
 809         }
 810         virtual uint32_t read_debug_data16(uint32_t addr)
 811         {
 812                 uint32_t val = read_debug_data8(addr);
 813                 val |= read_debug_data8(addr + 1) << 8;
 814                 return val;
 815         }
 816         virtual void write_debug_data32(uint32_t addr, uint32_t data)
 817         {
 818                 write_debug_data16(addr, data & 0xffff);
 819                 write_debug_data16(addr + 2, (data >> 16) & 0xffff);
 820         }
 821         virtual uint32_t read_debug_data32(uint32_t addr)
 822         {
 823                 uint32_t val = read_debug_data16(addr);
 824                 val |= read_debug_data16(addr + 2) << 16;
 825                 return val;
 826         }
 827         virtual void write_debug_io8(uint32_t addr, uint32_t data) {}
 828         virtual uint32_t read_debug_io8(uint32_t addr)
 829         {
 830                 return 0xff;
 831         }
 832         virtual void write_debug_io16(uint32_t addr, uint32_t data)
 833         {
 834                 write_debug_io8(addr, data & 0xff);
 835                 write_debug_io8(addr + 1, (data >> 8) & 0xff);
 836         }
 837         virtual uint32_t read_debug_io16(uint32_t addr)
 838         {
 839                 uint32_t val = read_debug_io8(addr);
 840                 val |= read_debug_io8(addr + 1) << 8;
 841                 return val;
 842         }
 843         virtual void write_debug_io32(uint32_t addr, uint32_t data)
 844         {
 845                 write_debug_io16(addr, data & 0xffff);
 846                 write_debug_io16(addr + 2, (data >> 16) & 0xffff);
 847         }
 848         virtual uint32_t read_debug_io32(uint32_t addr)
 849         {
 850                 uint32_t val = read_debug_io16(addr);
 851                 val |= read_debug_io16(addr + 2) << 16;
 852                 return val;
 853         }
 854         virtual bool write_debug_reg(const _TCHAR *reg, uint32_t data)
 855         {
 856                 return false;
 857         }
 858         virtual uint32_t read_debug_reg(const _TCHAR *reg)
 859         {
 860                 return 0;
 861         }
 862         virtual void get_debug_regs_info(_TCHAR *buffer, size_t buffer_len) {}
 863         virtual int debug_dasm(uint32_t pc, _TCHAR *buffer, size_t buffer_len)
 864         {
 865                 return 0;
 866         }
 867 #endif
 868         _TCHAR this_device_name[128];
 869
 870         DEVICE* prev_device;
 871         DEVICE* next_device;
 872         int this_device_id;
 873 };
 874 #endif // USE_SHARED_DLL
 875
 876 #endif