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