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