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