source/src/vm/fmtowns/cdrom.h

   1 /*
   2         FUJITSU FM Towns Emulator 'eFMTowns'
   3
   4         Author : Kyuma.Ohta <whatisthis.sowhat _at_ gmail.com>
   5         Date   : 2019.01.31 -
   6
   7         [FM-Towns CD-ROM based on SCSI CDROM]
   8 */
   9 #pragma once
  10
  11 #include "../../common.h"
  12 #include "../device.h"
  13
  14
  15 // 0 - 9 : SCSI_CDROM::
  16 // 100 - : SCSI_DEV::
  17 #define SIG_TOWNS_CDROM_PLAYING                         0
  18 #define SIG_TOWNS_CDROM_SAMPLE_L                        1
  19 #define SIG_TOWNS_CDROM_SAMPLE_R                        2
  20 #define SIG_TOWNS_CDROM_CDDA_PLAY                       3
  21 #define SIG_TOWNS_CDROM_CDDA_STOP                       4
  22 #define SIG_TOWNS_CDROM_CDDA_PAUSE                      5
  23
  24 #define SIG_TOWNS_CDROM_SET_TRACK                       0x10
  25 #define SIG_TOWNS_CDROM_MAX_TRACK                       0x11
  26 #define SIG_TOWNS_CDROM_IS_MEDIA_INSERTED       0x12
  27 #define SIG_TOWNS_CDROM_REACHED_MAX_TRACK       0x13
  28 #define SIG_TOWNS_CDROM_CURRENT_TRACK           0x14
  29 #define SIG_TOWNS_CDROM_START_MSF                       0x15
  30 #define SIG_TOWNS_CDROM_START_MSF_AA            0x16
  31 #define SIG_TOWNS_CDROM_GET_ADR                         0x17
  32 #define SIG_TOWNS_CDROM_SET_STAT_TRACK          0x18
  33 #define SIG_TOWNS_CDROM_RELATIVE_MSF            0x20
  34 #define SIG_TOWNS_CDROM_ABSOLUTE_MSF            0x21
  35 #define SIG_TOWNS_CDROM_READ_DATA                       0x22
  36 #define SIG_TOWNS_CDROM_RESET                           0x23
  37 #define SIG_TOWNS_CDROM_DMAINT                          0x24
  38 #define SIG_TOWNS_CDROM_DMAACK                          0x25
  39 #define SIG_TOWNS_CDROM_MUTE_L                          0x29
  40 #define SIG_TOWNS_CDROM_MUTE_R                          0x2a
  41 #define SIG_TOWNS_CDROM_MUTE_ALL                        0x2b
  42
  43 class SCSI_HOST;
  44 class FIFO;
  45 class FILEIO;
  46 class DEBUGGER;
  47
  48 namespace FMTOWNS {
  49         #pragma pack(1)
  50         typedef union {
  51                 struct {
  52                         uint8_t P:1;
  53                         uint8_t Q:1;
  54                         uint8_t R:1;
  55                         uint8_t S:1;
  56                         uint8_t T:1;
  57                         uint8_t U:1;
  58                         uint8_t V:1;
  59                         uint8_t W:1;
  60                 } bit;
  61                 uint8_t byte;
  62         } SUBC_t;
  63 #pragma pack()
  64         /*!
  65          * @note Belows are CD-ROM sector structuer.
  66          * @note See https://en.wikipedia.org/wiki/CD-ROM#Sector_structure .
  67          */
  68 #pragma pack(1)
  69         typedef struct {
  70                 uint8_t sync[12];
  71                 uint8_t addr_m;
  72                 uint8_t addr_s;
  73                 uint8_t addr_f;
  74                 uint8_t sector_type; //! 1 = MODE1, 2=MODE2
  75         } cd_data_head_t;
  76 #pragma pack()
  77 #pragma pack(1)
  78         /*!
  79          * @note ToDo: Still not implement crc32 and ecc.
  80          * @note 20201116 K.O
  81          */
  82         typedef struct {
  83                 cd_data_head_t header;
  84                 uint8_t data[2048];
  85                 uint8_t crc32[4]; //! CRC32 checksum.
  86                 uint8_t reserved[8];
  87                 uint8_t ecc[276]; //! ERROR CORRECTIOM DATA; by read solomon code.
  88         } cd_data_mode1_t;
  89 #pragma pack()
  90 #pragma pack(1)
  91         /*!
  92          *
  93          *
  94          */
  95         typedef struct {
  96                 cd_data_head_t header;
  97                 uint8_t data[2336];
  98         } cd_data_mode2_t;
  99 #pragma pack()
 100 #pragma pack(1)
 101         typedef struct {
 102                 uint8_t data[2352];
 103         } cd_audio_sector_t;
 104 #pragma pack()
 105 #pragma pack(1)
 106         /*!
 107          * @note ToDo: Add fake header and crc and ecc.
 108          * @note 20201116 K.O
 109          */
 110         typedef struct {
 111                 uint8_t data[2048];
 112         } cd_data_iso_t;
 113 #pragma pack()
 114 // From Towns Linux : include/linux/towns_cd.h
 115 enum {
 116         MODE_AUDIO = 0,
 117         MODE_MODE1_2352,
 118         MODE_MODE1_2048,
 119         MODE_CD_G,
 120         MODE_MODE2_2336,
 121         MODE_MODE2_2352,
 122         MODE_CDI_2336,
 123         MODE_CDI_2352,
 124         MODE_NONE
 125 };
 126 enum {
 127         CCD_PHASE_NULL = 0,
 128         CCD_PHASE_ENTRY = 1,
 129         CCD_PHASE_SESSION,
 130         CCD_PHASE_CLONECD,
 131         CCD_PHASE_DISC,
 132         CCD_PHASE_TRACK
 133 };
 134 enum {
 135         CCD_TYPE_NULL = 0,
 136         CCD_POINT = 1,
 137         CCD_CONTROL,
 138         CCD_PLBA,
 139         CCD_ALBA,
 140         CCD_INDEX_0,
 141         CCD_INDEX_1,
 142         CCD_MODE,
 143
 144         CCD_TOC_ENTRIES = 0x101,
 145         CCD_CDTEXT_LENGTH,
 146
 147         CCD_PREGAP_MODE = 0x201,
 148         CCD_PREGAP_SUBC
 149 };
 150
 151 enum {
 152         CDROM_READ_MODE1 = 1,
 153         CDROM_READ_MODE2 = 2,
 154         CDROM_READ_RAW   = 3,
 155         CDROM_READ_NONE = 0
 156 };
 157 enum {
 158         CDROM_COMMAND_SEEK =                    0x00,
 159         CDROM_COMMAND_READ_MODE2 =              0x01,
 160         CDROM_COMMAND_READ_MODE1 =              0x02,
 161         CDROM_COMMAND_READ_RAW   =              0x03,
 162         CDROM_COMMAND_PLAY_TRACK =              0x04,
 163         CDROM_COMMAND_READ_TOC =                0x05,
 164         CDROM_COMMAND_READ_CDDA_STATE = 0x06,
 165         CDROM_COMMAND_1F =                              0x1f,
 166         CDROM_COMMAND_SET_STATE =               0x80,
 167         CDROM_COMMAND_SET_CDDASET =             0x81,
 168         CDROM_COMMAND_STOP_CDDA =               0x84,
 169         CDROM_COMMAND_PAUSE_CDDA =              0x85,
 170         CDROM_COMMAND_RESUME_CDDA =             0x87,
 171 };
 172
 173 // STATUS[0].
 174 // Update from Tsugaru Thanks to Yamakawa-San.
 175 enum {
 176         TOWNS_CD_STATUS_ACCEPT                  = 0x00,
 177         TOWNS_CD_STATUS_NOT_ACCEPT              = 0x01,
 178         TOWNS_CD_STATUS_SEEK_COMPLETED  = 0x04,
 179         TOWNS_CD_STATUS_READ_DONE               = 0x06,
 180         TOWNS_CD_STATUS_PLAY_DONE               = 0x07,
 181         TOWNS_CD_STATUS_DOOR_OPEN_DONE  = 0x09,
 182         TOWNS_CD_STATUS_DISC_NOT_READY  = 0x10,
 183         TOWNS_CD_STATUS_DOOR_CLOSE_DONE = 0x10,
 184         TOWNS_CD_STATUS_STOP_DONE               = 0x11,
 185         TOWNS_CD_STATUS_PAUSE_DONE              = 0x12,
 186         TOWNS_CD_STATUS_RESUME_DONE             = 0x13,
 187         TOWNS_CD_STATUS_TOC_ADDR                = 0x16,
 188         TOWNS_CD_STATUS_TOC_DATA                = 0x17,
 189         TOWNS_CD_STATUS_SUBQ_READ               = 0x18,
 190         TOWNS_CD_STATUS_SUBQ_READ2              = 0x18,
 191         TOWNS_CD_STATUS_SUBQ_READ3              = 0x18,
 192         TOWNS_CD_STATUS_CMD_ABEND               = 0x21,
 193         TOWNS_CD_STATUS_DATA_READY              = 0x22,
 194         TOWNS_CD_STATUS_UNKNOWN                 = 0xff,
 195 };
 196
 197 // status[1] @ status[0] == 00h
 198 // From Tsugaru Thanks to Yamakawa-San.
 199 // Belows are quote from cdrom/cdrom.h for Tsugaru.
 200 //00H 04H xx xx   CDROM BIOS re-shoots command A0H if CDROM returns this code.       (0b00000100)
 201 //00H 08H xx xx   CDROM BIOS re-shoots command A0H if CDROM returns this code.       (0b00001000)
 202 //00H 0DH xx xx   CDROM BIOS Checking (2ndByte)&0x0D and wait for it to be non zero. (0b00001101)
 203 enum {
 204         TOWNS_CD_ACCEPT_NOERROR                 = 0x00,
 205         TOWNS_CD_ACCEPT_DATA_TRACK              = 0x01,
 206         TOWNS_CD_ACCEPT_CDDA_PLAYING    = 0x03,
 207         TOWNS_CD_ACCEPT_04H_FOR_CMD_A0H = 0x04,
 208         TOWNS_CD_ACCEPT_08H_FOR_CMD_A0H = 0x08,
 209         TOWNS_CD_ACCEPT_MEDIA_CHANGED   = 0x09,
 210         TOWNS_CD_ACCEPT_WAIT                    = 0x0d,
 211 };
 212
 213 // status[1] @ status[0] == 21h
 214 // From Tsugaru Thanks to Yamakawa-San.
 215 enum {
 216         TOWNS_CD_ABEND_PARAMETER_ERROR          = 0x01,
 217         TOWNS_CD_ABEND_ERR02                            = 0x02,
 218         TOWNS_CD_ABEND_HARDWARE_ERROR_03        = 0x03,
 219         TOWNS_CD_ABEND_HARDWARE_ERROR_04        = 0x04,
 220         TOWNS_CD_ABEND_READ_AUDIO_TRACK         = 0x05,
 221         TOWNS_CD_ABEND_MEDIA_ERROR_06           = 0x06,
 222         TOWNS_CD_ABEND_DRIVE_NOT_READY          = 0x07,
 223         TOWNS_CD_ABEND_MEDIA_CHANGED            = 0x08,
 224         TOWNS_CD_ABEND_HARDWARE_ERROR_09        = 0x09,
 225         TOWNS_CD_ABEND_ERROR_0C                         = 0x0c,
 226         TOWNS_CD_ABEND_HARDWARE_ERROR_0D        = 0x0d,
 227         TOWNS_CD_ABEND_RETRY                            = 0x0f, // Indicate RETRY ?
 228 };
 229
 230 enum {
 231         TOWNS_CD_READ_NONE = 0,
 232         TOWNS_CD_READ_MODE1,
 233         TOWNS_CD_READ_MODE2,
 234         TOWNS_CD_READ_RAW,
 235         TOWNS_CD_READ_CDDA,
 236         TOWNS_CD_STOP_CDDA,
 237         TOWNS_CD_PAUSE_CDDA,
 238         TOWNS_CD_UNPAUSE_CDDA,
 239 };
 240
 241 /*class TOWNS_CDROM : public SCSI_CDROM */
 242 class TOWNS_CDROM: public DEVICE {
 243 protected:
 244         outputs_t outputs_drq;
 245         outputs_t outputs_mcuint;
 246         FILEIO* fio_img;
 247 //      FIFO* subq_buffer;
 248         uint8_t sector_buffer[8192]; //!< main memory.Reading a sector.
 249         uint8_t prefetch_buffer[65536]; //!< prefetch buffer, this is only enabled after Towns2HR.
 250 //      FIFO* databuffer;
 251         FIFO* status_queue;
 252
 253         // For Debugging, will remove 20200822 K.O
 254         DEVICE* d_cpu;
 255         DEVICE* d_dmac;
 256
 257         uint32_t main_read_ptr;
 258         uint32_t main_write_ptr;
 259         int32_t main_left;
 260
 261         uint32_t prefetch_read_ptr;
 262         uint32_t prefetch_write_ptr;
 263         int32_t prefetch_left;
 264
 265         uint16_t cpu_id;
 266         uint16_t machine_id;
 267
 268         uint8_t data_reg;
 269         bool dma_transfer;
 270         bool pio_transfer;
 271         bool dma_transfer_phase;
 272         bool pio_transfer_phase;
 273
 274         bool cdrom_halted;
 275         bool status_seek;
 276
 277         SUBC_t subq_buffer[98]; // OK?
 278         int subq_bitptr;
 279         int subq_bitwidth;
 280         bool subq_overrun;
 281         bool is_playing;
 282         uint8_t next_status_byte;
 283
 284         int stat_track;
 285
 286         bool is_cue;
 287         bool is_iso;
 288         struct {
 289                 uint8_t type;
 290                 int32_t index0, index1, pregap;
 291                 uint32_t lba_offset;
 292                 uint32_t lba_size;
 293                 bool is_audio;
 294                 int physical_size;
 295                 int logical_size;
 296         } toc_table[1024];
 297         _TCHAR track_data_path[100][_MAX_PATH];
 298         _TCHAR img_file_path_bak[_MAX_PATH];
 299         bool with_filename[100];
 300
 301         uint32_t cdda_start_frame;
 302         uint32_t cdda_end_frame;
 303         uint32_t cdda_playing_frame;
 304         uint32_t cdda_loading_frame;
 305         int cdda_status;
 306         int cdda_repeat_count;
 307         bool cdda_interrupt;
 308         int cdda_buffer_ptr;
 309
 310         int mix_loop_num;
 311         int current_track;
 312         int read_sector;
 313         int transfer_speed;
 314         int read_length;
 315         int read_length_bak;
 316         int next_seek_lba;
 317         int read_mode;
 318
 319         uint8_t prev_command;
 320         uint8_t latest_command;
 321         uint8_t reserved_command;
 322         bool req_status;
 323         bool stat_reply_intr;
 324         bool mcu_ready;
 325         bool has_status;
 326         bool mcu_intr;
 327         bool dma_intr;
 328         bool mcu_intr_mask;
 329         bool dma_intr_mask;
 330
 331         bool mcuint_val;
 332
 333         int event_drq;
 334         int event_seek;
 335         int event_next_sector;
 336         int event_seek_completed;
 337         int event_cdda;
 338         int event_cdda_delay_play;
 339         int event_cdda_delay_stop;
 340         int event_delay_interrupt;
 341         int event_delay_ready;
 342         int event_halt;
 343         int event_delay_command;
 344         int event_time_out;
 345         int event_eot;
 346
 347         int cdda_sample_l;
 348         int cdda_sample_r;
 349
 350         int _decibel_l;
 351         int _decibel_r;
 352         int volume_l;
 353         int volume_r;
 354
 355         bool mute_left;
 356         bool mute_right;
 357
 358         uint8_t w_regs[16];
 359         static const uint16_t crc_table[256];
 360
 361         int param_ptr;
 362         bool command_entered;
 363         bool param_filled;
 364         uint8_t param_pre_queue[8];
 365         uint8_t param_queue[8];
 366
 367         double seek_time;
 368         int track_num;
 369         uint32_t max_logical_block;
 370         int bytes_per_sec;
 371         bool access;
 372         bool media_changed;
 373         bool cdda_stopped;
 374         uint32_t read_lba;
 375
 376         bool cdrom_prefetch;
 377
 378         int extra_status;
 379         void play_cdda_from_cmd();
 380         void unpause_cdda_from_cmd();
 381         void stop_cdda_from_cmd();
 382         void pause_cdda_from_cmd();
 383
 384         bool is_device_ready();
 385         void reset_device();
 386         void read_a_cdda_sample();
 387
 388         void send_mcu_ready();
 389         void set_extra_status();
 390
 391         void set_status(bool _req_status, int extra, uint8_t s0, uint8_t s1, uint8_t s2, uint8_t s3);
 392         void set_status_read_done(bool _req_status, int extra, uint8_t s0, uint8_t s1, uint8_t s2, uint8_t s3);
 393         void set_status_cddareply(bool _req_status, int extra, uint8_t s0, uint8_t s1, uint8_t s2, uint8_t s3);
 394         void set_status_immediate(bool _req_status, int extra, uint8_t s0, uint8_t s1, uint8_t s2, uint8_t s3);
 395         void set_status_extra(uint8_t s0, uint8_t s1, uint8_t s2, uint8_t s3);
 396         void set_status_extra_toc_addr(uint8_t s1, uint8_t s2, uint8_t s3);
 397         void set_status_extra_toc_data(uint8_t s1, uint8_t s2, uint8_t s3);
 398         bool __FASTCALL check_cdda_track_boundary(uint32_t &frame_no);
 399         bool seek_relative_frame_in_image(uint32_t frame_no);
 400     int prefetch_audio_sectors(int read_secs);
 401         void read_cdrom();
 402         void read_cdrom_mode1();
 403         void read_cdrom_mode2();
 404         void read_cdrom_raw();
 405         bool check_notready_and_changed(bool force_int);
 406
 407         virtual void execute_command(uint8_t command);
 408
 409         void __FASTCALL status_not_ready(bool forceint);
 410         void __FASTCALL status_media_changed(bool forceint);
 411         void __FASTCALL status_hardware_error(bool forceint);
 412         void __FASTCALL status_parameter_error(bool forceint);
 413         void __FASTCALL status_read_done(bool forceint);
 414         void __FASTCALL status_data_ready(bool forceint);
 415
 416         void __FASTCALL status_accept(int extra, uint8_t s2, uint8_t s3);
 417         void __FASTCALL status_not_accept(int extra, uint8_t s1, uint8_t s2, uint8_t s3);
 418
 419         void __FASTCALL status_illegal_lba(int extra, uint8_t s1, uint8_t s2, uint8_t s3);
 420         void set_delay_ready();
 421         void set_delay_ready_nostatus();
 422         void set_delay_ready_eot();
 423         void set_delay_ready_cddareply();
 424
 425         uint32_t cdrom_get_adr(int trk);
 426
 427         void __FASTCALL set_dma_intr(bool val);
 428         void __FASTCALL set_mcu_intr(bool val);
 429
 430         void __FASTCALL make_bitslice_subc_q(uint8_t *data, int bitwidth);
 431         uint16_t __FASTCALL calc_subc_crc16(uint8_t *databuf, int bytes, uint16_t initval);
 432
 433         bool open_cue_file(const _TCHAR* file_path);
 434         bool parse_cue_file_args(std::string& _arg2, const _TCHAR *parent_dir, std::string& imgpath);
 435         void parse_cue_track(std::string &_arg2, int& nr_current_track, std::string imgpath);
 436         int parse_cue_index(std::string &_arg2, int nr_current_track);
 437
 438         virtual bool open_iso_file(const _TCHAR* file_path);
 439         virtual bool open_ccd_file(const _TCHAR* file_path, _TCHAR* img_file_path);
 440
 441         virtual uint8_t read_subq();
 442         virtual uint8_t get_subq_status();
 443         virtual void set_subq(void);
 444
 445         int get_track_noop(uint32_t lba);
 446         void get_track_by_track_num(int track);
 447
 448         uint32_t __FASTCALL lba_to_msf(uint32_t lba);
 449         uint32_t __FASTCALL lba_to_msf_alt(uint32_t lba);
 450         int __FASTCALL get_frames_from_msf(const char *s);
 451         int64_t __FASTCALL hexatoi(const char *s);
 452         int64_t __FASTCALL string_to_numeric(std::string s);
 453
 454         virtual void open_from_cmd(const _TCHAR* file_path);
 455         virtual void close_from_cmd();
 456         virtual void do_dma_eot(bool by_signal);
 457
 458         void __FASTCALL write_mcuint_signals(uint32_t val)
 459         {
 460                 mcuint_val = (val != 0) ? true : false;
 461                 write_signals(&outputs_mcuint, val);
 462         }
 463         void cdrom_debug_log(const char *fmt, ...);
 464
 465         bool __CDROM_DEBUG_LOG;
 466         bool _USE_CDROM_PREFETCH;
 467         bool force_logging;
 468 public:
 469         TOWNS_CDROM(VM_TEMPLATE* parent_vm, EMU_TEMPLATE* parent_emu) : DEVICE(parent_vm, parent_emu)
 470         {
 471 //              seek_time = 400000; // 400msec (temporary)
 472                 seek_time = 10.0;
 473                 bytes_per_sec = 2048 * 75; // speed x1
 474                 max_logical_block = 0;
 475                 access = false;
 476                 databuffer = NULL;
 477                 status_queue = NULL;
 478                 _decibel_l = 0;
 479                 _decibel_r = 0;
 480
 481                 memset(subq_buffer, 0x00, sizeof(subq_buffer));
 482
 483                 initialize_output_signals(&outputs_drq);
 484                 initialize_output_signals(&outputs_mcuint);
 485                 set_device_name(_T("FM-Towns CD-ROM drive"));
 486                 d_dmac = NULL;
 487                 // For Debugging, will remove 20200822 K.O
 488                 d_cpu = NULL;
 489         }
 490         ~TOWNS_CDROM() { }
 491         virtual void initialize();
 492         virtual void release();
 493
 494         virtual void reset();
 495         virtual uint32_t __FASTCALL read_io8(uint32_t addr);
 496         virtual void __FASTCALL write_io8(uint32_t addr, uint32_t data);
 497         virtual uint32_t __FASTCALL read_dma_io8(uint32_t addr);
 498         virtual void __FASTCALL write_dma_io8(uint32_t addr, uint32_t data);
 499
 500         virtual void __FASTCALL write_signal(int id, uint32_t data, uint32_t mask);
 501         virtual uint32_t __FASTCALL read_signal(int id);
 502
 503         virtual void __FASTCALL event_callback(int event_id, int err);
 504         virtual void __FASTCALL mix(int32_t* buffer, int cnt);
 505
 506         virtual bool process_state(FILEIO* state_fio, bool loading);
 507
 508         virtual bool mounted();
 509         virtual bool accessed();
 510         virtual void open(const _TCHAR* file_path);
 511         virtual void close();
 512
 513         // for debug
 514         virtual void __FASTCALL write_debug_data8(uint32_t addr, uint32_t data);
 515         virtual uint32_t __FASTCALL read_debug_data8(uint32_t addr);
 516         virtual bool get_debug_regs_info(_TCHAR *buffer, size_t buffer_len);
 517         virtual bool write_debug_reg(const _TCHAR *reg, uint32_t data);
 518         bool is_debugger_available()
 519         {
 520                 return true;
 521         }
 522         uint64_t get_debug_data_addr_space()
 523         {
 524                 return 0x1fff; // Will change
 525         }
 526
 527
 528         virtual void set_volume(int ch, int decibel_l, int decibel_r);
 529         virtual void get_volume(int ch, int& decibel_l, int& decibel_r);
 530         virtual bool read_buffer(int sectors);
 531
 532         virtual bool read_raw(int sectors);
 533         virtual bool read_mode1(int sectors);
 534         virtual bool read_mode2(int sectors);
 535         virtual bool read_mode1_iso(int sectors);
 536
 537         // unique functions
 538         // Towns specified command
 539         virtual void set_cdda_status(uint8_t status);
 540         int get_track(uint32_t lba);
 541         virtual double get_seek_time(uint32_t lba);
 542         virtual uint8_t read_status();
 543         virtual const int logical_block_size();
 544         virtual const int physical_block_size();
 545         virtual bool write_a_byte(uint8_t val)
 546         {
 547                 uint32_t n = val;
 548                 n = n & 0xff;
 549 //              if(databuffer->count() >= fifo_length) {
 550 //                      return false;
 551 //              }
 552                 databuffer->write((int)n);
 553                 return true;
 554         }
 555         virtual bool write_bytes(uint8_t* val, int bytes)
 556         {
 557                 int n_count = databuffer->count();
 558                 if((val == NULL) ||
 559                    (n_count >= max_fifo_length) || ((n_count + bytes) >= fifo_length)) {
 560                         return false;
 561                 }
 562                 for(int i = 0; i < bytes; i++) {
 563                         int d = ((int)val[i]) & 0xff ;
 564                         databuffer->write(d);
 565                 }
 566                 return true;
 567         }
 568         virtual bool change_buffer_size(int size)
 569         {
 570                 if((size <= 0) || (size >= max_fifo_length) || (databuffer == NULL)) return false;
 571                 uint8_t tbuf[size];
 572                 if(fifo_length > size) { // truncate
 573                         // Dummy read
 574                         for(int i = 0; i < (fifo_length - size); i++) {
 575                                 uint8_t dummy = (uint8_t)(databuffer->read() & 0xff);
 576                         }
 577                         for(int i = 0; i < size; i++) {
 578                                 tbuf[i] = (uint8_t)(databuffer->read() & 0xff);
 579                         }
 580                         databuffer->clear();
 581                         for(int i = 0; i < size; i++) {
 582                                 databuffer->write(tbuf[i]);
 583                         }
 584                 } else if(fifo_length < size) {
 585                         for(int i = 0; i < fifo_length; i++) {
 586                                 tbuf[i] = (uint8_t)(databuffer->read() & 0xff);
 587                         }
 588                         databuffer->clear();
 589                         for(int i = 0; i < fifo_length; i++) {
 590                                 databuffer->write(tbuf[i]);
 591                         }
 592 //                      for(int i = 0; i < (size - fifo_size); i++) {
 593 //                              databuffer->write(0);
 594 //                      }
 595                 }
 596                 fifo_length = size;
 597                 return true;
 598         }
 599         uint8_t get_cdda_status()
 600         {
 601                 return cdda_status;
 602         }
 603
 604         void set_machine_id(uint16_t val)
 605         {
 606                 machine_id = val & 0xfff8;
 607         }
 608         void set_cpu_id(uint16_t val)
 609         {
 610                 cpu_id = val & 0x07;
 611         }
 612
 613         void set_context_mpuint_line(DEVICE* dev, int id, uint32_t mask)
 614         {
 615                 register_output_signal(&outputs_mcuint, dev, id, mask);
 616         }
 617         void set_context_drq_line(DEVICE* dev, int id, uint32_t mask)
 618         {
 619                 register_output_signal(&outputs_drq, dev, id, mask);
 620         }
 621         void set_context_dmac(DEVICE* d)
 622         {
 623                 d_dmac = d;
 624         }
 625         // For Debugging, will remove 20200822 K.O
 626         void set_context_cpu(DEVICE* d)
 627         {
 628                 d_cpu = d;
 629         }
 630 };
 631
 632 }