/* * 86Box A hypervisor and IBM PC system emulator that specializes in * running old operating systems and software designed for IBM * PC systems and compatibles from 1981 through fairly recent * system designs based on the PCI bus. * * This file is part of the 86Box distribution. * * CD-ROM passthrough support. * * * * Authors: TheCollector1995, , * Miran Grca, * * Copyright 2023 TheCollector1995. * Copyright 2023 Miran Grca. */ #include #include #include #include #include #include #include #define HAVE_STDARG_H #include <86box/86box.h> #include <86box/config.h> #include <86box/path.h> #include <86box/plat.h> #include <86box/plat_cdrom.h> #include <86box/scsi_device.h> #include <86box/cdrom.h> #ifdef ENABLE_CDROM_IOCTL_LOG int cdrom_ioctl_do_log = ENABLE_CDROM_IOCTL_LOG; void cdrom_ioctl_log(const char *fmt, ...) { va_list ap; if (cdrom_ioctl_do_log) { va_start(ap, fmt); pclog_ex(fmt, ap); va_end(ap); } } #else # define cdrom_ioctl_log(fmt, ...) #endif /* The addresses sent from the guest are absolute, ie. a LBA of 0 corresponds to a MSF of 00:00:00. Otherwise, the counter displayed by the guest is wrong: there is a seeming 2 seconds in which audio plays but counter does not move, while a data track before audio jumps to 2 seconds before the actual start of the audio while audio still plays. With an absolute conversion, the counter is fine. */ #define MSFtoLBA(m, s, f) ((((m * 60) + s) * 75) + f) static void ioctl_get_tracks(UNUSED(cdrom_t *dev), int *first, int *last) { TMSF tmsf; plat_cdrom_get_audio_tracks(first, last, &tmsf); } static void ioctl_get_track_info(UNUSED(cdrom_t *dev), uint32_t track, int end, track_info_t *ti) { TMSF tmsf; plat_cdrom_get_audio_track_info(end, track, &ti->number, &tmsf, &ti->attr); ti->m = tmsf.min; ti->s = tmsf.sec; ti->f = tmsf.fr; } static void ioctl_get_subchannel(UNUSED(cdrom_t *dev), uint32_t lba, subchannel_t *subc) { TMSF rel_pos; TMSF abs_pos; if ((dev->cd_status == CD_STATUS_PLAYING) || (dev->cd_status == CD_STATUS_PAUSED)) { const uint32_t trk = plat_cdrom_get_track_start(lba, &subc->attr, &subc->track); FRAMES_TO_MSF(lba + 150, &abs_pos.min, &abs_pos.sec, &abs_pos.fr); /* Absolute position should be adjusted by 150, not the relative ones. */ FRAMES_TO_MSF(lba - trk, &rel_pos.min, &rel_pos.sec, &rel_pos.fr); subc->index = 1; } else plat_cdrom_get_audio_sub(lba, &subc->attr, &subc->track, &subc->index, &rel_pos, &abs_pos); subc->abs_m = abs_pos.min; subc->abs_s = abs_pos.sec; subc->abs_f = abs_pos.fr; subc->rel_m = rel_pos.min; subc->rel_s = rel_pos.sec; subc->rel_f = rel_pos.fr; cdrom_ioctl_log("ioctl_get_subchannel(): %02X, %02X, %02i, %02i:%02i:%02i, %02i:%02i:%02i\n", subc->attr, subc->track, subc->index, subc->abs_m, subc->abs_s, subc->abs_f, subc->rel_m, subc->rel_s, subc->rel_f); } static int ioctl_get_capacity(UNUSED(cdrom_t *dev)) { int ret; ret = plat_cdrom_get_last_block(); cdrom_ioctl_log("GetCapacity=%x.\n", ret); return ret; } static int ioctl_is_track_audio(cdrom_t *dev, uint32_t pos, int ismsf) { int m; int s; int f; if (dev->cd_status == CD_STATUS_DATA_ONLY) return 0; if (ismsf) { m = (pos >> 16) & 0xff; s = (pos >> 8) & 0xff; f = pos & 0xff; pos = MSFtoLBA(m, s, f) - 150; } /* GetTrack requires LBA. */ return plat_cdrom_is_track_audio(pos); } static int ioctl_is_track_pre(UNUSED(cdrom_t *dev), uint32_t lba) { return plat_cdrom_is_track_pre(lba); } static int ioctl_sector_size(UNUSED(cdrom_t *dev), uint32_t lba) { cdrom_ioctl_log("LBA=%x.\n", lba); return plat_cdrom_get_sector_size(lba); } static int ioctl_read_sector(UNUSED(cdrom_t *dev), int type, uint8_t *b, uint32_t lba) { switch (type) { case CD_READ_DATA: cdrom_ioctl_log("cdrom_ioctl_read_sector(): Data.\n"); return plat_cdrom_read_sector(b, 0, lba); case CD_READ_AUDIO: cdrom_ioctl_log("cdrom_ioctl_read_sector(): Audio.\n"); return plat_cdrom_read_sector(b, 1, lba); case CD_READ_RAW: cdrom_ioctl_log("cdrom_ioctl_read_sector(): Raw.\n"); return plat_cdrom_read_sector(b, 1, lba); default: cdrom_ioctl_log("cdrom_ioctl_read_sector(): Unknown CD read type.\n"); break; } return 0; } static int ioctl_track_type(cdrom_t *dev, uint32_t lba) { int ret = 0; if (ioctl_is_track_audio(dev, lba, 0)) ret = CD_TRACK_AUDIO; cdrom_ioctl_log("cdrom_ioctl_track_type(): %i\n", ret); return ret; } static int ioctl_ext_medium_changed(cdrom_t *dev) { int ret; if ((dev->cd_status == CD_STATUS_PLAYING) || (dev->cd_status == CD_STATUS_PAUSED)) ret = 0; else ret = plat_cdrom_ext_medium_changed(); if (ret == 1) { dev->cd_status = CD_STATUS_STOPPED; dev->cdrom_capacity = ioctl_get_capacity(dev); } else if (ret == -1) dev->cd_status = CD_STATUS_EMPTY; return ret; } static void ioctl_exit(cdrom_t *dev) { cdrom_ioctl_log("CDROM: ioctl_exit(%s)\n", dev->image_path); dev->cd_status = CD_STATUS_EMPTY; plat_cdrom_close(); dev->ops = NULL; } static const cdrom_ops_t cdrom_ioctl_ops = { ioctl_get_tracks, ioctl_get_track_info, ioctl_get_subchannel, ioctl_is_track_pre, ioctl_sector_size, ioctl_read_sector, ioctl_track_type, ioctl_ext_medium_changed, ioctl_exit }; static int cdrom_ioctl_open_abort(cdrom_t *dev) { cdrom_ioctl_close(dev); dev->ops = NULL; dev->image_path[0] = 0; return 1; } int cdrom_ioctl_open(cdrom_t *dev, const char *drv) { const char *actual_drv = &(drv[8]); /* Make sure to not STRCPY if the two are pointing at the same place. */ if (drv != dev->image_path) strcpy(dev->image_path, drv); /* Open the image. */ if (strstr(drv, "ioctl://") != drv) return cdrom_ioctl_open_abort(dev); cdrom_ioctl_log("actual_drv = %s\n", actual_drv); int i = plat_cdrom_set_drive(actual_drv); if (!i) return cdrom_ioctl_open_abort(dev); /* All good, reset state. */ dev->cd_status = CD_STATUS_STOPPED; dev->seek_pos = 0; dev->cd_buflen = 0; dev->cdrom_capacity = ioctl_get_capacity(dev); cdrom_ioctl_log("CD-ROM capacity: %i sectors (%" PRIi64 " bytes)\n", dev->cdrom_capacity, ((uint64_t) dev->cdrom_capacity) << 11ULL); /* Attach this handler to the drive. */ dev->ops = &cdrom_ioctl_ops; return 0; } void cdrom_ioctl_close(cdrom_t *dev) { cdrom_ioctl_log("CDROM: ioctl_close(%s)\n", dev->image_path); if (dev && dev->ops && dev->ops->exit) dev->ops->exit(dev); }