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         virtual DEVICE *get_context_child()
 503         {
 504                 return NULL;
 505         }
 506
 507         // interrupt device to device
 508         virtual void set_intr_iei(bool val) {}
 509
 510         // interrupt device to cpu
 511         virtual void set_intr_line(bool line, bool pending, uint32_t bit) {}
 512
 513         // interrupt cpu to device
 514         virtual uint32_t get_intr_ack()
 515         {
 516                 return 0xff;
 517         }
 518         virtual void notify_intr_reti() {}
 519         virtual void notify_intr_ei() {}
 520
 521         // dma
 522         virtual void do_dma() {}
 523
 524         // cpu
 525         virtual int run(int clock)
 526         {
 527                 // when clock == -1, run one opecode
 528                 return (clock == -1 ? 1 : clock);
 529         }
 530         virtual void set_extra_clock(int clock) {}
 531         virtual int get_extra_clock()
 532         {
 533                 return 0;
 534         }
 535         virtual uint32_t get_pc()
 536         {
 537                 return 0;
 538         }
 539         virtual uint32_t get_next_pc()
 540         {
 541                 return 0;
 542         }
 543
 544         // bios
 545         virtual bool bios_call_far_i86(uint32_t PC, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
 546         {
 547                 return false;
 548         }
 549         virtual bool bios_int_i86(int intnum, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
 550         {
 551                 return false;
 552         }
 553         virtual bool bios_ret_z80(uint16_t PC, pair32_t* af, pair32_t* bc, pair32_t* de, pair32_t* hl, pair32_t* ix, pair32_t* iy, uint8_t* iff1)       {
 554                 return false;
 555         }
 556         // misc
 557         const _TCHAR *get_device_name(void)
 558         {
 559                 return (const _TCHAR *)this_device_name;
 560         }
 561
 562         // event manager
 563         DEVICE* event_manager;
 564
 565         virtual void set_context_event_manager(DEVICE* device)
 566         {
 567                 event_manager = device;
 568         }
 569         virtual int get_event_manager_id()
 570         {
 571                 if(event_manager == NULL) {
 572                         event_manager = vm->first_device->next_device;
 573                 }
 574                 return event_manager->this_device_id;
 575         }
 576         virtual bool is_primary_cpu(DEVICE* device)
 577         {
 578                 if(event_manager == NULL) {
 579                         event_manager = vm->first_device->next_device;
 580                 }
 581                 return event_manager->is_primary_cpu(device);
 582         }
 583         virtual void update_extra_event(int clock)
 584         {
 585                 if(event_manager == NULL) {
 586                         event_manager = vm->first_device->next_device;
 587                 }
 588                 event_manager->update_extra_event(clock);
 589         }
 590         virtual void register_event(DEVICE* device, int event_id, double usec, bool loop, int* register_id)
 591         {
 592                 if(event_manager == NULL) {
 593                         event_manager = vm->first_device->next_device;
 594                 }
 595                 event_manager->register_event(device, event_id, usec, loop, register_id);
 596         }
 597         virtual void register_event_by_clock(DEVICE* device, int event_id, uint64_t clock, bool loop, int* register_id)
 598         {
 599                 if(event_manager == NULL) {
 600                         event_manager = vm->first_device->next_device;
 601                 }
 602                 event_manager->register_event_by_clock(device, event_id, clock, loop, register_id);
 603         }
 604         virtual void cancel_event(DEVICE* device, int register_id)
 605         {
 606                 if(event_manager == NULL) {
 607                         event_manager = vm->first_device->next_device;
 608                 }
 609                 event_manager->cancel_event(device, register_id);
 610         }
 611         virtual void register_frame_event(DEVICE* device)
 612         {
 613                 if(event_manager == NULL) {
 614                         event_manager = vm->first_device->next_device;
 615                 }
 616                 event_manager->register_frame_event(device);
 617         }
 618         virtual void register_vline_event(DEVICE* device)
 619         {
 620                 if(event_manager == NULL) {
 621                         event_manager = vm->first_device->next_device;
 622                 }
 623                 event_manager->register_vline_event(device);
 624         }
 625         virtual uint32_t get_event_remaining_clock(int register_id)
 626         {
 627                 if(event_manager == NULL) {
 628                         event_manager = vm->first_device->next_device;
 629                 }
 630                 return event_manager->get_event_remaining_clock(register_id);
 631         }
 632         virtual double get_event_remaining_usec(int register_id)
 633         {
 634                 if(event_manager == NULL) {
 635                         event_manager = vm->first_device->next_device;
 636                 }
 637                 return event_manager->get_event_remaining_usec(register_id);
 638         }
 639         virtual uint32_t get_current_clock()
 640         {
 641                 if(event_manager == NULL) {
 642                         event_manager = vm->first_device->next_device;
 643                 }
 644                 return event_manager->get_current_clock();
 645         }
 646         virtual uint32_t get_passed_clock(uint32_t prev)
 647         {
 648                 if(event_manager == NULL) {
 649                         event_manager = vm->first_device->next_device;
 650                 }
 651                 return event_manager->get_passed_clock(prev);
 652         }
 653         virtual double get_passed_usec(uint32_t prev)
 654         {
 655                 if(event_manager == NULL) {
 656                         event_manager = vm->first_device->next_device;
 657                 }
 658                 return event_manager->get_passed_usec(prev);
 659         }
 660         virtual uint32_t get_passed_clock_since_vline()
 661         {
 662                 if(event_manager == NULL) {
 663                         event_manager = vm->first_device->next_device;
 664                 }
 665                 return event_manager->get_passed_clock_since_vline();
 666         }
 667         virtual double get_passed_usec_since_vline()
 668         {
 669                 if(event_manager == NULL) {
 670                         event_manager = vm->first_device->next_device;
 671                 }
 672                 return event_manager->get_passed_usec_since_vline();
 673         }
 674         virtual int get_cur_vline()
 675         {
 676                 if(event_manager == NULL) {
 677                         event_manager = vm->first_device->next_device;
 678                 }
 679                 return event_manager->get_cur_vline();
 680         }
 681         virtual int get_cur_vline_clocks()
 682         {
 683                 if(event_manager == NULL) {
 684                         event_manager = vm->first_device->next_device;
 685                 }
 686                 return event_manager->get_cur_vline_clocks();
 687         }
 688         virtual uint32_t get_cpu_pc(int index)
 689         {
 690                 if(event_manager == NULL) {
 691                         event_manager = vm->first_device->next_device;
 692                 }
 693                 return event_manager->get_cpu_pc(index);
 694         }
 695         virtual void request_skip_frames()
 696         {
 697                 if(event_manager == NULL) {
 698                         event_manager = vm->first_device->next_device;
 699                 }
 700                 event_manager->request_skip_frames();
 701         }
 702         virtual void set_frames_per_sec(double frames)
 703         {
 704                 if(event_manager == NULL) {
 705                         event_manager = vm->first_device->next_device;
 706                 }
 707                 event_manager->set_frames_per_sec(frames);
 708         }
 709         virtual void set_lines_per_frame(int lines)
 710         {
 711                 if(event_manager == NULL) {
 712                         event_manager = vm->first_device->next_device;
 713                 }
 714                 event_manager->set_lines_per_frame(lines);
 715         }
 716         virtual int get_lines_per_frame()
 717         {
 718                 if(event_manager == NULL) {
 719                         event_manager = vm->first_device->next_device;
 720                 }
 721                 return event_manager->get_lines_per_frame();
 722         }
 723         // Force reder sound immediately when device's status has changed.
 724         // You must call this after you changing registers (or enything).
 725         // If has problems, try set_realtime_render.
 726         // See mb8877.cpp and ym2203.cpp.
 727         // -- 20161010 K.O
 728         virtual void touch_sound(void)
 729         {
 730                 if(event_manager == NULL) {
 731                         event_manager = vm->first_device->next_device;
 732                 }
 733                 event_manager->touch_sound();
 734         }
 735         // Force render per 1 sample automatically.
 736         // See pcm1bit.cpp .
 737         // -- 20161010 K.O
 738         virtual void set_realtime_render(DEVICE* device, bool flag = true)
 739         {
 740                 if(event_manager == NULL) {
 741                         event_manager = vm->first_device->next_device;
 742                 }
 743                 if(device != event_manager) event_manager->set_realtime_render(device, flag);
 744         }
 745         virtual void set_realtime_render(bool flag)
 746         {
 747                 set_realtime_render(this, flag);
 748         }
 749         virtual void update_timing(int new_clocks, double new_frames_per_sec, int new_lines_per_frame) {}
 750
 751         // event callback
 752         virtual void event_callback(int event_id, int err) {}
 753         virtual void event_pre_frame() {}       // this event is to update timing settings
 754         virtual void event_frame() {}
 755         virtual void event_vline(int v, int clock) {}
 756         virtual void event_hsync(int v, int h, int clock) {}
 757
 758         // sound
 759         virtual void mix(int32_t* buffer, int cnt) {}
 760         virtual void set_volume(int ch, int decibel_l, int decibel_r) {} // +1 equals +0.5dB (same as fmgen)
 761         virtual void set_device_name(const _TCHAR *format, ...)
 762         {
 763                 if(format != NULL) {
 764                         va_list ap;
 765                         _TCHAR buffer[1024];
 766
 767                         va_start(ap, format);
 768                         my_vstprintf_s(buffer, 1024, format, ap);
 769                         va_end(ap);
 770
 771                         my_tcscpy_s(this_device_name, 128, buffer);
 772 #ifdef _USE_QT
 773                         emu->get_osd()->set_vm_node(this_device_id, buffer);
 774 #endif
 775                 }
 776         }
 777 /*
 778         These functions are used for debugging non-cpu device
 779         Insert debugger between standard read/write functions and these functions for checking breakpoints
 780
 781         void DEVICE::write_data8(uint32_t addr, uint32_t data)
 782         {
 783                 if(debugger != NULL && debugger->now_device_debugging) {
 784                         // debugger->mem = this;
 785                         // debugger->mem->write_via_debugger_data8(addr, data)
 786                         debugger->write_via_debugger_data8(addr, data);
 787                 } else {
 788                         this->write_via_debugger_data8(addr, data);
 789                 }
 790         }
 791         void DEVICE::write_via_debugger_data8(uint32_t addr, uint32_t data)
 792         {
 793                 // write memory
 794         }
 795 */
 796         virtual void write_via_debugger_data8(uint32_t addr, uint32_t data) {}
 797         virtual uint32_t read_via_debugger_data8(uint32_t addr)
 798         {
 799                 return 0xff;
 800         }
 801         virtual void write_via_debugger_data16(uint32_t addr, uint32_t data) {}
 802         virtual uint32_t read_via_debugger_data16(uint32_t addr)
 803         {
 804                 return 0xffff;
 805         }
 806         virtual void write_via_debugger_data32(uint32_t addr, uint32_t data) {}
 807         virtual uint32_t read_via_debugger_data32(uint32_t addr)
 808         {
 809                 return 0xffffffff;
 810         }
 811         virtual void write_via_debugger_data8w(uint32_t addr, uint32_t data, int* wait) {}
 812         virtual uint32_t read_via_debugger_data8w(uint32_t addr, int* wait)
 813         {
 814                 return 0xff;
 815         }
 816         virtual void write_via_debugger_data16w(uint32_t addr, uint32_t data, int* wait) {}
 817         virtual uint32_t read_via_debugger_data16w(uint32_t addr, int* wait)
 818         {
 819                 return 0xffff;
 820         }
 821         virtual void write_via_debugger_data32w(uint32_t addr, uint32_t data, int* wait) {}
 822         virtual uint32_t read_via_debugger_data32w(uint32_t addr, int* wait)
 823         {
 824                 return 0xffffffff;
 825         }
 826         virtual void write_via_debugger_io8(uint32_t addr, uint32_t data) {}
 827         virtual uint32_t read_via_debugger_io8(uint32_t addr)
 828         {
 829                 return 0xff;
 830         }
 831         virtual void write_via_debugger_io16(uint32_t addr, uint32_t data) {}
 832         virtual uint32_t read_via_debugger_io16(uint32_t addr)
 833         {
 834                 return 0xffff;
 835         }
 836         virtual void write_via_debugger_io32(uint32_t addr, uint32_t data) {}
 837         virtual uint32_t read_via_debugger_io32(uint32_t addr)
 838         {
 839                 return 0xffffffff;
 840         }
 841         virtual void write_via_debugger_io8w(uint32_t addr, uint32_t data, int* wait) {}
 842         virtual uint32_t read_via_debugger_io8w(uint32_t addr, int* wait)
 843         {
 844                 return 0xff;
 845         }
 846         virtual void write_via_debugger_io16w(uint32_t addr, uint32_t data, int* wait) {}
 847         virtual uint32_t read_via_debugger_io16w(uint32_t addr, int* wait)
 848         {
 849                 return 0xffff;
 850         }
 851         virtual void write_via_debugger_io32w(uint32_t addr, uint32_t data, int* wait) {}
 852         virtual uint32_t read_via_debugger_io32w(uint32_t addr, int* wait)
 853         {
 854                 return 0xffffffff;
 855         }
 856         virtual void out_debug_log(const char *fmt, ...)
 857         {
 858                 char strbuf[4096];
 859                 va_list ap;
 860
 861                 va_start(ap, fmt);
 862                 vsnprintf(strbuf, 4095, fmt, ap);
 863                 emu->out_debug_log("%s", strbuf);
 864                 va_end(ap);
 865         }
 866         virtual void force_out_debug_log(const char *fmt, ...)
 867         {
 868                 char strbuf[4096];
 869                 va_list ap;
 870
 871                 va_start(ap, fmt);
 872                 vsnprintf(strbuf, 4095, fmt, ap);
 873                 emu->force_out_debug_log("%s", strbuf);
 874                 va_end(ap);
 875         }
 876
 877 #ifdef USE_DEBUGGER
 878         // debugger
 879         virtual bool is_cpu()
 880         {
 881                 return false;
 882         }
 883         virtual bool is_debugger()
 884         {
 885                 return false;
 886         }
 887         virtual bool is_debugger_available()
 888         {
 889                 return false;
 890         }
 891         virtual void *get_debugger()
 892         {
 893                 return NULL;
 894         }
 895         virtual uint32_t get_debug_prog_addr_mask()
 896         {
 897                 return 0;
 898         }
 899         virtual uint32_t get_debug_data_addr_mask()
 900         {
 901                 return 0;
 902         }
 903         virtual uint64_t get_debug_data_addr_space()
 904         {
 905                 // override this function when memory space is not (2 << n)
 906                 return (uint64_t)get_debug_data_addr_mask() + 1;
 907         }
 908         virtual void write_debug_data8(uint32_t addr, uint32_t data)
 909         {
 910 //              write_data8(addr, data);
 911         }
 912         virtual uint32_t read_debug_data8(uint32_t addr)
 913         {
 914 //              return read_data8(addr);
 915                 return 0xff;
 916         }
 917         virtual void write_debug_data16(uint32_t addr, uint32_t data)
 918         {
 919                 write_debug_data8(addr, data & 0xff);
 920                 write_debug_data8(addr + 1, (data >> 8) & 0xff);
 921         }
 922         virtual uint32_t read_debug_data16(uint32_t addr)
 923         {
 924                 uint32_t val = read_debug_data8(addr);
 925                 val |= read_debug_data8(addr + 1) << 8;
 926                 return val;
 927         }
 928         virtual void write_debug_data32(uint32_t addr, uint32_t data)
 929         {
 930                 write_debug_data16(addr, data & 0xffff);
 931                 write_debug_data16(addr + 2, (data >> 16) & 0xffff);
 932         }
 933         virtual uint32_t read_debug_data32(uint32_t addr)
 934         {
 935                 uint32_t val = read_debug_data16(addr);
 936                 val |= read_debug_data16(addr + 2) << 16;
 937                 return val;
 938         }
 939         virtual void write_debug_io8(uint32_t addr, uint32_t data)
 940         {
 941 //              write_io8(addr, data);
 942         }
 943         virtual uint32_t read_debug_io8(uint32_t addr)
 944         {
 945 //              return read_io8(addr);
 946                 return 0xff;
 947         }
 948         virtual void write_debug_io16(uint32_t addr, uint32_t data)
 949         {
 950                 write_debug_io8(addr, data & 0xff);
 951                 write_debug_io8(addr + 1, (data >> 8) & 0xff);
 952         }
 953         virtual uint32_t read_debug_io16(uint32_t addr)
 954         {
 955                 uint32_t val = read_debug_io8(addr);
 956                 val |= read_debug_io8(addr + 1) << 8;
 957                 return val;
 958         }
 959         virtual void write_debug_io32(uint32_t addr, uint32_t data)
 960         {
 961                 write_debug_io16(addr, data & 0xffff);
 962                 write_debug_io16(addr + 2, (data >> 16) & 0xffff);
 963         }
 964         virtual uint32_t read_debug_io32(uint32_t addr)
 965         {
 966                 uint32_t val = read_debug_io16(addr);
 967                 val |= read_debug_io16(addr + 2) << 16;
 968                 return val;
 969         }
 970         virtual bool write_debug_reg(const _TCHAR *reg, uint32_t data)
 971         {
 972                 return false;
 973         }
 974         virtual uint32_t read_debug_reg(const _TCHAR *reg)
 975         {
 976                 return 0;
 977         }
 978         virtual bool get_debug_regs_info(_TCHAR *buffer, size_t buffer_len)
 979         {
 980                 return false;
 981         }
 982         virtual int debug_dasm(uint32_t pc, _TCHAR *buffer, size_t buffer_len)
 983         {
 984                 return 0;
 985         }
 986 #endif
 987         _TCHAR this_device_name[128];
 988
 989         DEVICE* prev_device;
 990         DEVICE* next_device;
 991         int this_device_id;
 992 };
 993 #endif // USE_SHARED_DLL
 994
 995 #endif