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