source/src/vm/libcpu_newdev/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 _LIBCPU_NEWDEV_DEVICE_H_
  11 #define _LIBCPU_NEWDEV_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 // max devices connected to the output port
  22 #define MAX_OUTPUT      16
  23
  24 // common signal id
  25 #define SIG_CPU_IRQ             101
  26 #define SIG_CPU_FIRQ            102
  27 #define SIG_CPU_NMI             103
  28 #define SIG_CPU_BUSREQ          104
  29 #define SIG_CPU_DEBUG           105
  30
  31 #define SIG_PRINTER_DATA        201
  32 #define SIG_PRINTER_STROBE      202
  33 #define SIG_PRINTER_RESET       203
  34 #define SIG_PRINTER_BUSY        204
  35 #define SIG_PRINTER_ACK         205
  36 #define SIG_PRINTER_SELECT      206
  37
  38 #define SIG_SCSI_DAT            301
  39 #define SIG_SCSI_BSY            302
  40 #define SIG_SCSI_CD             303
  41 #define SIG_SCSI_IO             304
  42 #define SIG_SCSI_MSG            305
  43 #define SIG_SCSI_REQ            306
  44 #define SIG_SCSI_SEL            307
  45 #define SIG_SCSI_ATN            308
  46 #define SIG_SCSI_ACK            309
  47 #define SIG_SCSI_RST            310
  48
  49
  50 class VM;
  51 class EMU;
  52 class DEVICE
  53 {
  54 protected:
  55         VM* vm;
  56         EMU* emu;
  57 public:
  58         DEVICE(VM* parent_vm, EMU* parent_emu);
  59         //ToDo: Will implement real destructor per real classes and below destructor decl. with "virtual".
  60         // This makes warning:
  61         //"deleting object of polymorphic class type 'DEVICE' which has non-virtual
  62         // destructor might cause undefined behavior [-Wdelete-non-virtual-dtor]".
  63         //~DEVICE(void);
  64         ~DEVICE(void) {}
  65
  66         virtual void initialize() {}
  67         virtual void release() {}
  68
  69         virtual void update_config() {}
  70         virtual void save_state(FILEIO* state_fio) {}
  71         virtual bool load_state(FILEIO* state_fio)
  72         {
  73                 return true;
  74         }
  75
  76         // control
  77         virtual void reset() {}
  78         virtual void special_reset()
  79         {
  80                 reset();
  81         }
  82
  83         // NOTE: the virtual bus interface functions for 16/32bit access invite the cpu is little endian.
  84         // if the cpu is big endian, you need to implement them in the virtual machine memory/io classes.
  85
  86         // memory bus
  87         virtual void write_data8(uint32_t addr, uint32_t data) {}
  88         virtual uint32_t read_data8(uint32_t addr)
  89         {
  90                 return 0xff;
  91         }
  92         virtual void write_data16(uint32_t addr, uint32_t data)
  93         {
  94                 write_data8(addr, data & 0xff);
  95                 write_data8(addr + 1, (data >> 8) & 0xff);
  96         }
  97         virtual uint32_t read_data16(uint32_t addr)
  98         {
  99                 uint32_t val = read_data8(addr);
 100                 val |= read_data8(addr + 1) << 8;
 101                 return val;
 102         }
 103         virtual void write_data32(uint32_t addr, uint32_t data)
 104         {
 105                 write_data16(addr, data & 0xffff);
 106                 write_data16(addr + 2, (data >> 16) & 0xffff);
 107         }
 108         virtual uint32_t read_data32(uint32_t addr)
 109         {
 110                 uint32_t val = read_data16(addr);
 111                 val |= read_data16(addr + 2) << 16;
 112                 return val;
 113         }
 114         virtual void write_data8w(uint32_t addr, uint32_t data, int* wait)
 115         {
 116                 *wait = 0;
 117                 write_data8(addr, data);
 118         }
 119         virtual uint32_t read_data8w(uint32_t addr, int* wait)
 120         {
 121                 *wait = 0;
 122                 return read_data8(addr);
 123         }
 124         virtual void write_data16w(uint32_t addr, uint32_t data, int* wait)
 125         {
 126                 int wait_l, wait_h;
 127                 write_data8w(addr, data & 0xff, &wait_l);
 128                 write_data8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 129                 *wait = wait_l + wait_h;
 130         }
 131         virtual uint32_t read_data16w(uint32_t addr, int* wait)
 132         {
 133                 int wait_l, wait_h;
 134                 uint32_t val = read_data8w(addr, &wait_l);
 135                 val |= read_data8w(addr + 1, &wait_h) << 8;
 136                 *wait = wait_l + wait_h;
 137                 return val;
 138         }
 139         virtual void write_data32w(uint32_t addr, uint32_t data, int* wait)
 140         {
 141                 int wait_l, wait_h;
 142                 write_data16w(addr, data & 0xffff, &wait_l);
 143                 write_data16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 144                 *wait = wait_l + wait_h;
 145         }
 146         virtual uint32_t read_data32w(uint32_t addr, int* wait)
 147         {
 148                 int wait_l, wait_h;
 149                 uint32_t val = read_data16w(addr, &wait_l);
 150                 val |= read_data16w(addr + 2, &wait_h) << 16;
 151                 *wait = wait_l + wait_h;
 152                 return val;
 153         }
 154         virtual uint32_t fetch_op(uint32_t addr, int *wait)
 155         {
 156                 return read_data8w(addr, wait);
 157         }
 158         virtual void write_dma_data8(uint32_t addr, uint32_t data)
 159         {
 160                 write_data8(addr, data);
 161         }
 162         virtual uint32_t read_dma_data8(uint32_t addr)
 163         {
 164                 return read_data8(addr);
 165         }
 166         virtual void write_dma_data16(uint32_t addr, uint32_t data)
 167         {
 168                 write_data16(addr, data);
 169         }
 170         virtual uint32_t read_dma_data16(uint32_t addr)
 171         {
 172                 return read_data16(addr);
 173         }
 174         virtual void write_dma_data32(uint32_t addr, uint32_t data)
 175         {
 176                 write_data32(addr, data);
 177         }
 178         virtual uint32_t read_dma_data32(uint32_t addr)
 179         {
 180                 return read_data32(addr);
 181         }
 182         virtual void write_dma_data8w(uint32_t addr, uint32_t data, int* wait)
 183         {
 184                 write_data8w(addr, data, wait);
 185         }
 186         virtual uint32_t read_dma_data8w(uint32_t addr, int* wait)
 187         {
 188                 return read_data8w(addr, wait);
 189         }
 190         virtual void write_dma_data16w(uint32_t addr, uint32_t data, int* wait)
 191         {
 192                 write_data16w(addr, data, wait);
 193         }
 194         virtual uint32_t read_dma_data16w(uint32_t addr, int* wait)
 195         {
 196                 return read_data16w(addr, wait);
 197         }
 198         virtual void write_dma_data32w(uint32_t addr, uint32_t data, int* wait)
 199         {
 200                 write_data32w(addr, data, wait);
 201         }
 202         virtual uint32_t read_dma_data32w(uint32_t addr, int* wait)
 203         {
 204                 return read_data32w(addr, wait);
 205         }
 206
 207         // i/o bus
 208         virtual void write_io8(uint32_t addr, uint32_t data) {}
 209         virtual uint32_t read_io8(uint32_t addr);
 210         virtual void write_io16(uint32_t addr, uint32_t data)
 211         {
 212                 write_io8(addr, data & 0xff);
 213                 write_io8(addr + 1, (data >> 8) & 0xff);
 214         }
 215         virtual uint32_t read_io16(uint32_t addr)
 216         {
 217                 uint32_t val = read_io8(addr);
 218                 val |= read_io8(addr + 1) << 8;
 219                 return val;
 220         }
 221         virtual void write_io32(uint32_t addr, uint32_t data)
 222         {
 223                 write_io16(addr, data & 0xffff);
 224                 write_io16(addr + 2, (data >> 16) & 0xffff);
 225         }
 226         virtual uint32_t read_io32(uint32_t addr)
 227         {
 228                 uint32_t val = read_io16(addr);
 229                 val |= read_io16(addr + 2) << 16;
 230                 return val;
 231         }
 232         virtual void write_io8w(uint32_t addr, uint32_t data, int* wait)
 233         {
 234                 *wait = 0;
 235                 write_io8(addr, data);
 236         }
 237         virtual uint32_t read_io8w(uint32_t addr, int* wait)
 238         {
 239                 *wait = 0;
 240                 return read_io8(addr);
 241         }
 242         virtual void write_io16w(uint32_t addr, uint32_t data, int* wait)
 243         {
 244                 int wait_l, wait_h;
 245                 write_io8w(addr, data & 0xff, &wait_l);
 246                 write_io8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 247                 *wait = wait_l + wait_h;
 248         }
 249         virtual uint32_t read_io16w(uint32_t addr, int* wait)
 250         {
 251                 int wait_l, wait_h;
 252                 uint32_t val = read_io8w(addr, &wait_l);
 253                 val |= read_io8w(addr + 1, &wait_h) << 8;
 254                 *wait = wait_l + wait_h;
 255                 return val;
 256         }
 257         virtual void write_io32w(uint32_t addr, uint32_t data, int* wait)
 258         {
 259                 int wait_l, wait_h;
 260                 write_io16w(addr, data & 0xffff, &wait_l);
 261                 write_io16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 262                 *wait = wait_l + wait_h;
 263         }
 264         virtual uint32_t read_io32w(uint32_t addr, int* wait)
 265         {
 266                 int wait_l, wait_h;
 267                 uint32_t val = read_io16w(addr, &wait_l);
 268                 val |= read_io16w(addr + 2, &wait_h) << 16;
 269                 *wait = wait_l + wait_h;
 270                 return val;
 271         }
 272         virtual void write_dma_io8(uint32_t addr, uint32_t data)
 273         {
 274                 write_io8(addr, data);
 275         }
 276         virtual uint32_t read_dma_io8(uint32_t addr)
 277         {
 278                 return read_io8(addr);
 279         }
 280         virtual void write_dma_io16(uint32_t addr, uint32_t data)
 281         {
 282                 write_io16(addr, data);
 283         }
 284         virtual uint32_t read_dma_io16(uint32_t addr)
 285         {
 286                 return read_io16(addr);
 287         }
 288         virtual void write_dma_io32(uint32_t addr, uint32_t data)
 289         {
 290                 write_io32(addr, data);
 291         }
 292         virtual uint32_t read_dma_io32(uint32_t addr)
 293         {
 294                 return read_io32(addr);
 295         }
 296         virtual void write_dma_io8w(uint32_t addr, uint32_t data, int* wait)
 297         {
 298                 write_io8w(addr, data, wait);
 299         }
 300         virtual uint32_t read_dma_io8w(uint32_t addr, int* wait)
 301         {
 302                 return read_io8w(addr, wait);
 303         }
 304         virtual void write_dma_io16w(uint32_t addr, uint32_t data, int* wait)
 305         {
 306                 write_io16w(addr, data, wait);
 307         }
 308         virtual uint32_t read_dma_io16w(uint32_t addr, int* wait)
 309         {
 310                 return read_io16w(addr, wait);
 311         }
 312         virtual void write_dma_io32w(uint32_t addr, uint32_t data, int* wait)
 313         {
 314                 write_io32w(addr, data, wait);
 315         }
 316         virtual uint32_t read_dma_io32w(uint32_t addr, int* wait)
 317         {
 318                 return read_io32w(addr, wait);
 319         }
 320
 321         // memory mapped i/o
 322         virtual void write_memory_mapped_io8(uint32_t addr, uint32_t data)
 323         {
 324                 write_io8(addr, data);
 325         }
 326         virtual uint32_t read_memory_mapped_io8(uint32_t addr)
 327         {
 328                 return read_io8(addr);
 329         }
 330         virtual void write_memory_mapped_io16(uint32_t addr, uint32_t data)
 331         {
 332                 write_memory_mapped_io8(addr, data & 0xff);
 333                 write_memory_mapped_io8(addr + 1, (data >> 8) & 0xff);
 334         }
 335         virtual uint32_t read_memory_mapped_io16(uint32_t addr)
 336         {
 337                 uint32_t val = read_memory_mapped_io8(addr);
 338                 val |= read_memory_mapped_io8(addr + 1) << 8;
 339                 return val;
 340         }
 341         virtual void write_memory_mapped_io32(uint32_t addr, uint32_t data)
 342         {
 343                 write_memory_mapped_io16(addr, data & 0xffff);
 344                 write_memory_mapped_io16(addr + 2, (data >> 16) & 0xffff);
 345         }
 346         virtual uint32_t read_memory_mapped_io32(uint32_t addr)
 347         {
 348                 uint32_t val = read_memory_mapped_io16(addr);
 349                 val |= read_memory_mapped_io16(addr + 2) << 16;
 350                 return val;
 351         }
 352         virtual void write_memory_mapped_io8w(uint32_t addr, uint32_t data, int* wait)
 353         {
 354                 *wait = 0;
 355                 write_memory_mapped_io8(addr, data);
 356         }
 357         virtual uint32_t read_memory_mapped_io8w(uint32_t addr, int* wait)
 358         {
 359                 *wait = 0;
 360                 return read_memory_mapped_io8(addr);
 361         }
 362         virtual void write_memory_mapped_io16w(uint32_t addr, uint32_t data, int* wait)
 363         {
 364                 int wait_l, wait_h;
 365                 write_memory_mapped_io8w(addr, data & 0xff, &wait_l);
 366                 write_memory_mapped_io8w(addr + 1, (data >> 8) & 0xff, &wait_h);
 367                 *wait = wait_l + wait_h;
 368         }
 369         virtual uint32_t read_memory_mapped_io16w(uint32_t addr, int* wait)
 370         {
 371                 int wait_l, wait_h;
 372                 uint32_t val = read_memory_mapped_io8w(addr, &wait_l);
 373                 val |= read_memory_mapped_io8w(addr + 1, &wait_h) << 8;
 374                 *wait = wait_l + wait_h;
 375                 return val;
 376         }
 377         virtual void write_memory_mapped_io32w(uint32_t addr, uint32_t data, int* wait)
 378         {
 379                 int wait_l, wait_h;
 380                 write_memory_mapped_io16w(addr, data & 0xffff, &wait_l);
 381                 write_memory_mapped_io16w(addr + 2, (data >> 16) & 0xffff, &wait_h);
 382                 *wait = wait_l + wait_h;
 383         }
 384         virtual uint32_t read_memory_mapped_io32w(uint32_t addr, int* wait)
 385         {
 386                 int wait_l, wait_h;
 387                 uint32_t val = read_memory_mapped_io16w(addr, &wait_l);
 388                 val |= read_memory_mapped_io16w(addr + 2, &wait_h) << 16;
 389                 *wait = wait_l + wait_h;
 390                 return val;
 391         }
 392
 393         // device to device
 394         typedef struct {
 395                 DEVICE *device;
 396                 int id;
 397                 uint32_t mask;
 398                 int shift;
 399         } output_t;
 400
 401         typedef struct {
 402                 int count;
 403                 output_t item[MAX_OUTPUT];
 404         } outputs_t;
 405
 406         virtual void initialize_output_signals(outputs_t *items)
 407         {
 408                 items->count = 0;
 409         }
 410         virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask, int shift)
 411         {
 412                 int c = items->count++;
 413                 items->item[c].device = device;
 414                 items->item[c].id = id;
 415                 items->item[c].mask = mask;
 416                 items->item[c].shift = shift;
 417         }
 418         virtual void register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask)
 419         {
 420                 int c = items->count++;
 421                 items->item[c].device = device;
 422                 items->item[c].id = id;
 423                 items->item[c].mask = mask;
 424                 items->item[c].shift = 0;
 425         }
 426         virtual void write_signals(outputs_t *items, uint32_t data)
 427         {
 428                 for(int i = 0; i < items->count; i++) {
 429                         output_t *item = &items->item[i];
 430                         int shift = item->shift;
 431                         uint32_t val = (shift < 0) ? (data >> (-shift)) : (data << shift);
 432                         uint32_t mask = (shift < 0) ? (item->mask >> (-shift)) : (item->mask << shift);
 433                         item->device->write_signal(item->id, val, mask);
 434                 }
 435         };
 436         virtual void write_signal(int id, uint32_t data, uint32_t mask) {}
 437         virtual uint32_t read_signal(int ch)
 438         {
 439                 return 0;
 440         }
 441
 442         // z80 daisy chain
 443         virtual void set_context_intr(DEVICE* device, uint32_t bit) {}
 444         virtual void set_context_child(DEVICE* device) {}
 445
 446         // interrupt device to device
 447         virtual void set_intr_iei(bool val) {}
 448
 449         // interrupt device to cpu
 450         virtual void set_intr_line(bool line, bool pending, uint32_t bit) {}
 451
 452         // interrupt cpu to device
 453         virtual uint32_t get_intr_ack()
 454         {
 455                 return 0xff;
 456         }
 457         virtual void notify_intr_reti() {}
 458         virtual void notify_intr_ei() {}
 459
 460         // dma
 461         virtual void do_dma() {}
 462
 463         // cpu
 464         virtual int run(int clock)
 465         {
 466                 // when clock == -1, run one opecode
 467                 return (clock == -1 ? 1 : clock);
 468         }
 469         virtual void set_extra_clock(int clock) {}
 470         virtual int get_extra_clock()
 471         {
 472                 return 0;
 473         }
 474         virtual uint32_t get_pc()
 475         {
 476                 return 0;
 477         }
 478         virtual uint32_t get_next_pc()
 479         {
 480                 return 0;
 481         }
 482
 483         // bios
 484         virtual bool bios_call_i86(uint32_t PC, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
 485         {
 486                 return false;
 487         }
 488         virtual bool bios_int_i86(int intnum, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag)
 489         {
 490                 return false;
 491         }
 492         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)   {
 493                 return false;
 494         }
 495         // misc
 496         const _TCHAR *get_device_name(void)
 497         {
 498                 return (const _TCHAR *)this_device_name;
 499         }
 500
 501         // event manager
 502         DEVICE* event_manager;
 503
 504         virtual void set_context_event_manager(DEVICE* device)
 505         {
 506                 event_manager = device;
 507         }
 508         virtual int get_event_manager_id();
 509         virtual void register_event(DEVICE* device, int event_id, double usec, bool loop, int* register_id);
 510         virtual void register_event_by_clock(DEVICE* device, int event_id, uint64_t clock, bool loop, int* register_id);
 511         virtual void cancel_event(DEVICE* device, int register_id);
 512         virtual void register_frame_event(DEVICE* device);
 513         virtual void register_vline_event(DEVICE* device);
 514         virtual uint32_t get_event_remaining_clock(int register_id);
 515         virtual double get_event_remaining_usec(int register_id);
 516         virtual uint32_t get_current_clock();
 517         virtual uint32_t get_passed_clock(uint32_t prev);
 518         virtual double get_passed_usec(uint32_t prev);
 519         virtual uint32_t get_cpu_pc(int index);
 520         virtual void request_skip_frames();
 521         virtual void set_frames_per_sec(double frames);
 522         virtual void set_lines_per_frame(int lines);
 523         // Force render sound immediately when device's status has changed.
 524         // You must call this after you changing registers (or enything).
 525         // If has problems, try set_realtime_render.
 526         // See mb8877.cpp and ym2203.cpp.
 527         // -- 20161010 K.O
 528         virtual void touch_sound(void);
 529         // Force render per 1 sample automatically.
 530         // See pcm1bit.cpp .
 531         // -- 20161010 K.O
 532         virtual void set_realtime_render(bool flag);
 533         virtual void update_timing(int new_clocks, double new_frames_per_sec, int new_lines_per_frame) {}
 534
 535         // event callback
 536         virtual void event_callback(int event_id, int err) {}
 537         virtual void event_pre_frame() {}       // this event is to update timing settings
 538         virtual void event_frame() {}
 539         virtual void event_vline(int v, int clock) {}
 540         virtual void event_hsync(int v, int h, int clock) {}
 541
 542         // sound
 543         virtual void mix(int32_t* buffer, int cnt) {}
 544         virtual void set_volume(int ch, int decibel_l, int decibel_r) {} // +1 equals +0.5dB (same as fmgen)
 545
 546         virtual void set_device_name(const _TCHAR *name);
 547         virtual void out_debug_log(const char *fmt, ...);
 548 #if 1
 549         // debugger
 550         // DEBUGGER is enabled by default.
 551         virtual void *get_debugger();
 552         virtual uint32_t get_debug_prog_addr_mask();
 553         virtual uint32_t get_debug_data_addr_mask();
 554         virtual void write_debug_data8(uint32_t addr, uint32_t data);
 555         virtual uint32_t read_debug_data8(uint32_t addr);
 556         virtual void write_debug_data16(uint32_t addr, uint32_t data);
 557         virtual uint32_t read_debug_data16(uint32_t addr);
 558         virtual void write_debug_data32(uint32_t addr, uint32_t data);
 559         virtual uint32_t read_debug_data32(uint32_t addr);
 560         virtual void write_debug_io8(uint32_t addr, uint32_t data);
 561         virtual uint32_t read_debug_io8(uint32_t addr);
 562         virtual void write_debug_io16(uint32_t addr, uint32_t data);
 563         virtual uint32_t read_debug_io16(uint32_t addr);
 564         virtual void write_debug_io32(uint32_t addr, uint32_t data);
 565         virtual uint32_t read_debug_io32(uint32_t addr);
 566         virtual bool write_debug_reg(const _TCHAR *reg, uint32_t data);
 567         virtual void get_debug_regs_info(_TCHAR *buffer, size_t buffer_len);
 568         virtual int debug_dasm(uint32_t pc, _TCHAR *buffer, size_t buffer_len);
 569 #endif
 570         _TCHAR this_device_name[128];
 571
 572         DEVICE* prev_device;
 573         DEVICE* next_device;
 574         int this_device_id;
 575 };
 576
 577 #endif