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