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