source/src/vm/device.cpp

   1 /*
   2         Skelton for retropc emulator
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2006.08.18 -
   6
   7         [ device base class ]
   8 */
   9
  10 #include "../common.h"
  11
  12 #if !defined(_USE_QT)
  13 #include "../vm.h"
  14 #include "../../emu.h"
  15 #endif
  16
  17 #include "./device.h"
  18 #include <memory>
  19
  20
  21 DEVICE::DEVICE(VM_TEMPLATE* parent_vm, EMU_TEMPLATE* parent_emu) : vm(parent_vm), emu(parent_emu)
  22 {
  23         __IOBUS_RETURN_ADDR = false;
  24 #if defined(_USE_QT)
  25         osd = emu->get_osd();
  26         p_logger = osd->get_logger();
  27 #else
  28         osd = NULL;
  29         p_logger = NULL;
  30 #endif
  31         memset(this_device_name, 0x00, sizeof(this_device_name));
  32         strncpy(this_device_name, "Base Device", 128 - 1);
  33         prev_device = vm->last_device;
  34         next_device = NULL;
  35         if(vm->first_device == NULL) {
  36                 // this is the first device
  37                 vm->first_device = this;
  38                 this_device_id = 0;
  39         } else {
  40                 // this is not the first device
  41                 vm->last_device->next_device = this;
  42                 this_device_id = vm->last_device->this_device_id + 1;
  43         }
  44         vm->last_device = this;
  45         // primary event manager
  46         event_manager = NULL;
  47 }
  48
  49 DEVICE::~DEVICE(void)
  50 {
  51 }
  52
  53 void DEVICE::initialize()
  54 {
  55 #if defined(_USE_QT)
  56         if(osd == nullptr) {
  57         #if defined(IOBUS_RETURN_ADDR)
  58                 __IOBUS_RETURN_ADDR = true;
  59         #endif
  60         } else {
  61                 __IOBUS_RETURN_ADDR = osd->check_feature(_T("IOBUS_RETURN_ADDR"));
  62         }
  63 #elif defined(IOBUS_RETURN_ADDR)
  64                 __IOBUS_RETURN_ADDR = true;
  65 #endif
  66         /* Initializing VM must be after initializing OSD. */
  67 }
  68
  69 void DEVICE::release()
  70 {
  71 }
  72
  73 void DEVICE::reset()
  74 {
  75 }
  76
  77 void DEVICE::special_reset(int num)
  78 {
  79         reset();
  80 }
  81
  82
  83 uint32_t DEVICE::translate_address(int segment, uint32_t offset)
  84 {
  85         return offset;
  86 }
  87
  88 void DEVICE::write_data8(uint32_t addr, uint32_t data)
  89 {
  90 }
  91
  92 uint32_t DEVICE::read_data8(uint32_t addr)
  93 {
  94         return 0xff;
  95 }
  96
  97 void DEVICE::write_data16(uint32_t addr, uint32_t data)
  98 {
  99         write_data8(addr,     (data     ) & 0xff);
 100         write_data8(addr + 1, (data >> 8) & 0xff);
 101 }
 102
 103 uint32_t DEVICE::read_data16(uint32_t addr)
 104 {
 105         uint32_t val;
 106         val  = read_data8(addr    );
 107         val |= read_data8(addr + 1) << 8;
 108         return val;
 109 }
 110
 111 void DEVICE::write_data32(uint32_t addr, uint32_t data)
 112 {
 113         __LIKELY_IF(!(addr & 1)) {
 114                 write_data16(addr,     (data      ) & 0xffff);
 115                 write_data16(addr + 2, (data >> 16) & 0xffff);
 116         } else {
 117                 write_data8 (addr,     (data      ) & 0x00ff);
 118                 write_data16(addr + 1, (data >>  8) & 0xffff);
 119                 write_data8 (addr + 3, (data >> 24) & 0x00ff);
 120         }
 121 }
 122
 123 uint32_t DEVICE::read_data32(uint32_t addr)
 124 {
 125         __LIKELY_IF(!(addr & 1)) {
 126                 uint32_t val;
 127                 val  = read_data16(addr    );
 128                 val |= read_data16(addr + 2) << 16;
 129                 return val;
 130         } else {
 131                 uint32_t val;
 132                 val  = read_data8 (addr    );
 133                 val |= read_data16(addr + 1) <<  8;
 134                 val |= read_data8 (addr + 3) << 24;
 135                 return val;
 136         }
 137 }
 138
 139 void DEVICE::write_data8w(uint32_t addr, uint32_t data, int* wait)
 140 {
 141         *wait = 0;
 142         write_data8(addr, data);
 143 }
 144
 145 uint32_t DEVICE::read_data8w(uint32_t addr, int* wait)
 146 {
 147         *wait = 0;
 148         return read_data8(addr);
 149 }
 150 void DEVICE::write_data16w(uint32_t addr, uint32_t data, int* wait)
 151 {
 152         int wait_0, wait_1;
 153         write_data8w(addr,     (data     ) & 0xff, &wait_0);
 154         write_data8w(addr + 1, (data >> 8) & 0xff, &wait_1);
 155         *wait = wait_0 + wait_1;
 156 }
 157
 158 uint32_t DEVICE::read_data16w(uint32_t addr, int* wait)
 159 {
 160         int wait_0, wait_1;
 161         uint32_t val;
 162         val  = read_data8w(addr,     &wait_0);
 163         val |= read_data8w(addr + 1, &wait_1) << 8;
 164         *wait = wait_0 + wait_1;
 165         return val;
 166 }
 167
 168 void DEVICE::write_data32w(uint32_t addr, uint32_t data, int* wait)
 169 {
 170         __LIKELY_IF(!(addr & 1)) {
 171                 int wait_0, wait_1;
 172                 write_data16w(addr,     (data      ) & 0xffff, &wait_0);
 173                 write_data16w(addr + 2, (data >> 16) & 0xffff, &wait_1);
 174                 *wait = wait_0 + wait_1;
 175         } else {
 176                 int wait_0, wait_1, wait_2;
 177                 write_data8w (addr,     (data      ) & 0x00ff, &wait_0);
 178                 write_data16w(addr + 1, (data >>  8) & 0xffff, &wait_1);
 179                 write_data8w (addr + 3, (data >> 24) & 0x00ff, &wait_2);
 180                 *wait = wait_0 + wait_1 + wait_2;
 181         }
 182 }
 183
 184 uint32_t DEVICE::read_data32w(uint32_t addr, int* wait)
 185 {
 186         __LIKELY_IF(!(addr & 1)) {
 187                 int wait_0, wait_1;
 188                 uint32_t val;
 189                 val  = read_data16w(addr,     &wait_0);
 190                 val |= read_data16w(addr + 2, &wait_1) << 16;
 191                 *wait = wait_0 + wait_1;
 192                 return val;
 193         } else {
 194                 int wait_0, wait_1, wait_2;
 195                 uint32_t val;
 196                 val  = read_data8w (addr,     &wait_0);
 197                 val |= read_data16w(addr + 1, &wait_1) <<  8;
 198                 val |= read_data8w (addr + 3, &wait_2) << 24;
 199                 *wait = wait_0 + wait_1 + wait_2;
 200                 return val;
 201         }
 202 }
 203
 204 uint32_t DEVICE::fetch_op(uint32_t addr, int *wait)
 205 {
 206         return read_data8w(addr, wait);
 207 }
 208
 209 void DEVICE::write_dma_data8(uint32_t addr, uint32_t data)
 210 {
 211         write_data8(addr, data);
 212 }
 213
 214 uint32_t DEVICE::read_dma_data8(uint32_t addr)
 215 {
 216         return read_data8(addr);
 217 }
 218
 219 void DEVICE::write_dma_data16(uint32_t addr, uint32_t data)
 220 {
 221         write_data16(addr, data);
 222 }
 223
 224 uint32_t DEVICE::read_dma_data16(uint32_t addr)
 225 {
 226         return read_data16(addr);
 227 }
 228 void DEVICE::write_dma_data32(uint32_t addr, uint32_t data)
 229 {
 230         write_data32(addr, data);
 231 }
 232
 233 uint32_t DEVICE::read_dma_data32(uint32_t addr)
 234 {
 235         return read_data32(addr);
 236 }
 237
 238
 239 void DEVICE::write_dma_data8w(uint32_t addr, uint32_t data, int* wait)
 240 {
 241         write_data8w(addr, data, wait);
 242 }
 243
 244 uint32_t DEVICE::read_dma_data8w(uint32_t addr, int* wait)
 245 {
 246         return read_data8w(addr, wait);
 247 }
 248
 249 void DEVICE::write_dma_data16w(uint32_t addr, uint32_t data, int* wait)
 250 {
 251         write_data16w(addr, data, wait);
 252 }
 253
 254 uint32_t DEVICE::read_dma_data16w(uint32_t addr, int* wait)
 255 {
 256         return read_data16w(addr, wait);
 257 }
 258
 259 void DEVICE::write_dma_data32w(uint32_t addr, uint32_t data, int* wait)
 260 {
 261         write_data32w(addr, data, wait);
 262 }
 263
 264 uint32_t DEVICE::read_dma_data32w(uint32_t addr, int* wait)
 265 {
 266         return read_data32w(addr, wait);
 267 }
 268
 269 //<! i/o bus
 270
 271 void DEVICE::write_io8(uint32_t addr, uint32_t data)
 272 {
 273 }
 274
 275 uint32_t DEVICE::read_io8(uint32_t addr)
 276 {
 277         __UNLIKELY_IF(__IOBUS_RETURN_ADDR) {
 278                 return (addr & 1 ? addr >> 8 : addr) & 0xff;
 279         } else {
 280                 return 0xff;
 281         }
 282 }
 283
 284 void DEVICE::write_io16(uint32_t addr, uint32_t data)
 285 {
 286         write_io8(addr    , (data     ) & 0xff);
 287         write_io8(addr + 1, (data >> 8) & 0xff);
 288 }
 289
 290 uint32_t DEVICE::read_io16(uint32_t addr)
 291 {
 292         uint32_t val;
 293         val  = read_io8(addr    );
 294         val |= read_io8(addr + 1) << 8;
 295         return val;
 296 }
 297
 298 void DEVICE::write_io32(uint32_t addr, uint32_t data)
 299 {
 300         __LIKELY_IF(!(addr & 1)) {
 301                 write_io16(addr,     (data      ) & 0xffff);
 302                 write_io16(addr + 2, (data >> 16) & 0xffff);
 303         } else {
 304                 write_io8 (addr,     (data      ) & 0x00ff);
 305                 write_io16(addr + 1, (data >>  8) & 0xffff);
 306                 write_io8 (addr + 3, (data >> 24) & 0x00ff);
 307         }
 308 }
 309
 310 uint32_t DEVICE::read_io32(uint32_t addr)
 311 {
 312         __LIKELY_IF(!(addr & 1)) {
 313                 uint32_t val;
 314                 val  = read_io16(addr    );
 315                 val |= read_io16(addr + 2) << 16;
 316                 return val;
 317         } else {
 318                 uint32_t val;
 319                 val  = read_io8 (addr    );
 320                 val |= read_io16(addr + 1) <<  8;
 321                 val |= read_io8 (addr + 3) << 24;
 322                 return val;
 323         }
 324 }
 325
 326 void DEVICE::write_io8w(uint32_t addr, uint32_t data, int* wait)
 327 {
 328         *wait = 0;
 329         write_io8(addr, data);
 330 }
 331
 332 uint32_t DEVICE::read_io8w(uint32_t addr, int* wait)
 333 {
 334         *wait = 0;
 335         return read_io8(addr);
 336 }
 337
 338 void DEVICE::write_io16w(uint32_t addr, uint32_t data, int* wait)
 339 {
 340         int wait_0, wait_1;
 341         write_io8w(addr,     (data     ) & 0xff, &wait_0);
 342         write_io8w(addr + 1, (data >> 8) & 0xff, &wait_1);
 343         *wait = wait_0 + wait_1;
 344 }
 345
 346 uint32_t DEVICE::read_io16w(uint32_t addr, int* wait)
 347 {
 348         int wait_0, wait_1;
 349         uint32_t val;
 350         val  = read_io8w(addr,     &wait_0);
 351         val |= read_io8w(addr + 1, &wait_1) << 8;
 352         *wait = wait_0 + wait_1;
 353         return val;
 354 }
 355
 356 void DEVICE::write_io32w(uint32_t addr, uint32_t data, int* wait)
 357 {
 358         __LIKELY_IF(!(addr & 1)) {
 359                 int wait_0, wait_1;
 360                 write_io16w(addr,     (data      ) & 0xffff, &wait_0);
 361                 write_io16w(addr + 2, (data >> 16) & 0xffff, &wait_1);
 362                 *wait = wait_0 + wait_1;
 363         } else {
 364                 int wait_0, wait_1, wait_2;
 365                 write_io8w (addr,     (data      ) & 0x00ff, &wait_0);
 366                 write_io16w(addr + 1, (data >>  8) & 0xffff, &wait_1);
 367                 write_io8w (addr + 3, (data >> 24) & 0x00ff, &wait_2);
 368                 *wait = wait_0 + wait_1 + wait_2;
 369         }
 370 }
 371
 372 uint32_t DEVICE::read_io32w(uint32_t addr, int* wait)
 373 {
 374         __LIKELY_IF(!(addr & 1)) {
 375                 int wait_0, wait_1;
 376                 uint32_t val;
 377                 val  = read_io16w(addr,     &wait_0);
 378                 val |= read_io16w(addr + 2, &wait_1) << 16;
 379                 *wait = wait_0 + wait_1;
 380                 return val;
 381         } else {
 382                 int wait_0, wait_1, wait_2;
 383                 uint32_t val;
 384                 val  = read_io8w (addr,     &wait_0);
 385                 val |= read_io16w(addr + 1, &wait_1) <<  8;
 386                 val |= read_io8w (addr + 3, &wait_2) << 24;
 387                 *wait = wait_0 + wait_1 + wait_2;
 388                 return val;
 389         }
 390 }
 391
 392 void DEVICE::write_dma_io8(uint32_t addr, uint32_t data)
 393 {
 394         write_io8(addr, data);
 395 }
 396
 397 uint32_t DEVICE::read_dma_io8(uint32_t addr)
 398 {
 399         return read_io8(addr);
 400 }
 401
 402 void DEVICE::write_dma_io16(uint32_t addr, uint32_t data)
 403 {
 404         write_io16(addr, data);
 405 }
 406
 407 uint32_t DEVICE::read_dma_io16(uint32_t addr)
 408 {
 409         return read_io16(addr);
 410 }
 411
 412 void DEVICE::write_dma_io32(uint32_t addr, uint32_t data)
 413 {
 414         write_io32(addr, data);
 415 }
 416
 417 uint32_t DEVICE::read_dma_io32(uint32_t addr)
 418 {
 419         return read_io32(addr);
 420 }
 421
 422 void DEVICE::write_dma_io8w(uint32_t addr, uint32_t data, int* wait)
 423 {
 424         write_io8w(addr, data, wait);
 425 }
 426
 427 uint32_t DEVICE::read_dma_io8w(uint32_t addr, int* wait)
 428 {
 429         return read_io8w(addr, wait);
 430 }
 431
 432 void DEVICE::write_dma_io16w(uint32_t addr, uint32_t data, int* wait)
 433 {
 434         write_io16w(addr, data, wait);
 435 }
 436
 437 uint32_t DEVICE::read_dma_io16w(uint32_t addr, int* wait)
 438 {
 439         return read_io16w(addr, wait);
 440 }
 441
 442 void DEVICE::write_dma_io32w(uint32_t addr, uint32_t data, int* wait)
 443 {
 444         write_io32w(addr, data, wait);
 445 }
 446
 447 uint32_t DEVICE::read_dma_io32w(uint32_t addr, int* wait)
 448 {
 449         return read_io32w(addr, wait);
 450 }
 451
 452 // memory mapped i/o
 453 void DEVICE::write_memory_mapped_io8(uint32_t addr, uint32_t data)
 454 {
 455         write_io8(addr, data);
 456 }
 457
 458 uint32_t DEVICE::read_memory_mapped_io8(uint32_t addr)
 459 {
 460         return read_io8(addr);
 461 }
 462
 463 void DEVICE::write_memory_mapped_io16(uint32_t addr, uint32_t data)
 464 {
 465         write_memory_mapped_io8(addr,     (data     ) & 0xff);
 466         write_memory_mapped_io8(addr + 1, (data >> 8) & 0xff);
 467 }
 468
 469 uint32_t DEVICE::read_memory_mapped_io16(uint32_t addr)
 470 {
 471         uint32_t val;
 472         val =  read_memory_mapped_io8(addr    );
 473         val |= read_memory_mapped_io8(addr + 1) << 8;
 474         return val;
 475 }
 476
 477 void DEVICE::write_memory_mapped_io32(uint32_t addr, uint32_t data)
 478 {
 479         __LIKELY_IF(!(addr & 1)) {
 480                 write_memory_mapped_io16(addr,     (data      ) & 0xffff);
 481                 write_memory_mapped_io16(addr + 2, (data >> 16) & 0xffff);
 482         } else {
 483                 write_memory_mapped_io8 (addr,     (data      ) & 0x00ff);
 484                 write_memory_mapped_io16(addr + 1, (data >>  8) & 0xffff);
 485                 write_memory_mapped_io8 (addr + 3, (data >> 24) & 0x00ff);
 486         }
 487 }
 488
 489 uint32_t DEVICE::read_memory_mapped_io32(uint32_t addr)
 490 {
 491         __LIKELY_IF(!(addr & 1)) {
 492                 uint32_t val;
 493                 val  = read_memory_mapped_io16(addr    );
 494                 val |= read_memory_mapped_io16(addr + 2) << 16;
 495                 return val;
 496         } else {
 497                 uint32_t val;
 498                 val  = read_memory_mapped_io8 (addr    );
 499                 val |= read_memory_mapped_io16(addr + 1) <<  8;
 500                 val |= read_memory_mapped_io8 (addr + 3) << 24;
 501                 return val;
 502         }
 503 }
 504
 505 void DEVICE::write_memory_mapped_io8w(uint32_t addr, uint32_t data, int* wait)
 506 {
 507         *wait = 0;
 508         write_memory_mapped_io8(addr, data);
 509 }
 510
 511 uint32_t DEVICE::read_memory_mapped_io8w(uint32_t addr, int* wait)
 512 {
 513         *wait = 0;
 514         return read_memory_mapped_io8(addr);
 515 }
 516
 517 void DEVICE::write_memory_mapped_io16w(uint32_t addr, uint32_t data, int* wait)
 518 {
 519         int wait_0, wait_1;
 520         write_memory_mapped_io8w(addr,     (data     ) & 0xff, &wait_0);
 521         write_memory_mapped_io8w(addr + 1, (data >> 8) & 0xff, &wait_1);
 522         *wait = wait_0 + wait_1;
 523 }
 524
 525 uint32_t DEVICE::read_memory_mapped_io16w(uint32_t addr, int* wait)
 526 {
 527         int wait_0, wait_1;
 528         uint32_t val;
 529         val  = read_memory_mapped_io8w(addr,     &wait_0);
 530         val |= read_memory_mapped_io8w(addr + 1, &wait_1) << 8;
 531         *wait = wait_0 + wait_1;
 532         return val;
 533 }
 534
 535 void DEVICE::write_memory_mapped_io32w(uint32_t addr, uint32_t data, int* wait)
 536 {
 537         __LIKELY_IF(!(addr & 1)) {
 538                 int wait_0, wait_1;
 539                 write_memory_mapped_io16w(addr,     (data      ) & 0xffff, &wait_0);
 540                 write_memory_mapped_io16w(addr + 2, (data >> 16) & 0xffff, &wait_1);
 541                 *wait = wait_0 + wait_1;
 542         } else {
 543                 int wait_0, wait_1, wait_2;
 544                 write_memory_mapped_io8w (addr,     (data      ) & 0x00ff, &wait_0);
 545                 write_memory_mapped_io16w(addr + 1, (data >>  8) & 0xffff, &wait_1);
 546                 write_memory_mapped_io8w (addr + 3, (data >> 24) & 0x00ff, &wait_2);
 547                 *wait = wait_0 + wait_1 + wait_2;
 548         }
 549 }
 550
 551 uint32_t DEVICE::read_memory_mapped_io32w(uint32_t addr, int* wait)
 552 {
 553         __LIKELY_IF(!(addr & 1)) {
 554                 int wait_0, wait_1;
 555                 uint32_t val;
 556                 val  = read_memory_mapped_io16w(addr,     &wait_0);
 557                 val |= read_memory_mapped_io16w(addr + 2, &wait_1) << 16;
 558                 *wait = wait_0 + wait_1;
 559                 return val;
 560         } else {
 561                 int wait_0, wait_1, wait_2;
 562                 uint32_t val;
 563                 val  = read_memory_mapped_io8w (addr,     &wait_0);
 564                 val |= read_memory_mapped_io16w(addr + 1, &wait_1) <<  8;
 565                 val |= read_memory_mapped_io8w (addr + 3, &wait_2) << 24;
 566                 *wait = wait_0 + wait_1 + wait_2;
 567                 return val;
 568         }
 569 }
 570
 571 //<! device to device
 572 void DEVICE::initialize_output_signals(outputs_t *items)
 573 {
 574         items->count = 0;
 575 }
 576
 577 void DEVICE::register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask, int shift)
 578 {
 579         int c = items->count++;
 580         items->item[c].device = device;
 581         items->item[c].id = id;
 582         items->item[c].mask = mask;
 583         items->item[c].shift = shift;
 584 }
 585
 586 void DEVICE::register_output_signal(outputs_t *items, DEVICE *device, int id, uint32_t mask)
 587 {
 588         int c = items->count++;
 589         items->item[c].device = device;
 590         items->item[c].id = id;
 591         items->item[c].mask = mask;
 592         items->item[c].shift = 0;
 593 }
 594
 595
 596 void DEVICE::write_signals(outputs_t *items, uint32_t data)
 597 {
 598         for(int i = 0; i < items->count; i++) {
 599                 output_t *item = &items->item[i];
 600                 int shift = item->shift;
 601                 uint32_t val = (shift < 0) ? (data >> (-shift)) : (data << shift);
 602                 uint32_t mask = (shift < 0) ? (item->mask >> (-shift)) : (item->mask << shift);
 603                 item->device->write_signal(item->id, val, mask);
 604         }
 605 }
 606
 607 void DEVICE::update_signal_mask(outputs_t *items, DEVICE *device, uint32_t mask)
 608 {
 609         if(items == NULL) return;
 610         int c = items->count;
 611         if(c <= 0) return;
 612         if(c >= MAX_OUTPUT) c = MAX_OUTPUT - 1;
 613         // if (ARG:device == NULL) apply to all devices.
 614         for(int i = 0; i < c; i++) {
 615                 if((device == NULL) || (device == items->item[i].device)) {
 616                         items->item[i].mask = mask;
 617                 }
 618         }
 619 }
 620
 621 void DEVICE::write_signal(int id, uint32_t data, uint32_t mask)
 622 {
 623 }
 624
 625 uint32_t DEVICE::read_signal(int ch)
 626 {
 627         return 0;
 628 }
 629
 630 //<! z80 daisy chain
 631 void DEVICE::set_context_intr(DEVICE* device, uint32_t bit)
 632 {
 633 }
 634
 635 void DEVICE::set_context_child(DEVICE* device)
 636 {
 637 }
 638
 639 DEVICE *DEVICE::get_context_child()
 640 {
 641         return NULL;
 642 }
 643
 644 void DEVICE::set_intr_iei(bool val)
 645 {
 646 }
 647
 648 void DEVICE::set_intr_line(bool line, bool pending, uint32_t bit)
 649 {
 650 }
 651
 652 // interrupt cpu to device
 653 uint32_t DEVICE::get_intr_ack()
 654 {
 655         return 0xff;
 656 }
 657
 658 void DEVICE::update_intr()
 659 {
 660
 661 }
 662
 663 void DEVICE::notify_intr_reti()
 664 {
 665 }
 666
 667 void DEVICE::notify_intr_ei()
 668 {
 669 }
 670
 671 void DEVICE::do_dma()
 672 {
 673 }
 674
 675 //<! cpu
 676 int DEVICE::run(int clock)
 677 {
 678         // when clock == -1, run one opecode
 679         return (clock == -1 ? 1 : clock);
 680 }
 681
 682 void DEVICE::set_extra_clock(int clock)
 683 {
 684 }
 685
 686 int DEVICE::get_extra_clock()
 687 {
 688         return 0;
 689 }
 690
 691 uint32_t DEVICE::get_pc()
 692 {
 693         return 0;
 694 }
 695
 696 uint32_t DEVICE::get_next_pc()
 697 {
 698         return 0;
 699 }
 700
 701 //<! bios
 702 bool DEVICE::bios_call_far_i86(uint32_t PC, uint16_t regs[], const uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag, int* cycles, uint64_t* total_cycles)
 703 {
 704         return false;
 705 }
 706 bool DEVICE::bios_int_i86(int intnum, uint16_t regs[], const uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag, int* cycles, uint64_t* total_cycles)
 707 {
 708         return false;
 709 }
 710 bool DEVICE::bios_call_far_ia32(uint32_t PC, uint32_t regs[], const uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag, int* cycles, uint64_t* total_cycles)
 711 {
 712         return false;
 713 }
 714 bool DEVICE::bios_int_ia32(int intnum, uint32_t regs[], const uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag, int* cycles, uint64_t* total_cycles)
 715 {
 716         return false;
 717 }
 718 bool DEVICE::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)
 719 {
 720         return false;
 721 }
 722
 723
 724
 725 // Sound input functions
 726
 727 void DEVICE::clear_sound_in_source(int bank)
 728 {
 729         if(event_manager == NULL) {
 730                 event_manager = vm->first_device->next_device;
 731         }
 732         event_manager->clear_sound_in_source(bank);
 733 }
 734
 735
 736
 737 // this function may be before (or after) initialize().
 738 int DEVICE::add_sound_in_source(int rate, int samples, int channels)
 739 {
 740         if(event_manager == NULL) return -1;
 741         return event_manager->add_sound_in_source(rate, samples, channels);
 742 }
 743
 744 // this function may be before (or after) initialize().
 745 int DEVICE::release_sound_in_source(int bank)
 746 {
 747         if(event_manager == NULL) return -1;
 748         return event_manager->release_sound_in_source(bank);
 749 }
 750
 751 bool DEVICE::is_sound_in_source_exists(int bank)
 752 {
 753         if(event_manager == NULL) {
 754                 event_manager = vm->first_device->next_device;
 755         }
 756         return event_manager->is_sound_in_source_exists(bank);
 757 }
 758
 759 int DEVICE::increment_sound_in_passed_data(int bank, double passed_usec)
 760 {
 761         if(event_manager == NULL) {
 762                 return 0;
 763         }
 764         return event_manager->increment_sound_in_passed_data(bank, passed_usec);
 765 }
 766
 767 int DEVICE::get_sound_in_buffers_count()
 768 {
 769         if(event_manager == NULL) {
 770                 event_manager = vm->first_device->next_device;
 771         }
 772         return event_manager->get_sound_in_buffers_count();
 773 }
 774
 775 int DEVICE::get_sound_in_samples(int bank)
 776 {
 777         if(event_manager == NULL) {
 778                 event_manager = vm->first_device->next_device;
 779         }
 780         return event_manager->get_sound_in_samples(bank);
 781 }
 782
 783 int DEVICE::get_sound_in_rate(int bank)
 784 {
 785         if(event_manager == NULL) {
 786                 event_manager = vm->first_device->next_device;
 787         }
 788         return event_manager->get_sound_in_rate(bank);
 789 }
 790
 791 int DEVICE::get_sound_in_channels(int bank)
 792 {
 793         if(event_manager == NULL) {
 794                 event_manager = vm->first_device->next_device;
 795         }
 796         return event_manager->get_sound_in_channels(bank);
 797 }
 798
 799 // this function may be before (or after) initialize().
 800 int16_t* DEVICE::get_sound_in_buf_ptr(int bank)
 801 {
 802         if(event_manager == NULL) return NULL;
 803         return event_manager->get_sound_in_buf_ptr(bank);
 804 }
 805
 806 int DEVICE::write_sound_in_buffer(int bank, int32_t* src, int samples)
 807 {
 808         if(event_manager == NULL) {
 809                 event_manager = vm->first_device->next_device;
 810         }
 811         return event_manager->write_sound_in_buffer(bank, src, samples);
 812 }
 813
 814 // Add sampled values to sample buffer;value may be -32768 to +32767.
 815 // this function may be before (or after) initialize().
 816 int DEVICE::get_sound_in_latest_data(int bank, int32_t* dst, int expect_channels)
 817 {
 818         if(event_manager == NULL) return 0;
 819         return event_manager->get_sound_in_latest_data(bank, dst, expect_channels);
 820 }
 821
 822 int DEVICE::get_sound_in_data(int bank, int32_t* dst, int expect_samples, int expect_rate, int expect_channels)
 823 {
 824         if(event_manager == NULL) return -1;
 825         return event_manager->get_sound_in_data(bank, dst, expect_samples, expect_rate, expect_channels);
 826 }
 827
 828 void DEVICE::set_high_pass_filter_freq(int freq, double quality)
 829 {
 830 }
 831
 832 void DEVICE::set_low_pass_filter_freq(int freq, double quality)
 833 {
 834 }
 835
 836 int DEVICE::get_event_manager_id()
 837 {
 838         if(event_manager == NULL) {
 839                 event_manager = vm->first_device->next_device;
 840         }
 841         return event_manager->this_device_id;
 842 }
 843
 844 uint32_t DEVICE::get_event_clocks()
 845 {
 846         if(event_manager == NULL) {
 847                 event_manager = vm->first_device->next_device;
 848         }
 849         return event_manager->get_event_clocks();
 850 }
 851
 852 bool DEVICE::is_primary_cpu(DEVICE* device)
 853 {
 854         if(event_manager == NULL) {
 855                 event_manager = vm->first_device->next_device;
 856         }
 857         return event_manager->is_primary_cpu(device);
 858 }
 859
 860 uint32_t DEVICE::get_cpu_clocks(DEVICE* device)
 861 {
 862         if(event_manager == NULL) {
 863                 event_manager = vm->first_device->next_device;
 864         }
 865         return event_manager->get_cpu_clocks(device);
 866 }
 867 void DEVICE::update_extra_event(int clock)
 868 {
 869         if(event_manager == NULL) {
 870                 event_manager = vm->first_device->next_device;
 871         }
 872         event_manager->update_extra_event(clock);
 873 }
 874
 875 void DEVICE::register_event(DEVICE* device, int event_id, double usec, bool loop, int* register_id)
 876 {
 877         if(event_manager == NULL) {
 878                 event_manager = vm->first_device->next_device;
 879         }
 880         event_manager->register_event(device, event_id, usec, loop, register_id);
 881 }
 882
 883 void DEVICE::register_event_by_clock(DEVICE* device, int event_id, uint64_t clock, bool loop, int* register_id)
 884 {
 885         if(event_manager == NULL) {
 886                 event_manager = vm->first_device->next_device;
 887         }
 888         event_manager->register_event_by_clock(device, event_id, clock, loop, register_id);
 889 }
 890
 891 void DEVICE::cancel_event(DEVICE* device, int register_id)
 892 {
 893         if(event_manager == NULL) {
 894                 event_manager = vm->first_device->next_device;
 895         }
 896         event_manager->cancel_event(device, register_id);
 897 }
 898
 899 // Clear and DE-Register EVENT at slot evid.
 900 void DEVICE::clear_event(DEVICE* dev, int& evid)
 901 {
 902         if(evid > -1) {
 903                 cancel_event(dev, evid);
 904         }
 905         evid = -1;
 906 }
 907
 908 // Register a EVENT to evid (and update evid) , even if evid's slot is used.
 909 void DEVICE::force_register_event(DEVICE* dev, int event_num, double usec, bool loop, int& evid)
 910 {
 911         clear_event(dev, evid);
 912         register_event(dev, event_num, usec, loop, &evid);
 913 }
 914
 915 void DEVICE::force_register_event_by_clock(DEVICE* dev, int event_num, uint64_t clock, bool loop, int& evid)
 916 {
 917         clear_event(dev, evid);
 918         register_event_by_clock(dev, event_num, clock, loop, &evid);
 919 }
 920
 921 // Register a EVENT to evid , if evid slot isn't used.
 922 void DEVICE::check_and_update_event(DEVICE* dev, int event_num, double usec, bool loop, int& evid)
 923 {
 924         if(evid > -1) return;
 925         register_event(dev, event_num, usec, loop, &evid);
 926 }
 927
 928 void DEVICE::check_and_update_event_by_clock(DEVICE* dev, int event_num, uint64_t clock, bool loop, int& evid)
 929 {
 930         if(evid > -1) return;
 931         register_event_by_clock(dev, event_num, clock, loop, &evid);
 932 }
 933
 934
 935 void DEVICE::register_frame_event(DEVICE* device)
 936 {
 937         if(event_manager == NULL) {
 938                 event_manager = vm->first_device->next_device;
 939         }
 940         event_manager->register_frame_event(device);
 941 }
 942 void DEVICE::register_vline_event(DEVICE* device)
 943 {
 944         if(event_manager == NULL) {
 945                 event_manager = vm->first_device->next_device;
 946         }
 947         event_manager->register_vline_event(device);
 948 }
 949
 950 uint32_t DEVICE::get_event_remaining_clock(int register_id)
 951 {
 952         if(event_manager == NULL) {
 953                 event_manager = vm->first_device->next_device;
 954         }
 955         return event_manager->get_event_remaining_clock(register_id);
 956 }
 957
 958 double DEVICE::get_event_remaining_usec(int register_id)
 959 {
 960         if(event_manager == NULL) {
 961                 event_manager = vm->first_device->next_device;
 962         }
 963         return event_manager->get_event_remaining_usec(register_id);
 964 }
 965
 966 uint32_t DEVICE::get_current_clock()
 967 {
 968         __UNLIKELY_IF(event_manager == NULL) {
 969                 event_manager = vm->first_device->next_device;
 970         }
 971         return event_manager->get_current_clock();
 972 }
 973
 974 uint32_t DEVICE::get_passed_clock(uint32_t prev)
 975 {
 976         __UNLIKELY_IF(event_manager == NULL) {
 977                 event_manager = vm->first_device->next_device;
 978         }
 979         return event_manager->get_passed_clock(prev);
 980 }
 981
 982 double DEVICE::get_passed_usec(uint32_t prev)
 983 {
 984         __UNLIKELY_IF(event_manager == NULL) {
 985                 event_manager = vm->first_device->next_device;
 986         }
 987         return event_manager->get_passed_usec(prev);
 988 }
 989
 990 uint32_t DEVICE::get_passed_clock_since_vline()
 991 {
 992         __UNLIKELY_IF(event_manager == NULL) {
 993                 event_manager = vm->first_device->next_device;
 994         }
 995         return event_manager->get_passed_clock_since_vline();
 996 }
 997
 998 double DEVICE::get_passed_usec_since_vline()
 999 {
1000         __UNLIKELY_IF(event_manager == NULL) {
1001                 event_manager = vm->first_device->next_device;
1002         }
1003         return event_manager->get_passed_usec_since_vline();
1004 }
1005
1006 int DEVICE::get_cur_vline()
1007 {
1008         __UNLIKELY_IF(event_manager == NULL) {
1009                 event_manager = vm->first_device->next_device;
1010         }
1011         return event_manager->get_cur_vline();
1012 }
1013
1014 int DEVICE::get_cur_vline_clocks()
1015 {
1016         __UNLIKELY_IF(event_manager == NULL) {
1017                 event_manager = vm->first_device->next_device;
1018         }
1019         return event_manager->get_cur_vline_clocks();
1020 }
1021
1022 uint32_t DEVICE::get_cpu_pc(int index)
1023 {
1024         __UNLIKELY_IF(event_manager == NULL) {
1025                 event_manager = vm->first_device->next_device;
1026         }
1027         return event_manager->get_cpu_pc(index);
1028 }
1029
1030 uint64_t DEVICE::get_current_clock_uint64()
1031 {
1032         __UNLIKELY_IF(event_manager == NULL) {
1033                 event_manager = vm->first_device->next_device;
1034         }
1035         return event_manager->get_current_clock_uint64();
1036 }
1037
1038 uint32_t DEVICE::get_cpu_clock(int index)
1039 {
1040         __UNLIKELY_IF(event_manager == NULL) {
1041                 event_manager = vm->first_device->next_device;
1042         }
1043         return event_manager->get_cpu_clock(index);
1044 }
1045
1046 void DEVICE::request_skip_frames()
1047 {
1048         __UNLIKELY_IF(event_manager == NULL) {
1049                 event_manager = vm->first_device->next_device;
1050         }
1051         event_manager->request_skip_frames();
1052 }
1053
1054 void DEVICE::set_frames_per_sec(double frames)
1055 {
1056         __UNLIKELY_IF(event_manager == NULL) {
1057                 event_manager = vm->first_device->next_device;
1058         }
1059         event_manager->set_frames_per_sec(frames);
1060 }
1061
1062 void DEVICE::set_lines_per_frame(int lines)
1063 {
1064         __UNLIKELY_IF(event_manager == NULL) {
1065                 event_manager = vm->first_device->next_device;
1066         }
1067         event_manager->set_lines_per_frame(lines);
1068 }
1069
1070 int DEVICE::get_lines_per_frame()
1071 {
1072         __UNLIKELY_IF(event_manager == NULL) {
1073                 event_manager = vm->first_device->next_device;
1074         }
1075         return event_manager->get_lines_per_frame();
1076 }
1077
1078 // Force render sound immediately when device's status has changed.
1079 // You must call this after you changing registers (or anything).
1080 // If has problems, try set_realtime_render.
1081 // See mb8877.cpp and ym2203.cpp.
1082 // -- 20161010 K.O
1083 void DEVICE::touch_sound(void)
1084 {
1085         __UNLIKELY_IF(event_manager == NULL) {
1086                 event_manager = vm->first_device->next_device;
1087         }
1088         event_manager->touch_sound();
1089 }
1090 // Force render per 1 sample automatically.
1091 // See pcm1bit.cpp .
1092 // -- 20161010 K.O
1093 void DEVICE::set_realtime_render(DEVICE *device, bool flag)
1094 {
1095         __UNLIKELY_IF(event_manager == NULL) {
1096                 event_manager = vm->first_device->next_device;
1097         }
1098         __UNLIKELY_IF(device != event_manager) event_manager->set_realtime_render(device, flag);
1099 }
1100
1101 void DEVICE::update_timing(int new_clocks, double new_frames_per_sec, int new_lines_per_frame)
1102 {
1103 }
1104
1105 //!< event callback
1106 void DEVICE::event_callback(int event_id, int err)
1107 {
1108 }
1109
1110 void DEVICE::event_pre_frame()
1111 {
1112         // this event is to update timing settings
1113 }
1114
1115 void DEVICE::event_frame()
1116 {
1117         // this event is to update timing settings
1118 }
1119
1120 void DEVICE::event_vline(int v, int clock)
1121 {
1122 }
1123
1124 void DEVICE::event_hsync(int v, int h, int clock)
1125 {
1126 }
1127
1128 void DEVICE::mix(int32_t* buffer, int cnt)
1129 {
1130 }
1131
1132 void DEVICE::set_volume(int ch, int decibel_l, int decibel_r)
1133 {
1134         // +1 equals +0.5dB (same as fmgen)
1135 }
1136
1137 void DEVICE::get_volume(int ch, int &decibel_l, int &decibel_r)
1138 {
1139         decibel_l = 0;
1140         decibel_r = 0;
1141 }
1142
1143 void DEVICE::set_device_name(const _TCHAR *format, ...)
1144 {
1145         if(format != NULL) {
1146                 va_list ap;
1147                 _TCHAR buffer[1024];
1148
1149                 va_start(ap, format);
1150                 my_vstprintf_s(buffer, 1024, format, ap);
1151                 va_end(ap);
1152
1153                 my_tcscpy_s(this_device_name, 128, buffer);
1154 #ifdef _USE_QT
1155                 emu->get_osd()->set_vm_node(this_device_id, buffer);
1156 #endif
1157         }
1158 }
1159
1160 void DEVICE::out_debug_log(const char *fmt, ...)
1161 {
1162 #if defined(_USE_QT)
1163         __UNLIKELY_IF(osd == nullptr) return;
1164         char strbuf[4096] = {0};
1165         va_list ap;
1166
1167         va_start(ap, fmt);
1168         vsnprintf(strbuf, 4095, fmt, ap);
1169         va_end(ap);
1170         osd->debug_log(CSP_LOG_DEBUG, this_device_id + CSP_LOG_TYPE_VM_DEVICE_0,  strbuf);
1171 #else
1172         char strbuf[4096] = {0};
1173         va_list ap;
1174
1175         va_start(ap, fmt);
1176         vsnprintf(strbuf, 4095, fmt, ap);
1177         emu->out_debug_log("%s", strbuf);
1178         va_end(ap);
1179 #endif
1180 }
1181
1182 void DEVICE::out_debug_log_with_switch(bool logging, const char *fmt, ...)
1183 {
1184         if(!(logging)) return;
1185 #if defined(_USE_QT)
1186         __UNLIKELY_IF(osd == nullptr) return;
1187         char strbuf[4096] = {0};
1188         va_list ap;
1189
1190         va_start(ap, fmt);
1191         vsnprintf(strbuf, 4095, fmt, ap);
1192         va_end(ap);
1193         osd->debug_log(CSP_LOG_DEBUG, this_device_id + CSP_LOG_TYPE_VM_DEVICE_0, strbuf);
1194
1195 #else
1196         char strbuf[4096];
1197         va_list ap;
1198
1199         va_start(ap, fmt);
1200         vsnprintf(strbuf, 4095, fmt, ap);
1201         emu->out_debug_log("%s", strbuf);
1202         va_end(ap);
1203 #endif
1204 }
1205
1206 void DEVICE::force_out_debug_log(const char *fmt, ...)
1207 {
1208         char strbuf[4096];
1209         va_list ap;
1210
1211         va_start(ap, fmt);
1212         vsnprintf(strbuf, 4095, fmt, ap);
1213         emu->force_out_debug_log("%s", strbuf);
1214         va_end(ap);
1215 }
1216
1217 // debugger
1218
1219 void DEVICE::write_debug_data8(uint32_t addr, uint32_t data)
1220 {
1221 //              write_data8(addr, data);
1222 }
1223
1224 uint32_t DEVICE::read_debug_data8(uint32_t addr)
1225 {
1226 //              return read_data8(addr);
1227         return 0xff;
1228 }
1229
1230 void DEVICE::write_debug_data16(uint32_t addr, uint32_t data)
1231 {
1232         write_debug_data8(addr, data & 0xff);
1233         write_debug_data8(addr + 1, (data >> 8) & 0xff);
1234 }
1235
1236 uint32_t DEVICE::read_debug_data16(uint32_t addr)
1237 {
1238         uint32_t val = read_debug_data8(addr);
1239         val |= read_debug_data8(addr + 1) << 8;
1240         return val;
1241 }
1242
1243 void DEVICE::write_debug_data32(uint32_t addr, uint32_t data)
1244 {
1245         write_debug_data16(addr, data & 0xffff);
1246         write_debug_data16(addr + 2, (data >> 16) & 0xffff);
1247 }
1248
1249 uint32_t DEVICE::read_debug_data32(uint32_t addr)
1250 {
1251         uint32_t val = read_debug_data16(addr);
1252         val |= read_debug_data16(addr + 2) << 16;
1253         return val;
1254 }
1255
1256 void DEVICE::write_debug_io8(uint32_t addr, uint32_t data)
1257 {
1258 //              write_io8(addr, data);
1259 }
1260
1261 uint32_t DEVICE::read_debug_io8(uint32_t addr)
1262 {
1263 //              return read_io8(addr);
1264         return 0xff;
1265 }
1266
1267 void DEVICE::write_debug_io16(uint32_t addr, uint32_t data)
1268 {
1269         write_debug_io8(addr, data & 0xff);
1270         write_debug_io8(addr + 1, (data >> 8) & 0xff);
1271 }
1272
1273 uint32_t DEVICE::read_debug_io16(uint32_t addr)
1274 {
1275         uint32_t val = read_debug_io8(addr);
1276         val |= read_debug_io8(addr + 1) << 8;
1277         return val;
1278 }
1279
1280 void DEVICE::write_debug_io32(uint32_t addr, uint32_t data)
1281 {
1282         write_debug_io16(addr, data & 0xffff);
1283         write_debug_io16(addr + 2, (data >> 16) & 0xffff);
1284 }
1285
1286 uint32_t DEVICE::read_debug_io32(uint32_t addr)
1287 {
1288         uint32_t val = read_debug_io16(addr);
1289         val |= read_debug_io16(addr + 2) << 16;
1290         return val;
1291 }
1292
1293 bool DEVICE::write_debug_reg(const _TCHAR *reg, uint32_t data)
1294 {
1295         return false;
1296 }
1297
1298 uint32_t DEVICE::read_debug_reg(const _TCHAR *reg)
1299 {
1300         return 0;
1301 }
1302
1303 bool DEVICE::get_debug_regs_info(_TCHAR *buffer, size_t buffer_len)
1304 {
1305         return false;
1306 }
1307
1308 bool DEVICE::get_debug_regs_description(_TCHAR *buffer, size_t buffer_len)
1309 {
1310         return false;
1311 }
1312
1313 int DEVICE::debug_dasm(uint32_t pc, _TCHAR *buffer, size_t buffer_len)
1314 {
1315         return debug_dasm_with_userdata(pc, buffer, buffer_len, 0);
1316 }
1317
1318 int DEVICE::debug_dasm_with_userdata(uint32_t pc, _TCHAR *buffer, size_t buffer_len, uint32_t userdata)
1319 {
1320         return 0;
1321 }
1322
1323 bool DEVICE::debug_rewind_call_trace(uint32_t pc, int &size, _TCHAR* buffer, size_t buffer_len, uint64_t userdata)
1324 {
1325                 size = 0;
1326                 return false;
1327 }
1328
1329 void DEVICE::write_via_debugger_data8(uint32_t addr, uint32_t data)
1330 {
1331 }
1332
1333 uint32_t DEVICE::read_via_debugger_data8(uint32_t addr)
1334 {
1335         return 0xff;
1336 }
1337
1338 void DEVICE::write_via_debugger_data16(uint32_t addr, uint32_t data)
1339 {
1340 }
1341
1342 uint32_t DEVICE::read_via_debugger_data16(uint32_t addr)
1343 {
1344         return 0xffff;
1345 }
1346
1347 void DEVICE::write_via_debugger_data32(uint32_t addr, uint32_t data)
1348 {
1349 }
1350
1351 uint32_t DEVICE::read_via_debugger_data32(uint32_t addr)
1352 {
1353         return 0xffffffff;
1354 }
1355
1356 void DEVICE::write_via_debugger_data8w(uint32_t addr, uint32_t data, int* wait)
1357 {
1358         *wait = 0;
1359 }
1360
1361 uint32_t DEVICE::read_via_debugger_data8w(uint32_t addr, int* wait)
1362 {
1363         *wait = 0;
1364         return 0xff;
1365 }
1366
1367 void DEVICE::write_via_debugger_data16w(uint32_t addr, uint32_t data, int* wait)
1368 {
1369         *wait = 0;
1370 }
1371
1372 uint32_t DEVICE::read_via_debugger_data16w(uint32_t addr, int* wait)
1373 {
1374         *wait = 0;
1375         return 0xffff;
1376 }
1377
1378 void DEVICE::write_via_debugger_data32w(uint32_t addr, uint32_t data, int* wait)
1379 {
1380 }
1381
1382 uint32_t DEVICE::read_via_debugger_data32w(uint32_t addr, int* wait)
1383 {
1384         *wait = 0;
1385         return 0xffffffff;
1386 }
1387
1388 void DEVICE::write_via_debugger_io8(uint32_t addr, uint32_t data)
1389 {
1390 }
1391
1392 uint32_t DEVICE::read_via_debugger_io8(uint32_t addr)
1393 {
1394         return 0xff;
1395 }
1396
1397 void DEVICE::write_via_debugger_io16(uint32_t addr, uint32_t data)
1398 {
1399 }
1400
1401 uint32_t DEVICE::read_via_debugger_io16(uint32_t addr)
1402 {
1403         return 0xffff;
1404 }
1405
1406 void DEVICE::write_via_debugger_io32(uint32_t addr, uint32_t data)
1407 {
1408 }
1409
1410 uint32_t DEVICE::read_via_debugger_io32(uint32_t addr)
1411 {
1412         return 0xffffffff;
1413 }
1414
1415 void DEVICE::write_via_debugger_io8w(uint32_t addr, uint32_t data, int* wait)
1416 {
1417         *wait = 0;
1418 //      write_io8w(addr, data, wait);
1419 }
1420
1421 uint32_t DEVICE::read_via_debugger_io8w(uint32_t addr, int* wait)
1422 {
1423         // return read_io8w(addr, wait);
1424         *wait = 0;
1425         return 0xff;
1426 }
1427
1428 void DEVICE::write_via_debugger_io16w(uint32_t addr, uint32_t data, int* wait)
1429 {
1430         *wait = 0;
1431 }
1432
1433 uint32_t DEVICE::read_via_debugger_io16w(uint32_t addr, int* wait)
1434 {
1435         *wait = 0;
1436         return 0xffff;
1437 }
1438 void DEVICE::write_via_debugger_io32w(uint32_t addr, uint32_t data, int* wait)
1439 {
1440         *wait = 0;
1441 }
1442
1443 uint32_t DEVICE::read_via_debugger_io32w(uint32_t addr, int* wait)
1444 {
1445         *wait = 0;
1446         return 0xffffffff;
1447 }
1448
1449 bool DEVICE::address_translate_for_bios(int space, int intention, uint64_t &taddress)
1450 {
1451         return true; // If don't present address translation, translation succeed.
1452 }
1453
1454 const _TCHAR *DEVICE::get_lib_common_vm_version(void)
1455 {
1456 #if defined(__LIBRARY_NAME)
1457         return (const _TCHAR *)__LIBRARY_NAME;
1458 #else
1459         return (const _TCHAR *)"\0";
1460 #endif
1461 }
1462
1463
1464 void DEVICE::update_config()
1465 {
1466 }
1467
1468 void DEVICE::save_state(FILEIO* state_fio)
1469 {
1470 }
1471
1472 bool DEVICE::load_state(FILEIO* state_fio)
1473 {
1474         return true;
1475 }
1476
1477 bool DEVICE::process_state(FILEIO* state_fio, bool loading)
1478 {
1479         if(loading) {
1480                 return load_state(state_fio);
1481         } else {
1482                 save_state(state_fio);
1483                 return true;
1484         }
1485 }