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 SUBC_u {
  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 #pragma pack(1)
 115         /*!
 116          * @note
 117          * @note 20201116 K.O
 118          */
 119         typedef union cdimage_buffer_s {
 120                 uint8_t rawdata[2352]; //!< @note OK?
 121                 cd_data_mode1_t mode1;
 122                 cd_data_mode2_t mode2;
 123                 cd_audio_sector_t audio;
 124         } cdimage_buffer_t;
 125 #pragma pack()
 126
 127 // From Towns Linux : include/linux/towns_cd.h
 128 enum {
 129         MODE_AUDIO = 0,
 130         MODE_MODE1_2352,
 131         MODE_MODE1_2048,
 132         MODE_CD_G,
 133         MODE_MODE2_2336,
 134         MODE_MODE2_2352,
 135         MODE_CDI_2336,
 136         MODE_CDI_2352,
 137         MODE_NONE
 138 };
 139 enum {
 140         CCD_PHASE_NULL = 0,
 141         CCD_PHASE_ENTRY = 1,
 142         CCD_PHASE_SESSION,
 143         CCD_PHASE_CLONECD,
 144         CCD_PHASE_DISC,
 145         CCD_PHASE_TRACK
 146 };
 147 enum {
 148         CCD_TYPE_NULL = 0,
 149         CCD_POINT = 1,
 150         CCD_CONTROL,
 151         CCD_PLBA,
 152         CCD_ALBA,
 153         CCD_INDEX_0,
 154         CCD_INDEX_1,
 155         CCD_MODE,
 156
 157         CCD_TOC_ENTRIES = 0x101,
 158         CCD_CDTEXT_LENGTH,
 159
 160         CCD_PREGAP_MODE = 0x201,
 161         CCD_PREGAP_SUBC
 162 };
 163
 164 enum {
 165         CDROM_READ_MODE1 = 1,
 166         CDROM_READ_MODE2 = 2,
 167         CDROM_READ_RAW   = 3,
 168         CDROM_READ_AUDIO = 4,
 169         CDROM_READ_NONE = 0
 170 };
 171 enum {
 172         CDROM_COMMAND_SEEK =                    0x00,
 173         CDROM_COMMAND_READ_MODE2 =              0x01,
 174         CDROM_COMMAND_READ_MODE1 =              0x02,
 175         CDROM_COMMAND_READ_RAW   =              0x03,
 176         CDROM_COMMAND_PLAY_TRACK =              0x04,
 177         CDROM_COMMAND_READ_TOC =                0x05,
 178         CDROM_COMMAND_READ_CDDA_STATE = 0x06,
 179         CDROM_COMMAND_1F =                              0x1f,
 180         CDROM_COMMAND_SET_STATE =               0x80,
 181         CDROM_COMMAND_SET_CDDASET =             0x81,
 182         CDROM_COMMAND_STOP_CDDA =               0x84,
 183         CDROM_COMMAND_PAUSE_CDDA =              0x85,
 184         CDROM_COMMAND_RESUME_CDDA =             0x87,
 185 };
 186
 187 // STATUS[0].
 188 // Update from Tsugaru Thanks to Yamakawa-San.
 189 enum {
 190         TOWNS_CD_STATUS_ACCEPT                  = 0x00,
 191         TOWNS_CD_STATUS_NOT_ACCEPT              = 0x01,
 192         TOWNS_CD_STATUS_SEEK_COMPLETED  = 0x04,
 193         TOWNS_CD_STATUS_READ_DONE               = 0x06,
 194         TOWNS_CD_STATUS_PLAY_DONE               = 0x07,
 195         TOWNS_CD_STATUS_DOOR_OPEN_DONE  = 0x09,
 196         TOWNS_CD_STATUS_DISC_NOT_READY  = 0x10,
 197         TOWNS_CD_STATUS_DOOR_CLOSE_DONE = 0x10,
 198         TOWNS_CD_STATUS_STOP_DONE               = 0x11,
 199         TOWNS_CD_STATUS_PAUSE_DONE              = 0x12,
 200         TOWNS_CD_STATUS_RESUME_DONE             = 0x13,
 201         TOWNS_CD_STATUS_TOC_ADDR                = 0x16,
 202         TOWNS_CD_STATUS_TOC_DATA                = 0x17,
 203         TOWNS_CD_STATUS_SUBQ_READ               = 0x18,
 204         TOWNS_CD_STATUS_SUBQ_READ2              = 0x18,
 205         TOWNS_CD_STATUS_SUBQ_READ3              = 0x18,
 206         TOWNS_CD_STATUS_CMD_ABEND               = 0x21,
 207         TOWNS_CD_STATUS_DATA_READY              = 0x22,
 208         TOWNS_CD_STATUS_UNKNOWN                 = 0xff,
 209 };
 210
 211 // status[1] @ status[0] == 00h
 212 // From Tsugaru Thanks to Yamakawa-San.
 213 // Belows are quote from cdrom/cdrom.h for Tsugaru.
 214 //00H 04H xx xx   CDROM BIOS re-shoots command A0H if CDROM returns this code.       (0b00000100)
 215 //00H 08H xx xx   CDROM BIOS re-shoots command A0H if CDROM returns this code.       (0b00001000)
 216 //00H 0DH xx xx   CDROM BIOS Checking (2ndByte)&0x0D and wait for it to be non zero. (0b00001101)
 217 enum {
 218         TOWNS_CD_ACCEPT_NOERROR                 = 0x00,
 219         TOWNS_CD_ACCEPT_DATA_TRACK              = 0x01,
 220         TOWNS_CD_ACCEPT_CDDA_PAUSED             = 0x01,
 221         TOWNS_CD_ACCEPT_CDDA_PLAYING    = 0x03,
 222         TOWNS_CD_ACCEPT_04H_FOR_CMD_A0H = 0x04,
 223         TOWNS_CD_ACCEPT_08H_FOR_CMD_A0H = 0x08,
 224         TOWNS_CD_ACCEPT_MEDIA_CHANGED   = 0x09,
 225         TOWNS_CD_ACCEPT_WAIT                    = 0x0d,
 226 };
 227
 228 // status[1] @ status[0] == 21h
 229 // From Tsugaru Thanks to Yamakawa-San.
 230 enum {
 231         TOWNS_CD_ABEND_PARAMETER_ERROR          = 0x01,
 232         TOWNS_CD_ABEND_ERR02                            = 0x02,
 233         TOWNS_CD_ABEND_HARDWARE_ERROR_03        = 0x03,
 234         TOWNS_CD_ABEND_HARDWARE_ERROR_04        = 0x04,
 235         TOWNS_CD_ABEND_READ_AUDIO_TRACK         = 0x05,
 236         TOWNS_CD_ABEND_MEDIA_ERROR_06           = 0x06,
 237         TOWNS_CD_ABEND_DRIVE_NOT_READY          = 0x07,
 238         TOWNS_CD_ABEND_MEDIA_CHANGED            = 0x08,
 239         TOWNS_CD_ABEND_HARDWARE_ERROR_09        = 0x09,
 240         TOWNS_CD_ABEND_ERROR_0C                         = 0x0c,
 241         TOWNS_CD_ABEND_HARDWARE_ERROR_0D        = 0x0d,
 242         TOWNS_CD_ABEND_RETRY                            = 0x0f, // Indicate RETRY ?
 243 };
 244
 245 enum {
 246         TOWNS_CD_READ_NONE = 0,
 247         TOWNS_CD_READ_MODE1,
 248         TOWNS_CD_READ_MODE2,
 249         TOWNS_CD_READ_RAW,
 250         TOWNS_CD_READ_CDDA,
 251         TOWNS_CD_STOP_CDDA,
 252         TOWNS_CD_PAUSE_CDDA,
 253         TOWNS_CD_UNPAUSE_CDDA,
 254 };
 255
 256 /*class TOWNS_CDROM : public SCSI_CDROM */
 257 class TOWNS_CDROM: public DEVICE {
 258 protected:
 259         outputs_t outputs_drq;
 260         outputs_t outputs_mcuint;
 261         FILEIO* fio_img;
 262 //      FIFO* subq_buffer;
 263         FIFO* databuffer;
 264         FIFO* status_queue;
 265
 266         // For Debugging, will remove 20200822 K.O
 267         DEVICE* d_cpu;
 268         DEVICE* d_dmac;
 269
 270         uint32_t max_fifo_length;
 271         uint32_t fifo_length;
 272
 273         uint16_t cpu_id;
 274         uint16_t machine_id;
 275
 276         uint8_t data_reg;
 277         bool dma_transfer;
 278         bool pio_transfer;
 279         bool dma_transfer_phase;
 280         bool pio_transfer_phase;
 281
 282         bool cdrom_halted;
 283         bool status_seek;
 284
 285         SUBC_t subq_buffer[98]; // OK?
 286         int subq_bitptr;
 287         int subq_bitwidth;
 288         bool subq_overrun;
 289         bool is_playing;
 290
 291         int stat_track;
 292
 293         bool is_cue;
 294         bool is_iso;
 295         struct {
 296                 uint8_t type;
 297                 int32_t index0, index1, pregap;
 298                 uint32_t lba_offset;
 299                 uint32_t lba_size;
 300                 bool is_audio;
 301                 int physical_size;
 302                 int logical_size;
 303         } toc_table[108];
 304         _TCHAR track_data_path[100][_MAX_PATH];
 305         _TCHAR img_file_path_bak[_MAX_PATH];
 306         bool with_filename[100];
 307
 308         uint32_t cdda_start_frame;
 309         uint32_t cdda_end_frame;
 310         uint32_t cdda_playing_frame;
 311
 312         int cdda_status;
 313         int cdda_repeat_count;
 314         bool cdda_interrupt;
 315         int cdda_buffer_ptr;
 316
 317         int mix_loop_num;
 318         int current_track;
 319         int read_sector;
 320         int transfer_speed;
 321         int read_length;
 322
 323         int next_seek_lba;
 324         int read_mode;
 325
 326         uint8_t prev_command;
 327         uint8_t latest_command;
 328         uint8_t reserved_command;
 329         bool has_status;
 330         bool req_status;
 331
 332         bool stat_reply_intr;
 333         bool mcu_ready;
 334
 335         bool mcu_intr;
 336         bool dma_intr;
 337         bool mcu_intr_mask;
 338         bool dma_intr_mask;
 339
 340         bool mcuint_val;
 341
 342         int event_drq;
 343         int event_seek;
 344         int event_next_sector;
 345         int event_seek_completed;
 346         int event_cdda;
 347         int event_cdda_delay_play;
 348         int event_cdda_delay_stop;
 349         int event_delay_interrupt;
 350         int event_delay_ready;
 351         int event_halt;
 352         int event_delay_command;
 353         int event_time_out;
 354         int event_eot;
 355
 356         int cdda_sample_l;
 357         int cdda_sample_r;
 358
 359         int _decibel_l;
 360         int _decibel_r;
 361         int volume_l;
 362         int volume_r;
 363
 364         bool mute_left;
 365         bool mute_right;
 366
 367         uint8_t w_regs[16];
 368         static const uint16_t crc_table[256];
 369
 370         uint8_t param_ptr;
 371         bool command_entered;
 372         bool param_filled;
 373         uint8_t param_pre_queue[8];
 374         uint8_t param_queue[8];
 375
 376         bool command_received;
 377
 378         double seek_time;
 379         int track_num;
 380         uint32_t max_logical_block;
 381         int bytes_per_sec;
 382         bool access;
 383         bool media_changed;
 384         bool cdda_stopped;
 385         uint32_t read_lba;
 386
 387         bool cdrom_prefetch;
 388
 389         int extra_status;
 390         void play_cdda_from_cmd();
 391         void unpause_cdda_from_cmd();
 392         void stop_cdda_from_cmd();
 393         void pause_cdda_from_cmd();
 394
 395         bool is_device_ready();
 396         void reset_device();
 397         virtual void read_a_cdda_sample();
 398
 399         void send_mcu_ready();
 400         virtual void set_extra_status();
 401
 402         void set_status(bool _req_status, int extra, uint8_t s0, uint8_t s1, uint8_t s2, uint8_t s3);
 403         void set_status_read_done(bool _req_status, int extra, uint8_t s0, uint8_t s1, uint8_t s2, uint8_t s3);
 404         void set_status_cddareply(bool _req_status, int extra, uint8_t s0, uint8_t s1, uint8_t s2, uint8_t s3);
 405         void set_status_immediate(bool _req_status, int extra, uint8_t s0, uint8_t s1, uint8_t s2, uint8_t s3);
 406         virtual void set_status_extra(uint8_t s0, uint8_t s1, uint8_t s2, uint8_t s3);
 407         void set_status_extra_toc_addr(uint8_t s1, uint8_t s2, uint8_t s3);
 408         void set_status_extra_toc_data(uint8_t s1, uint8_t s2, uint8_t s3);
 409         virtual int __FASTCALL check_cdda_track_boundary(uint32_t frame_no);
 410         virtual bool seek_relative_frame_in_image(uint32_t frame_no);
 411     virtual int prefetch_audio_sectors(int sectors);
 412         virtual int __FASTCALL dequeue_audio_data(pair16_t& left, pair16_t& right);
 413
 414         virtual void read_cdrom();
 415         virtual int read_sectors_image(int sectors, uint32_t& transferred_bytes);
 416
 417         bool check_notready_and_changed(bool force_int);
 418
 419         virtual void execute_command(uint8_t command);
 420
 421         bool __FASTCALL status_not_ready(bool forceint);
 422         bool __FASTCALL status_media_changed(bool forceint);
 423         bool __FASTCALL status_media_changed_or_not_ready(bool forceint);
 424
 425         void __FASTCALL status_hardware_error(bool forceint);
 426         void __FASTCALL status_parameter_error(bool forceint);
 427         void __FASTCALL status_read_done(bool forceint);
 428         void __FASTCALL status_data_ready(bool forceint);
 429
 430         void __FASTCALL status_accept(int extra, uint8_t s2, uint8_t s3);
 431         void __FASTCALL status_not_accept(int extra, uint8_t s1, uint8_t s2, uint8_t s3);
 432
 433         void __FASTCALL status_illegal_lba(int extra, uint8_t s1, uint8_t s2, uint8_t s3);
 434         void set_delay_ready();
 435         void set_delay_ready_nostatus();
 436         void set_delay_ready_eot();
 437         void set_delay_ready_cddareply();
 438
 439         uint32_t cdrom_get_adr(int trk);
 440
 441         void __FASTCALL set_dma_intr(bool val);
 442         void __FASTCALL set_mcu_intr(bool val);
 443         /*!
 444          * @brief set interrupts without stat_reply_intr.
 445          * @param mcu interrupt value to set.
 446          * @param dma interrupt value to set.
 447          * @param use_mask true when masking mcu and dma.
 448          */
 449         void __FASTCALL set_intrs_force(bool mcu, bool dma, bool use_mask = false);
 450
 451         void __FASTCALL make_bitslice_subc_q(uint8_t *data, int bitwidth);
 452         uint16_t __FASTCALL calc_subc_crc16(uint8_t *databuf, int bytes, uint16_t initval);
 453
 454         bool open_cue_file(const _TCHAR* file_path);
 455         bool parse_cue_file_args(std::string& _arg2, const _TCHAR *parent_dir, std::string& imgpath);
 456         void parse_cue_track(std::string &_arg2, int& nr_current_track, std::string imgpath);
 457         int parse_cue_index(std::string &_arg2, int nr_current_track);
 458
 459         virtual bool open_iso_file(const _TCHAR* file_path);
 460         virtual bool open_ccd_file(const _TCHAR* file_path, _TCHAR* img_file_path);
 461
 462         virtual uint8_t read_subq();
 463         virtual uint8_t get_subq_status();
 464         virtual void set_subq(void);
 465
 466         virtual int get_track_noop(uint32_t lba);
 467         virtual void get_track_by_track_num(int track);
 468         virtual uint32_t get_image_cur_position();
 469
 470         uint32_t __FASTCALL lba_to_msf(uint32_t lba);
 471         uint32_t __FASTCALL lba_to_msf_alt(uint32_t lba);
 472         int __FASTCALL get_frames_from_msf(const char *s);
 473         int64_t __FASTCALL hexatoi(const char *s);
 474         int64_t __FASTCALL string_to_numeric(std::string s);
 475
 476         virtual void open_from_cmd(const _TCHAR* file_path);
 477         virtual void close_from_cmd();
 478         virtual void do_dma_eot(bool by_signal);
 479
 480         void __FASTCALL write_mcuint_signals(uint32_t val)
 481         {
 482                 mcuint_val = (val != 0) ? true : false;
 483                 write_signals(&outputs_mcuint, val);
 484         }
 485         void cdrom_debug_log(const char *fmt, ...);
 486         virtual const _TCHAR* __FASTCALL get_cdda_status_name(int _status);
 487         virtual const _TCHAR* __FASTCALL get_command_name_from_command(uint8_t cmd);
 488
 489         bool __CDROM_DEBUG_LOG;
 490         bool _USE_CDROM_PREFETCH;
 491         bool force_logging;
 492 public:
 493         TOWNS_CDROM(VM_TEMPLATE* parent_vm, EMU_TEMPLATE* parent_emu) : DEVICE(parent_vm, parent_emu)
 494         {
 495 //              seek_time = 400000; // 400msec (temporary)
 496                 seek_time = 10.0;
 497                 bytes_per_sec = 2048 * 75; // speed x1
 498                 max_logical_block = 0;
 499                 access = false;
 500                 databuffer = NULL;
 501                 status_queue = NULL;
 502                 _decibel_l = 0;
 503                 _decibel_r = 0;
 504
 505                 memset(subq_buffer, 0x00, sizeof(subq_buffer));
 506
 507                 initialize_output_signals(&outputs_drq);
 508                 initialize_output_signals(&outputs_mcuint);
 509                 set_device_name(_T("FM-Towns CD-ROM drive"));
 510                 d_dmac = NULL;
 511                 // For Debugging, will remove 20200822 K.O
 512                 d_cpu = NULL;
 513         }
 514         ~TOWNS_CDROM() { }
 515         virtual void initialize();
 516         virtual void release();
 517
 518         virtual void reset();
 519         virtual uint32_t __FASTCALL read_io8(uint32_t addr);
 520         virtual void __FASTCALL write_io8(uint32_t addr, uint32_t data);
 521         virtual uint32_t __FASTCALL read_dma_io8(uint32_t addr);
 522         virtual void __FASTCALL write_dma_io8(uint32_t addr, uint32_t data);
 523
 524         virtual void __FASTCALL write_signal(int id, uint32_t data, uint32_t mask);
 525         virtual uint32_t __FASTCALL read_signal(int id);
 526
 527         virtual void __FASTCALL event_callback(int event_id, int err);
 528         virtual void __FASTCALL mix(int32_t* buffer, int cnt);
 529
 530         virtual bool process_state(FILEIO* state_fio, bool loading);
 531
 532         virtual bool mounted();
 533         virtual bool accessed();
 534         virtual void open(const _TCHAR* file_path);
 535         virtual void close();
 536
 537         // for debug
 538         virtual void __FASTCALL write_debug_data8(uint32_t addr, uint32_t data);
 539         virtual uint32_t __FASTCALL read_debug_data8(uint32_t addr);
 540         virtual bool get_debug_regs_info(_TCHAR *buffer, size_t buffer_len);
 541         virtual bool write_debug_reg(const _TCHAR *reg, uint32_t data);
 542         bool is_debugger_available()
 543         {
 544                 return true;
 545         }
 546         uint64_t get_debug_data_addr_space()
 547         {
 548                 return 0x1fff; // Will change
 549         }
 550
 551
 552         virtual void set_volume(int ch, int decibel_l, int decibel_r);
 553         virtual void get_volume(int ch, int& decibel_l, int& decibel_r);
 554         virtual bool read_buffer(int sectors);
 555
 556         // unique functions
 557         // Towns specified command
 558         virtual void set_cdda_status(uint8_t status);
 559         int get_track(uint32_t lba);
 560         virtual double get_seek_time(uint32_t lba);
 561         virtual uint8_t read_status();
 562         virtual const int logical_block_size();
 563         virtual const int physical_block_size();
 564         virtual bool write_a_byte(uint8_t val)
 565         {
 566                 uint32_t n = val;
 567                 n = n & 0xff;
 568 //              if(databuffer->count() >= fifo_length) {
 569 //                      return false;
 570 //              }
 571                 databuffer->write((int)n);
 572                 return true;
 573         }
 574         virtual bool write_bytes(uint8_t* val, int bytes)
 575         {
 576                 int n_count = databuffer->count();
 577                 if((val == NULL) ||
 578                    (n_count >= max_fifo_length) || ((n_count + bytes) >= fifo_length)) {
 579                         return false;
 580                 }
 581                 for(int i = 0; i < bytes; i++) {
 582                         int d = ((int)val[i]) & 0xff ;
 583                         databuffer->write(d);
 584                 }
 585                 return true;
 586         }
 587         virtual bool change_buffer_size(int size)
 588         {
 589                 if((size <= 0) || (size >= max_fifo_length) || (databuffer == NULL)) return false;
 590                 uint8_t tbuf[size];
 591                 if(fifo_length > size) { // truncate
 592                         // Dummy read
 593                         for(int i = 0; i < (fifo_length - size); i++) {
 594                                 uint8_t dummy = (uint8_t)(databuffer->read() & 0xff);
 595                         }
 596                         for(int i = 0; i < size; i++) {
 597                                 tbuf[i] = (uint8_t)(databuffer->read() & 0xff);
 598                         }
 599                         databuffer->clear();
 600                         for(int i = 0; i < size; i++) {
 601                                 databuffer->write(tbuf[i]);
 602                         }
 603                 } else if(fifo_length < size) {
 604                         for(int i = 0; i < fifo_length; i++) {
 605                                 tbuf[i] = (uint8_t)(databuffer->read() & 0xff);
 606                         }
 607                         databuffer->clear();
 608                         for(int i = 0; i < fifo_length; i++) {
 609                                 databuffer->write(tbuf[i]);
 610                         }
 611 //                      for(int i = 0; i < (size - fifo_size); i++) {
 612 //                              databuffer->write(0);
 613 //                      }
 614                 }
 615                 fifo_length = size;
 616                 return true;
 617         }
 618         uint8_t get_cdda_status()
 619         {
 620                 return cdda_status;
 621         }
 622
 623         void set_machine_id(uint16_t val)
 624         {
 625                 machine_id = val & 0xfff8;
 626         }
 627         void set_cpu_id(uint16_t val)
 628         {
 629                 cpu_id = val & 0x07;
 630         }
 631
 632         void set_context_mpuint_line(DEVICE* dev, int id, uint32_t mask)
 633         {
 634                 register_output_signal(&outputs_mcuint, dev, id, mask);
 635         }
 636         void set_context_drq_line(DEVICE* dev, int id, uint32_t mask)
 637         {
 638                 register_output_signal(&outputs_drq, dev, id, mask);
 639         }
 640         void set_context_dmac(DEVICE* d)
 641         {
 642                 d_dmac = d;
 643         }
 644         // For Debugging, will remove 20200822 K.O
 645         void set_context_cpu(DEVICE* d)
 646         {
 647                 d_cpu = d;
 648         }
 649 };
 650
 651
 652 }