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 #define SIG_CPU_ADDRESS_DIRTY   107
  37 #define SIG_CPU_TOTAL_CYCLE_LO  108
  38 #define SIG_CPU_TOTAL_CYCLE_HI  109
  39 #define SIG_CPU_WAIT_FACTOR             110
  40
  41 #define SIG_PRINTER_DATA        201
  42 #define SIG_PRINTER_STROBE      202
  43 #define SIG_PRINTER_RESET       203
  44 #define SIG_PRINTER_BUSY        204
  45 #define SIG_PRINTER_ACK         205
  46 #define SIG_PRINTER_SELECT      206
  47
  48 #define SIG_SCSI_DAT            301
  49 #define SIG_SCSI_BSY            302
  50 #define SIG_SCSI_CD             303
  51 #define SIG_SCSI_IO             304
  52 #define SIG_SCSI_MSG            305
  53 #define SIG_SCSI_REQ            306
  54 #define SIG_SCSI_SEL            307
  55 #define SIG_SCSI_ATN            308
  56 #define SIG_SCSI_ACK            309
  57 #define SIG_SCSI_RST            310
  58
  59 #if defined(_USE_QT)
  60 class CSP_Logger;
  61 extern CSP_Logger *csp_logger;
  62
  63 #endif
  64 class DEVICE
  65 {
  66 protected:
  67         VM_TEMPLATE* vm;
  68         EMU* emu;
  69         OSD* osd;
  70 #if defined(_USE_QT)
  71         CSP_Logger *p_logger;
  72 #endif
  73 public:
  74         DEVICE(VM_TEMPLATE* parent_vm, EMU* parent_emu) : vm(parent_vm), emu(parent_emu)
  75         {
  76 #if defined(_USE_QT)
  77                 osd = emu->get_osd();
  78                 p_logger = csp_logger;
  79 #else
  80                 osd = NULL;
  81 #endif
  82                 memset(this_device_name, 0x00, sizeof(this_device_name));
  83                 strncpy(this_device_name, "Base Device", 128 - 1);
  84                 prev_device = vm->last_device;
  85                 next_device = NULL;
  86                 if(vm->first_device == NULL) {
  87                         // this is the first device
  88                         vm->first_device = this;
  89                         this_device_id = 0;
  90                 } else {
  91                         // this is not the first device
  92                         vm->last_device->next_device = this;
  93                         this_device_id = vm->last_device->this_device_id + 1;
  94                 }
  95                 vm->last_device = this;
  96                 // primary event manager
  97                 event_manager = NULL;
  98         }
  99         //ToDo: Will implement real destructor per real classes and below destructor decl. with "virtual".
 100         // This makes warning:
 101         //"deleting object of polymorphic class type 'DEVICE' which has non-virtual
 102         // destructor might cause undefined behavior [-Wdelete-non-virtual-dtor]".
 103         ~DEVICE(void) {}
 104
 105         virtual void initialize() {     /* osd = emu->get_osd(); */ /* Initializing VM must be after initializing OSD. */ }
 106 #if defined(_USE_QT)
 107         virtual void release() {
 108         }
 109 #else
 110         virtual void release() {}
 111 #endif
 112         // Sound input functions
 113         virtual void clear_sound_in_source(int bank) {
 114                 if(event_manager == NULL) {
 115                         event_manager = vm->first_device->next_device;
 116                 }
 117                 event_manager->clear_sound_in_source(bank);
 118         }
 119         // this function may be before (or after) initialize().
 120         virtual int add_sound_in_source(int rate, int samples, int channels) {
 121                 if(event_manager == NULL) return -1;
 122                 return event_manager->add_sound_in_source(rate, samples, channels);
 123         }
 124         // this function may be before (or after) initialize().
 125         virtual int release_sound_in_source(int bank) {
 126                 if(event_manager == NULL) return -1;
 127                 return event_manager->release_sound_in_source(bank);
 128         }
 129
 130         virtual bool is_sound_in_source_exists(int bank) {
 131                 if(event_manager == NULL) {
 132                         event_manager = vm->first_device->next_device;
 133                 }
 134                 return event_manager->is_sound_in_source_exists(bank);
 135         }
 136         virtual int increment_sound_in_passed_data(int bank, double passed_usec) {
 137                 if(event_manager == NULL) {
 138                         return 0;
 139                 }
 140                 return event_manager->increment_sound_in_passed_data(bank, passed_usec);
 141         }
 142         virtual int get_sound_in_buffers_count() {
 143                 if(event_manager == NULL) {
 144                         event_manager = vm->first_device->next_device;
 145                 }
 146                 return event_manager->get_sound_in_buffers_count();
 147         }
 148         virtual int get_sound_in_samples(int bank) {
 149                 if(event_manager == NULL) {
 150                         event_manager = vm->first_device->next_device;
 151                 }
 152                 return event_manager->get_sound_in_samples(bank);
 153         }
 154         virtual int get_sound_in_rate(int bank) {
 155                 if(event_manager == NULL) {
 156                         event_manager = vm->first_device->next_device;
 157                 }
 158                 return event_manager->get_sound_in_rate(bank);
 159         }
 160         virtual int get_sound_in_channels(int bank) {
 161                 if(event_manager == NULL) {
 162                         event_manager = vm->first_device->next_device;
 163                 }
 164                 return event_manager->get_sound_in_channels(bank);
 165         }
 166         // this function may be before (or after) initialize().
 167         virtual int16_t* get_sound_in_buf_ptr(int bank) {
 168                 if(event_manager == NULL) return NULL;
 169                 return event_manager->get_sound_in_buf_ptr(bank);
 170         }
 171         virtual int write_sound_in_buffer(int bank, int32_t* src, int samples) {
 172                 if(event_manager == NULL) {
 173                         event_manager = vm->first_device->next_device;
 174                 }
 175                 return event_manager->write_sound_in_buffer(bank, src, samples);
 176
 177         }
 178         // Add sampled values to sample buffer;value may be -32768 to +32767.
 179         // this function may be before (or after) initialize().
 180         virtual int get_sound_in_latest_data(int bank, int32_t* dst, int expect_channels) {
 181                 if(event_manager == NULL) return 0;
 182                 return event_manager->get_sound_in_latest_data(bank, dst, expect_channels);
 183         }
 184         virtual int get_sound_in_data(int bank, int32_t* dst, int expect_samples, int expect_rate, int expect_channels) {
 185                 if(event_manager == NULL) return -1;
 186                 return event_manager->get_sound_in_data(bank, dst, expect_samples, expect_rate, expect_channels);
 187         }
 188
 189         virtual void set_high_pass_filter_freq(int freq, double quality) { } // If freq < 0 disable HPF.
 190         virtual void set_low_pass_filter_freq(int freq, double quality) { }  // If freq <= 0 disable LPF.
 191
 192         virtual void update_config() {}
 193         virtual void save_state(FILEIO* state_fio) {}
 194         virtual bool load_state(FILEIO* state_fio)
 195         {
 196                 return true;
 197         }
 198         // control
 199         virtual void reset() {}
 200         virtual void special_reset()
 201         {
 202                 reset();
 203         }
 204         virtual bool process_state(FILEIO* state_fio, bool loading)
 205         {
 206                 if(loading) {
 207                         return load_state(state_fio);
 208                 } else {
 209                         save_state(state_fio);
 210                         return true;
 211                 }
 212         }
 213
 214         // NOTE: the virtual bus interface functions for 16/32bit access invite the cpu is little endian.
 215         // if the cpu is big endian, you need to implement them in the virtual machine memory/io classes.
 216         virtual uint32_t __FASTCALL translate_address(int segment, uint32_t offset) { /* offset must be numeric, not value */ return offset; }
 217
 218         // memory bus
 219         virtual void __FASTCALL write_data8(uint32_t addr, uint32_t data) {}
 220         virtual uint32_t __FASTCALL read_data8(uint32_t addr)
 221         {
 222                 return 0xff;
 223         }
 224         virtual void __FASTCALL write_data16(uint32_t addr, uint32_t data)
 225         {
 226                 write_data8(addr, data & 0xff);
 227                 write_data8(addr + 1, (data >> 8) & 0xff);
 228         }
 229         virtual uint32_t __FASTCALL read_data16(uint32_t addr)
 230         {
 231                 uint32_t val = read_data8(addr);
 232                 val |= read_data8(addr + 1) << 8;
 233                 return val;
 234         }
 235         virtual void __FASTCALL write_data32(uint32_t addr, uint32_t data)
 236         {
 237                 write_data16(addr, data & 0xffff);
 238                 write_data16(addr + 2, (data >> 16) & 0xffff);
 239         }
 240         virtual uint32_t __FASTCALL read_data32(uint32_t addr)
 241         {
 242                 uint32_t val = read_data16(addr);
 243                 val |= read_data16(addr + 2) << 16;
 244                 return val;
 245         }
 246         virtual void __FASTCALL write_data8w(uint32_t addr, uint32_t data, int* wait)
 247         {
 248                 *wait = 0;
 249                 write_data8(addr, data);
 250         }
 251         virtual uint32_t __FASTCALL read_data8w(uint32_t addr, int* wait)
 252         {
 253                 *wait = 0;
 254                 return read_data8(addr);
 255         }
 256         virtual void __FASTCALL write_data16w(uint32_t addr, uint32_t data, int* wait)
 257         {
 258                 int wait_l, wait_h;
 259                 write_data8w(addr, data & 0xff, &wait_l);
 260                 write_data8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 261                 *wait = wait_l + wait_h;
 262         }
 263         virtual uint32_t __FASTCALL read_data16w(uint32_t addr, int* wait)
 264         {
 265                 int wait_l, wait_h;
 266                 uint32_t val = read_data8w(addr, &wait_l);
 267                 val |= read_data8w(addr + 1, &wait_h) << 8;
 268                 *wait = wait_l + wait_h;
 269                 return val;
 270         }
 271         virtual void __FASTCALL write_data32w(uint32_t addr, uint32_t data, int* wait)
 272         {
 273                 int wait_l, wait_h;
 274                 write_data16w(addr, data & 0xffff, &wait_l);
 275                 write_data16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 276                 *wait = wait_l + wait_h;
 277         }
 278         virtual uint32_t __FASTCALL read_data32w(uint32_t addr, int* wait)
 279         {
 280                 int wait_l, wait_h;
 281                 uint32_t val = read_data16w(addr, &wait_l);
 282                 val |= read_data16w(addr + 2, &wait_h) << 16;
 283                 *wait = wait_l + wait_h;
 284                 return val;
 285         }
 286         virtual uint32_t __FASTCALL fetch_op(uint32_t addr, int *wait)
 287         {
 288                 return read_data8w(addr, wait);
 289         }
 290         virtual void __FASTCALL write_dma_data8(uint32_t addr, uint32_t data)
 291         {
 292                 write_data8(addr, data);
 293         }
 294         virtual uint32_t __FASTCALL read_dma_data8(uint32_t addr)
 295         {
 296                 return read_data8(addr);
 297         }
 298         virtual void __FASTCALL write_dma_data16(uint32_t addr, uint32_t data)
 299         {
 300                 write_data16(addr, data);
 301         }
 302         virtual uint32_t __FASTCALL read_dma_data16(uint32_t addr)
 303         {
 304                 return read_data16(addr);
 305         }
 306         virtual void __FASTCALL write_dma_data32(uint32_t addr, uint32_t data)
 307         {
 308                 write_data32(addr, data);
 309         }
 310         virtual uint32_t __FASTCALL read_dma_data32(uint32_t addr)
 311         {
 312                 return read_data32(addr);
 313         }
 314         virtual void __FASTCALL write_dma_data8w(uint32_t addr, uint32_t data, int* wait)
 315         {
 316                 write_data8w(addr, data, wait);
 317         }
 318         virtual uint32_t __FASTCALL read_dma_data8w(uint32_t addr, int* wait)
 319         {
 320                 return read_data8w(addr, wait);
 321         }
 322         virtual void __FASTCALL write_dma_data16w(uint32_t addr, uint32_t data, int* wait)
 323         {
 324                 write_data16w(addr, data, wait);
 325         }
 326         virtual uint32_t __FASTCALL read_dma_data16w(uint32_t addr, int* wait)
 327         {
 328                 return read_data16w(addr, wait);
 329         }
 330         virtual void __FASTCALL write_dma_data32w(uint32_t addr, uint32_t data, int* wait)
 331         {
 332                 write_data32w(addr, data, wait);
 333         }
 334         virtual uint32_t __FASTCALL read_dma_data32w(uint32_t addr, int* wait)
 335         {
 336                 return read_data32w(addr, wait);
 337         }
 338
 339         // i/o bus
 340         virtual void __FASTCALL write_io8(uint32_t addr, uint32_t data) {}
 341         virtual uint32_t __FASTCALL read_io8(uint32_t addr)
 342         {
 343 #ifdef IOBUS_RETURN_ADDR
 344                 return (addr & 1 ? addr >> 8 : addr) & 0xff;
 345 #else
 346                 return 0xff;
 347 #endif
 348         }
 349         virtual void __FASTCALL write_io16(uint32_t addr, uint32_t data)
 350         {
 351                 write_io8(addr, data & 0xff);
 352                 write_io8(addr + 1, (data >> 8) & 0xff);
 353         }
 354         virtual uint32_t __FASTCALL read_io16(uint32_t addr)
 355         {
 356                 uint32_t val = read_io8(addr);
 357                 val |= read_io8(addr + 1) << 8;
 358                 return val;
 359         }
 360         virtual void __FASTCALL write_io32(uint32_t addr, uint32_t data)
 361         {
 362                 write_io16(addr, data & 0xffff);
 363                 write_io16(addr + 2, (data >> 16) & 0xffff);
 364         }
 365         virtual uint32_t __FASTCALL read_io32(uint32_t addr)
 366         {
 367                 uint32_t val = read_io16(addr);
 368                 val |= read_io16(addr + 2) << 16;
 369                 return val;
 370         }
 371         virtual void __FASTCALL write_io8w(uint32_t addr, uint32_t data, int* wait)
 372         {
 373                 *wait = 0;
 374                 write_io8(addr, data);
 375         }
 376         virtual uint32_t __FASTCALL read_io8w(uint32_t addr, int* wait)
 377         {
 378                 *wait = 0;
 379                 return read_io8(addr);
 380         }
 381         virtual void __FASTCALL write_io16w(uint32_t addr, uint32_t data, int* wait)
 382         {
 383                 int wait_l, wait_h;
 384                 write_io8w(addr, data & 0xff, &wait_l);
 385                 write_io8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 386                 *wait = wait_l + wait_h;
 387         }
 388         virtual uint32_t __FASTCALL read_io16w(uint32_t addr, int* wait)
 389         {
 390                 int wait_l, wait_h;
 391                 uint32_t val = read_io8w(addr, &wait_l);
 392                 val |= read_io8w(addr + 1, &wait_h) << 8;
 393                 *wait = wait_l + wait_h;
 394                 return val;
 395         }
 396         virtual void __FASTCALL write_io32w(uint32_t addr, uint32_t data, int* wait)
 397         {
 398                 int wait_l, wait_h;
 399                 write_io16w(addr, data & 0xffff, &wait_l);
 400                 write_io16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 401                 *wait = wait_l + wait_h;
 402         }
 403         virtual uint32_t __FASTCALL read_io32w(uint32_t addr, int* wait)
 404         {
 405                 int wait_l, wait_h;
 406                 uint32_t val = read_io16w(addr, &wait_l);
 407                 val |= read_io16w(addr + 2, &wait_h) << 16;
 408                 *wait = wait_l + wait_h;
 409                 return val;
 410         }
 411         virtual void __FASTCALL write_dma_io8(uint32_t addr, uint32_t data)
 412         {
 413                 write_io8(addr, data);
 414         }
 415         virtual uint32_t __FASTCALL read_dma_io8(uint32_t addr)
 416         {
 417                 return read_io8(addr);
 418         }
 419         virtual void __FASTCALL write_dma_io16(uint32_t addr, uint32_t data)
 420         {
 421                 write_io16(addr, data);
 422         }
 423         virtual uint32_t __FASTCALL read_dma_io16(uint32_t addr)
 424         {
 425                 return read_io16(addr);
 426         }
 427         virtual void __FASTCALL write_dma_io32(uint32_t addr, uint32_t data)
 428         {
 429                 write_io32(addr, data);
 430         }
 431         virtual uint32_t __FASTCALL read_dma_io32(uint32_t addr)
 432         {
 433                 return read_io32(addr);
 434         }
 435         virtual void __FASTCALL write_dma_io8w(uint32_t addr, uint32_t data, int* wait)
 436         {
 437                 write_io8w(addr, data, wait);
 438         }
 439         virtual uint32_t __FASTCALL read_dma_io8w(uint32_t addr, int* wait)
 440         {
 441                 return read_io8w(addr, wait);
 442         }
 443         virtual void __FASTCALL write_dma_io16w(uint32_t addr, uint32_t data, int* wait)
 444         {
 445                 write_io16w(addr, data, wait);
 446         }
 447         virtual uint32_t __FASTCALL read_dma_io16w(uint32_t addr, int* wait)
 448         {
 449                 return read_io16w(addr, wait);
 450         }
 451         virtual void __FASTCALL write_dma_io32w(uint32_t addr, uint32_t data, int* wait)
 452         {
 453                 write_io32w(addr, data, wait);
 454         }
 455         virtual uint32_t __FASTCALL read_dma_io32w(uint32_t addr, int* wait)
 456         {
 457                 return read_io32w(addr, wait);
 458         }
 459
 460         // memory mapped i/o
 461         virtual void __FASTCALL write_memory_mapped_io8(uint32_t addr, uint32_t data)
 462         {
 463                 write_io8(addr, data);
 464         }
 465         virtual uint32_t __FASTCALL read_memory_mapped_io8(uint32_t addr)
 466         {
 467                 return read_io8(addr);
 468         }
 469         virtual void __FASTCALL write_memory_mapped_io16(uint32_t addr, uint32_t data)
 470         {
 471                 write_memory_mapped_io8(addr, data & 0xff);
 472                 write_memory_mapped_io8(addr + 1, (data >> 8) & 0xff);
 473         }
 474         virtual uint32_t __FASTCALL read_memory_mapped_io16(uint32_t addr)
 475         {
 476                 uint32_t val = read_memory_mapped_io8(addr);
 477                 val |= read_memory_mapped_io8(addr + 1) << 8;
 478                 return val;
 479         }
 480         virtual void __FASTCALL write_memory_mapped_io32(uint32_t addr, uint32_t data)
 481         {
 482                 write_memory_mapped_io16(addr, data & 0xffff);
 483                 write_memory_mapped_io16(addr + 2, (data >> 16) & 0xffff);
 484         }
 485         virtual uint32_t __FASTCALL read_memory_mapped_io32(uint32_t addr)
 486         {
 487                 uint32_t val = read_memory_mapped_io16(addr);
 488                 val |= read_memory_mapped_io16(addr + 2) << 16;
 489                 return val;
 490         }
 491         virtual void __FASTCALL write_memory_mapped_io8w(uint32_t addr, uint32_t data, int* wait)
 492         {
 493                 *wait = 0;
 494                 write_memory_mapped_io8(addr, data);
 495         }
 496         virtual uint32_t __FASTCALL read_memory_mapped_io8w(uint32_t addr, int* wait)
 497         {
 498                 *wait = 0;
 499                 return read_memory_mapped_io8(addr);
 500         }
 501         virtual void __FASTCALL write_memory_mapped_io16w(uint32_t addr, uint32_t data, int* wait)
 502         {
 503                 int wait_l, wait_h;
 504                 write_memory_mapped_io8w(addr, data & 0xff, &wait_l);
 505                 write_memory_mapped_io8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 506                 *wait = wait_l + wait_h;
 507         }
 508         virtual uint32_t __FASTCALL  read_memory_mapped_io16w(uint32_t addr, int* wait)
 509         {
 510                 int wait_l, wait_h;
 511                 uint32_t val = read_memory_mapped_io8w(addr, &wait_l);
 512                 val |= read_memory_mapped_io8w(addr + 1, &wait_h) << 8;
 513                 *wait = wait_l + wait_h;
 514                 return val;
 515         }
 516         virtual void __FASTCALL write_memory_mapped_io32w(uint32_t addr, uint32_t data, int* wait)
 517         {
 518                 int wait_l, wait_h;
 519                 write_memory_mapped_io16w(addr, data & 0xffff, &wait_l);
 520                 write_memory_mapped_io16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 521                 *wait = wait_l + wait_h;
 522         }
 523         virtual uint32_t __FASTCALL read_memory_mapped_io32w(uint32_t addr, int* wait)
 524         {
 525                 int wait_l, wait_h;
 526                 uint32_t val = read_memory_mapped_io16w(addr, &wait_l);
 527                 val |= read_memory_mapped_io16w(addr + 2, &wait_h) << 16;
 528                 *wait = wait_l + wait_h;
 529                 return val;
 530         }
 531
 532         // device to device
 533         typedef struct {
 534                 DEVICE *device;
 535                 int id;
 536                 uint32_t mask;
 537                 int shift;
 538         } output_t;
 539
 540         typedef struct {
 541                 int count;
 542                 output_t item[MAX_OUTPUT];
 543         } outputs_t;
 544
 545         virtual void initialize_output_signals(outputs_t *items)
 546         {
 547                 items->count = 0;
 548         }
 549         virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask, int shift)
 550         {
 551                 int c = items->count++;
 552                 items->item[c].device = device;
 553                 items->item[c].id = id;
 554                 items->item[c].mask = mask;
 555                 items->item[c].shift = shift;
 556         }
 557         virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask)
 558         {
 559                 int c = items->count++;
 560                 items->item[c].device = device;
 561                 items->item[c].id = id;
 562                 items->item[c].mask = mask;
 563                 items->item[c].shift = 0;
 564         }
 565         virtual void __FASTCALL write_signals(outputs_t *items, uint32_t data)
 566         {
 567                 for(int i = 0; i < items->count; i++) {
 568                         output_t *item = &items->item[i];
 569                         int shift = item->shift;
 570                         uint32_t val = (shift < 0) ? (data >> (-shift)) : (data << shift);
 571                         uint32_t mask = (shift < 0) ? (item->mask >> (-shift)) : (item->mask << shift);
 572                         item->device->write_signal(item->id, val, mask);
 573                 }
 574         };
 575         virtual void __FASTCALL write_signal(int id, uint32_t data, uint32_t mask) {}
 576         virtual uint32_t __FASTCALL read_signal(int ch)
 577         {
 578                 return 0;
 579         }
 580
 581         // z80 daisy chain
 582         virtual void set_context_intr(DEVICE* device, uint32_t bit) {}
 583         virtual void set_context_child(DEVICE* device) {}
 584         virtual DEVICE *get_context_child()
 585         {
 586                 return NULL;
 587         }
 588
 589         // interrupt device to device
 590         virtual void set_intr_iei(bool val) {}
 591
 592         // interrupt device to cpu
 593         virtual void set_intr_line(bool line, bool pending, uint32_t bit) {}
 594
 595         // interrupt cpu to device
 596         virtual uint32_t get_intr_ack()
 597         {
 598                 return 0xff;
 599         }
 600         virtual void notify_intr_reti() {}
 601         virtual void notify_intr_ei() {}
 602
 603         // dma
 604         virtual void __FASTCALL do_dma() { }
 605
 606         // cpu
 607         virtual int __FASTCALL run(int clock)
 608         {
 609                 // when clock == -1, run one opecode
 610                 return (clock == -1 ? 1 : clock);
 611         }
 612         virtual void set_extra_clock(int clock) {}
 613         virtual int get_extra_clock()
 614         {
 615                 return 0;
 616         }
 617         virtual uint32_t get_pc()
 618         {
 619                 return 0;
 620         }
 621         virtual uint32_t get_next_pc()
 622         {
 623                 return 0;
 624         }
 625
 626         // bios
 627         virtual bool bios_call_far_i86(uint32_t PC, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag, int* cycles, uint64_t* total_cycles)
 628         {
 629                 return false;
 630         }
 631         virtual bool bios_int_i86(int intnum, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag, int* cycles, uint64_t* total_cycles)
 632         {
 633                 return false;
 634         }
 635         virtual bool bios_call_far_ia32(uint32_t PC, uint32_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag, int* cycles, uint64_t* total_cycles)
 636         {
 637                 return false;
 638         }
 639         virtual bool bios_int_ia32(int intnum, uint32_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag, int* cycles, uint64_t* total_cycles)
 640         {
 641                 return false;
 642         }
 643         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)       {
 644                 return false;
 645         }
 646         virtual bool __FASTCALL address_translate(int space, int intention, uint64_t &taddress) { return true; /* If not present, always succeeded.*/ }
 647         // misc
 648         const _TCHAR *get_device_name(void)
 649         {
 650                 return (const _TCHAR *)this_device_name;
 651         }
 652
 653         // event manager
 654         DEVICE* event_manager;
 655
 656         virtual void set_context_event_manager(DEVICE* device)
 657         {
 658                 event_manager = device;
 659         }
 660         virtual int get_event_manager_id()
 661         {
 662                 if(event_manager == NULL) {
 663                         event_manager = vm->first_device->next_device;
 664                 }
 665                 return event_manager->this_device_id;
 666         }
 667         virtual bool is_primary_cpu(DEVICE* device)
 668         {
 669                 if(event_manager == NULL) {
 670                         event_manager = vm->first_device->next_device;
 671                 }
 672                 return event_manager->is_primary_cpu(device);
 673         }
 674         virtual void update_extra_event(int clock)
 675         {
 676                 if(event_manager == NULL) {
 677                         event_manager = vm->first_device->next_device;
 678                 }
 679                 event_manager->update_extra_event(clock);
 680         }
 681         virtual void register_event(DEVICE* device, int event_id, double usec, bool loop, int* register_id)
 682         {
 683                 if(event_manager == NULL) {
 684                         event_manager = vm->first_device->next_device;
 685                 }
 686                 event_manager->register_event(device, event_id, usec, loop, register_id);
 687         }
 688         virtual void register_event_by_clock(DEVICE* device, int event_id, uint64_t clock, bool loop, int* register_id)
 689         {
 690                 if(event_manager == NULL) {
 691                         event_manager = vm->first_device->next_device;
 692                 }
 693                 event_manager->register_event_by_clock(device, event_id, clock, loop, register_id);
 694         }
 695         virtual void cancel_event(DEVICE* device, int register_id)
 696         {
 697                 if(event_manager == NULL) {
 698                         event_manager = vm->first_device->next_device;
 699                 }
 700                 event_manager->cancel_event(device, register_id);
 701         }
 702         virtual void register_frame_event(DEVICE* device)
 703         {
 704                 if(event_manager == NULL) {
 705                         event_manager = vm->first_device->next_device;
 706                 }
 707                 event_manager->register_frame_event(device);
 708         }
 709         virtual void register_vline_event(DEVICE* device)
 710         {
 711                 if(event_manager == NULL) {
 712                         event_manager = vm->first_device->next_device;
 713                 }
 714                 event_manager->register_vline_event(device);
 715         }
 716         virtual uint32_t get_event_remaining_clock(int register_id)
 717         {
 718                 if(event_manager == NULL) {
 719                         event_manager = vm->first_device->next_device;
 720                 }
 721                 return event_manager->get_event_remaining_clock(register_id);
 722         }
 723         virtual double get_event_remaining_usec(int register_id)
 724         {
 725                 if(event_manager == NULL) {
 726                         event_manager = vm->first_device->next_device;
 727                 }
 728                 return event_manager->get_event_remaining_usec(register_id);
 729         }
 730         virtual uint32_t get_current_clock()
 731         {
 732                 if(event_manager == NULL) {
 733                         event_manager = vm->first_device->next_device;
 734                 }
 735                 return event_manager->get_current_clock();
 736         }
 737         virtual uint32_t get_passed_clock(uint32_t prev)
 738         {
 739                 if(event_manager == NULL) {
 740                         event_manager = vm->first_device->next_device;
 741                 }
 742                 return event_manager->get_passed_clock(prev);
 743         }
 744         virtual double get_passed_usec(uint32_t prev)
 745         {
 746                 if(event_manager == NULL) {
 747                         event_manager = vm->first_device->next_device;
 748                 }
 749                 return event_manager->get_passed_usec(prev);
 750         }
 751         virtual uint32_t get_passed_clock_since_vline()
 752         {
 753                 if(event_manager == NULL) {
 754                         event_manager = vm->first_device->next_device;
 755                 }
 756                 return event_manager->get_passed_clock_since_vline();
 757         }
 758         virtual double get_passed_usec_since_vline()
 759         {
 760                 if(event_manager == NULL) {
 761                         event_manager = vm->first_device->next_device;
 762                 }
 763                 return event_manager->get_passed_usec_since_vline();
 764         }
 765         virtual int get_cur_vline()
 766         {
 767                 if(event_manager == NULL) {
 768                         event_manager = vm->first_device->next_device;
 769                 }
 770                 return event_manager->get_cur_vline();
 771         }
 772         virtual int get_cur_vline_clocks()
 773         {
 774                 if(event_manager == NULL) {
 775                         event_manager = vm->first_device->next_device;
 776                 }
 777                 return event_manager->get_cur_vline_clocks();
 778         }
 779         virtual uint32_t get_cpu_pc(int index)
 780         {
 781                 if(event_manager == NULL) {
 782                         event_manager = vm->first_device->next_device;
 783                 }
 784                 return event_manager->get_cpu_pc(index);
 785         }
 786         virtual uint64_t get_current_clock_uint64()
 787         {
 788                 if(event_manager == NULL) {
 789                         event_manager = vm->first_device->next_device;
 790                 }
 791                 return event_manager->get_current_clock_uint64();
 792         }
 793         virtual uint32_t get_cpu_clock(int index)
 794         {
 795                 if(event_manager == NULL) {
 796                         event_manager = vm->first_device->next_device;
 797                 }
 798                 return event_manager->get_cpu_clock(index);
 799         }
 800         virtual void request_skip_frames()
 801         {
 802                 if(event_manager == NULL) {
 803                         event_manager = vm->first_device->next_device;
 804                 }
 805                 event_manager->request_skip_frames();
 806         }
 807         virtual void set_frames_per_sec(double frames)
 808         {
 809                 if(event_manager == NULL) {
 810                         event_manager = vm->first_device->next_device;
 811                 }
 812                 event_manager->set_frames_per_sec(frames);
 813         }
 814         virtual void set_lines_per_frame(int lines)
 815         {
 816                 if(event_manager == NULL) {
 817                         event_manager = vm->first_device->next_device;
 818                 }
 819                 event_manager->set_lines_per_frame(lines);
 820         }
 821         virtual int get_lines_per_frame()
 822         {
 823                 if(event_manager == NULL) {
 824                         event_manager = vm->first_device->next_device;
 825                 }
 826                 return event_manager->get_lines_per_frame();
 827         }
 828         // Force reder sound immediately when device's status has changed.
 829         // You must call this after you changing registers (or enything).
 830         // If has problems, try set_realtime_render.
 831         // See mb8877.cpp and ym2203.cpp.
 832         // -- 20161010 K.O
 833         virtual void touch_sound(void)
 834         {
 835                 if(event_manager == NULL) {
 836                         event_manager = vm->first_device->next_device;
 837                 }
 838                 event_manager->touch_sound();
 839         }
 840         // Force render per 1 sample automatically.
 841         // See pcm1bit.cpp .
 842         // -- 20161010 K.O
 843         virtual void set_realtime_render(DEVICE* device, bool flag = true)
 844         {
 845                 if(event_manager == NULL) {
 846                         event_manager = vm->first_device->next_device;
 847                 }
 848                 if(device != event_manager) event_manager->set_realtime_render(device, flag);
 849         }
 850         virtual void set_realtime_render(bool flag)
 851         {
 852                 set_realtime_render(this, flag);
 853         }
 854         virtual void update_timing(int new_clocks, double new_frames_per_sec, int new_lines_per_frame) {}
 855
 856         // event callback
 857         virtual void event_callback(int event_id, int err) {}
 858         virtual void event_pre_frame() {}       // this event is to update timing settings
 859         virtual void event_frame() {}
 860         virtual void event_vline(int v, int clock) {}
 861         virtual void event_hsync(int v, int h, int clock) {}
 862
 863         // sound
 864         virtual void mix(int32_t* buffer, int cnt) {}
 865         virtual void set_volume(int ch, int decibel_l, int decibel_r) {} // +1 equals +0.5dB (same as fmgen)
 866         virtual void set_device_name(const _TCHAR *format, ...)
 867         {
 868                 if(format != NULL) {
 869                         va_list ap;
 870                         _TCHAR buffer[1024];
 871
 872                         va_start(ap, format);
 873                         my_vstprintf_s(buffer, 1024, format, ap);
 874                         va_end(ap);
 875
 876                         my_tcscpy_s(this_device_name, 128, buffer);
 877 #ifdef _USE_QT
 878                         emu->get_osd()->set_vm_node(this_device_id, buffer);
 879 #endif
 880                 }
 881         }
 882 /*
 883         These functions are used for debugging non-cpu device
 884         Insert debugger between standard read/write functions and these functions for checking breakpoints
 885
 886         void DEVICE::write_data8(uint32_t addr, uint32_t data)
 887         {
 888                 if(debugger != NULL && debugger->now_device_debugging) {
 889                         // debugger->mem = this;
 890                         // debugger->mem->write_via_debugger_data8(addr, data)
 891                         debugger->write_via_debugger_data8(addr, data);
 892                 } else {
 893                         this->write_via_debugger_data8(addr, data);
 894                 }
 895         }
 896         void DEVICE::write_via_debugger_data8(uint32_t addr, uint32_t data)
 897         {
 898                 // write memory
 899         }
 900 */
 901         virtual void __FASTCALL write_via_debugger_data8(uint32_t addr, uint32_t data) {}
 902         virtual uint32_t __FASTCALL read_via_debugger_data8(uint32_t addr)
 903         {
 904                 return 0xff;
 905         }
 906         virtual void __FASTCALL write_via_debugger_data16(uint32_t addr, uint32_t data) {}
 907         virtual uint32_t __FASTCALL read_via_debugger_data16(uint32_t addr)
 908         {
 909                 return 0xffff;
 910         }
 911         virtual void __FASTCALL write_via_debugger_data32(uint32_t addr, uint32_t data) {}
 912         virtual uint32_t __FASTCALL read_via_debugger_data32(uint32_t addr)
 913         {
 914                 return 0xffffffff;
 915         }
 916         virtual void __FASTCALL write_via_debugger_data8w(uint32_t addr, uint32_t data, int* wait) {}
 917         virtual uint32_t __FASTCALL read_via_debugger_data8w(uint32_t addr, int* wait)
 918         {
 919                 return 0xff;
 920         }
 921         virtual void __FASTCALL write_via_debugger_data16w(uint32_t addr, uint32_t data, int* wait) {}
 922         virtual uint32_t __FASTCALL read_via_debugger_data16w(uint32_t addr, int* wait)
 923         {
 924                 return 0xffff;
 925         }
 926         virtual void __FASTCALL write_via_debugger_data32w(uint32_t addr, uint32_t data, int* wait) {}
 927         virtual uint32_t __FASTCALL read_via_debugger_data32w(uint32_t addr, int* wait)
 928         {
 929                 return 0xffffffff;
 930         }
 931         virtual void __FASTCALL write_via_debugger_io8(uint32_t addr, uint32_t data) {}
 932         virtual uint32_t __FASTCALL read_via_debugger_io8(uint32_t addr)
 933         {
 934                 return 0xff;
 935         }
 936         virtual void __FASTCALL write_via_debugger_io16(uint32_t addr, uint32_t data) {}
 937         virtual uint32_t __FASTCALL read_via_debugger_io16(uint32_t addr)
 938         {
 939                 return 0xffff;
 940         }
 941         virtual void __FASTCALL write_via_debugger_io32(uint32_t addr, uint32_t data) {}
 942         virtual uint32_t __FASTCALL read_via_debugger_io32(uint32_t addr)
 943         {
 944                 return 0xffffffff;
 945         }
 946         virtual void __FASTCALL write_via_debugger_io8w(uint32_t addr, uint32_t data, int* wait) {}
 947         virtual uint32_t __FASTCALL read_via_debugger_io8w(uint32_t addr, int* wait)
 948         {
 949                 return 0xff;
 950         }
 951         virtual void __FASTCALL write_via_debugger_io16w(uint32_t addr, uint32_t data, int* wait) {}
 952         virtual uint32_t __FASTCALL read_via_debugger_io16w(uint32_t addr, int* wait)
 953         {
 954                 return 0xffff;
 955         }
 956         virtual void __FASTCALL write_via_debugger_io32w(uint32_t addr, uint32_t data, int* wait) {}
 957         virtual uint32_t __FASTCALL read_via_debugger_io32w(uint32_t addr, int* wait)
 958         {
 959                 return 0xffffffff;
 960         }
 961         virtual void out_debug_log(const char *fmt, ...)
 962         {
 963                 char strbuf[4096];
 964                 va_list ap;
 965
 966                 va_start(ap, fmt);
 967                 vsnprintf(strbuf, 4095, fmt, ap);
 968                 emu->out_debug_log("%s", strbuf);
 969                 va_end(ap);
 970         }
 971         virtual void force_out_debug_log(const char *fmt, ...)
 972         {
 973                 char strbuf[4096];
 974                 va_list ap;
 975
 976                 va_start(ap, fmt);
 977                 vsnprintf(strbuf, 4095, fmt, ap);
 978                 emu->force_out_debug_log("%s", strbuf);
 979                 va_end(ap);
 980         }
 981
 982 #ifdef USE_DEBUGGER
 983         // debugger
 984         virtual bool is_cpu()
 985         {
 986                 return false;
 987         }
 988         virtual bool is_debugger()
 989         {
 990                 return false;
 991         }
 992         virtual bool is_debugger_available()
 993         {
 994                 return false;
 995         }
 996         virtual void *get_debugger()
 997         {
 998                 return NULL;
 999         }
1000         virtual uint32_t get_debug_prog_addr_mask()
1001         {
1002                 return 0;
1003         }
1004         virtual uint32_t get_debug_data_addr_mask()
1005         {
1006                 return 0;
1007         }
1008         virtual uint64_t get_debug_data_addr_space()
1009         {
1010                 // override this function when memory space is not (2 << n)
1011                 return (uint64_t)get_debug_data_addr_mask() + 1;
1012         }
1013         virtual void __FASTCALL write_debug_data8(uint32_t addr, uint32_t data)
1014         {
1015 //              write_data8(addr, data);
1016         }
1017         virtual uint32_t __FASTCALL read_debug_data8(uint32_t addr)
1018         {
1019 //              return read_data8(addr);
1020                 return 0xff;
1021         }
1022         virtual void __FASTCALL write_debug_data16(uint32_t addr, uint32_t data)
1023         {
1024                 write_debug_data8(addr, data & 0xff);
1025                 write_debug_data8(addr + 1, (data >> 8) & 0xff);
1026         }
1027         virtual uint32_t __FASTCALL read_debug_data16(uint32_t addr)
1028         {
1029                 uint32_t val = read_debug_data8(addr);
1030                 val |= read_debug_data8(addr + 1) << 8;
1031                 return val;
1032         }
1033         virtual void __FASTCALL write_debug_data32(uint32_t addr, uint32_t data)
1034         {
1035                 write_debug_data16(addr, data & 0xffff);
1036                 write_debug_data16(addr + 2, (data >> 16) & 0xffff);
1037         }
1038         virtual uint32_t __FASTCALL read_debug_data32(uint32_t addr)
1039         {
1040                 uint32_t val = read_debug_data16(addr);
1041                 val |= read_debug_data16(addr + 2) << 16;
1042                 return val;
1043         }
1044         virtual void __FASTCALL write_debug_io8(uint32_t addr, uint32_t data)
1045         {
1046 //              write_io8(addr, data);
1047         }
1048         virtual uint32_t __FASTCALL read_debug_io8(uint32_t addr)
1049         {
1050 //              return read_io8(addr);
1051                 return 0xff;
1052         }
1053         virtual void __FASTCALL write_debug_io16(uint32_t addr, uint32_t data)
1054         {
1055                 write_debug_io8(addr, data & 0xff);
1056                 write_debug_io8(addr + 1, (data >> 8) & 0xff);
1057         }
1058         virtual uint32_t __FASTCALL read_debug_io16(uint32_t addr)
1059         {
1060                 uint32_t val = read_debug_io8(addr);
1061                 val |= read_debug_io8(addr + 1) << 8;
1062                 return val;
1063         }
1064         virtual void __FASTCALL write_debug_io32(uint32_t addr, uint32_t data)
1065         {
1066                 write_debug_io16(addr, data & 0xffff);
1067                 write_debug_io16(addr + 2, (data >> 16) & 0xffff);
1068         }
1069         virtual uint32_t __FASTCALL read_debug_io32(uint32_t addr)
1070         {
1071                 uint32_t val = read_debug_io16(addr);
1072                 val |= read_debug_io16(addr + 2) << 16;
1073                 return val;
1074         }
1075         virtual bool write_debug_reg(const _TCHAR *reg, uint32_t data)
1076         {
1077                 return false;
1078         }
1079         virtual uint32_t __FASTCALL read_debug_reg(const _TCHAR *reg)
1080         {
1081                 return 0;
1082         }
1083         virtual bool get_debug_regs_info(_TCHAR *buffer, size_t buffer_len)
1084         {
1085                 return false;
1086         }
1087         virtual int debug_dasm(uint32_t pc, _TCHAR *buffer, size_t buffer_len)
1088         {
1089                 return debug_dasm_with_userdata(pc, buffer, buffer_len, 0);
1090         }
1091         virtual int debug_dasm_with_userdata(uint32_t pc, _TCHAR *buffer, size_t buffer_len, uint32_t userdata = 0)
1092         {
1093                 return 0;
1094         }
1095 #endif
1096         _TCHAR this_device_name[128];
1097
1098         DEVICE* prev_device;
1099         DEVICE* next_device;
1100         int this_device_id;
1101 };
1102 #endif // USE_SHARED_DLL
1103
1104 #endif