[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Libcdio-devel] [PATCH] OS/2 support
|
From: |
rocky |
|
Subject: |
[Libcdio-devel] [PATCH] OS/2 support |
|
Date: |
Tue, 13 Jan 2009 11:28:04 -0500 |
KO Myung-Hun writes:
> Hi/2.
>
> These patches add a OS/2 driver for libcdio-0.81.
>
> Review, please.
Thanks. A quick scan over the patch and it looks fine. I'll try to
apply sometime in the future. Some of the patch extends code which is
depricated so that will be removed (along with the corresponding code
in other drivers that is deprecated.)
>
> --
> KO Myung-Hun
>
> Using Mozilla SeaMonkey 1.1.14
> Under OS/2 Warp 4 for Korean with FixPak #15
> On AMD ThunderBird 1 GHz with 512 MB RAM
>
> Korean OS/2 User Community : http://www.ecomstation.co.kr
>
>
> diff -buNr configure.ac.org configure.ac
> --- configure.ac.org 2008-10-26 23:48:24.000000000 +0900
> +++ configure.ac 2009-01-09 02:09:10.000000000 +0900
> @@ -529,6 +529,13 @@
> # LIBS="$LIBS -lcam"
> cd_drivers="${cd_drivers}, NetBSD "
> ;;
> + os2*)
> + AC_DEFINE([HAVE_OS2_CDROM], [1],
> + [Define 1 if you have OS/2 CD-ROM support])
> + LT_NO_UNDEFINED="-no-undefined"
> + LDFLAGS="$LDFLAGS -Zbin-files"
> + cd_drivers="${cd_drivers}, OS2 "
> + ;;
> *)
> AC_MSG_WARN([Don't have OS CD-reading support for ${host_os}...])
> AC_MSG_WARN([Will use generic support.])
> @@ -563,6 +570,7 @@
> AC_SUBST(HAVE_LINUX_CDROM)
> AC_SUBST(HAVE_SOLARIS_CDROM)
> AC_SUBST(HAVE_WIN32_CDROM)
> +AC_SUBST(HAVE_OS2_CDROM)
>
> LIBCDIO_SOURCE_PATH="`pwd`"
> AC_DEFINE_UNQUOTED(LIBCDIO_SOURCE_PATH, "$LIBCDIO_SOURCE_PATH",
> diff -buNr include/cdio/device.h.org include/cdio/device.h
> --- include/cdio/device.h.org 2008-03-27 18:28:36.000000000 +0900
> +++ include/cdio/device.h 2009-01-12 22:05:00.000000000 +0900
> @@ -159,6 +159,7 @@
> DRIVER_OSX, /**< Apple OSX Driver */
> DRIVER_WIN32, /**< Microsoft Windows Driver. Includes ASPI and
> ioctl access. */
> + DRIVER_OS2, /**< OS/2 Driver */
> DRIVER_NETBSD, /**< NetBSD Driver. */
> DRIVER_CDRDAO, /**< cdrdao format CD image. This is listed
> before BIN/CUE, to make the code prefer cdrdao
> @@ -810,6 +811,44 @@
>
> char **cdio_get_devices_win32(void);
>
> + /*! Set up CD-ROM for reading using the IBM OS/2 driver. The
> + device_name is the some sort of device name.
> +
> + NULL is returned on error or there is no OS/2 driver.
> +
> + In some situations of drivers or OS's we can't find a CD device if
> + there is no media in it and it is possible for this routine to return
> + NULL even though there may be a hardware CD-ROM.
> +
> + @see cdio_open_cd, cdio_open
> + */
> + CdIo_t * cdio_open_os2 (const char *psz_source);
> +
> + /*! Set up CD-ROM for reading using the IBM OS/2 driver. The
> + device_name is the some sort of device name.
> +
> + NULL is returned on error or there is no OS/2 driver.
> +
> + @see cdio_open_cd, cdio_open
> + */
> + CdIo_t * cdio_open_am_os2 (const char *psz_source,
> + const char *psz_access_mode);
> +
> + /*! Return a string containing the default device name that the
> + OS/2 driver would use when none is specified. A scan is made
> + for CD-ROM drives with CDs in them.
> +
> + In some situations of drivers or OS's we can't find a CD device if
> + there is no media in it and it is possible for this routine to return
> + NULL even though there may be a hardware CD-ROM.
> + */
> + char * cdio_get_default_device_os2(void);
> +
> + /*! Return a list of all of the CD-ROM devices that the OS/2 driver
> + can find.
> + */
> + char **cdio_get_devices_os2(void);
> +
> /*! Set up CD-ROM for reading using the Nero driver. The
> device_name is the some sort of device name.
>
> diff -buNr lib/cdda_interface/common_interface.h.org
> lib/cdda_interface/common_interface.h
> --- lib/cdda_interface/common_interface.h.org 2008-04-23
> 23:59:52.000000000 +0900
> +++ lib/cdda_interface/common_interface.h 2009-01-09 01:59:08.000000000
> +0900
> @@ -28,7 +28,7 @@
> #include <cdio/types.h>
> #include "low_interface.h"
>
> -#if defined(HAVE_LSTAT) && !defined(HAVE_WIN32_CDROM)
> +#if defined(HAVE_LSTAT) && !defined(HAVE_WIN32_CDROM) &&
> !defined(HAVE_OS2_CDROM)
> /* Define this if the CD-ROM device is a file in the filesystem
> that can be lstat'd
> */
> diff -buNr lib/driver/cdio_private.h.org lib/driver/cdio_private.h
> --- lib/driver/cdio_private.h.org 2008-04-23 23:59:52.000000000 +0900
> +++ lib/driver/cdio_private.h 2009-01-12 22:05:42.000000000 +0900
> @@ -488,6 +488,7 @@
> driver_return_code_t close_tray_osx (const char *psz_drive);
> driver_return_code_t close_tray_solaris (const char *psz_drive);
> driver_return_code_t close_tray_win32 (const char *psz_drive);
> + driver_return_code_t close_tray_os2 (const char *psz_drive);
>
> bool cdio_have_netbsd(void);
> CdIo_t * cdio_open_netbsd (const char *psz_source);
> @@ -531,6 +532,10 @@
> True if Microsoft Windows driver is available. */
> bool cdio_have_win32 (void);
>
> + /*! DEPRICATED: use cdio_have_driver().
> + True if IBM OS/2 driver is available. */
> + bool cdio_have_os2 (void);
> +
> /*! True if Nero driver is available. */
> bool cdio_have_nrg (void);
>
> diff -buNr lib/driver/device.c.org lib/driver/device.c
> --- lib/driver/device.c.org 2008-04-23 23:59:52.000000000 +0900
> +++ lib/driver/device.c 2009-01-09 01:59:08.000000000 +0900
> @@ -71,6 +71,8 @@
> const driver_id_t cdio_os_driver = DRIVER_SOLARIS;
> #elif HAVE_DARWIN_WIN32
> const driver_id_t cdio_os_driver = DRIVER_WIN32;
> +#elif HAVE_OS2_CDROM
> +const driver_id_t cdio_os_driver = DRIVER_OS2;
> #else
> const driver_id_t cdio_os_driver = DRIVER_UNKNOWN;
> #endif
> @@ -213,6 +215,19 @@
> &close_tray_win32
> },
>
> + {DRIVER_OS2,
> + CDIO_SRC_IS_DEVICE_MASK|CDIO_SRC_IS_NATIVE_MASK|CDIO_SRC_IS_SCSI_MASK,
> + "OS2",
> + "IBM OS/2 driver",
> + &cdio_have_os2,
> + &cdio_open_os2,
> + &cdio_open_am_os2,
> + &cdio_get_default_device_os2,
> + &cdio_is_device_os2,
> + &cdio_get_devices_os2,
> + &close_tray_os2
> + },
> +
> {DRIVER_CDRDAO,
> CDIO_SRC_IS_DISK_IMAGE_MASK,
> "CDRDAO",
> @@ -939,6 +954,7 @@
> case DRIVER_SOLARIS:
> case DRIVER_WIN32:
> case DRIVER_OSX:
> + case DRIVER_OS2:
> case DRIVER_NRG:
> case DRIVER_BINCUE:
> case DRIVER_CDRDAO:
> diff -buNr lib/driver/generic.h.org lib/driver/generic.h
> --- lib/driver/generic.h.org 2008-04-23 23:59:52.000000000 +0900
> +++ lib/driver/generic.h 2009-01-09 02:26:50.000000000 +0900
> @@ -134,6 +134,12 @@
> */
> bool cdio_is_device_win32(const char *source_name);
>
> + /*!
> + Return true if source_name could be a device containing a CD-ROM on
> + OS/2
> + */
> + bool cdio_is_device_os2(const char *source_name);
> +
>
> /*!
> Return true if source_name could be a device containing a CD-ROM on
> diff -buNr lib/driver/Makefile.am.org lib/driver/Makefile.am
> --- lib/driver/Makefile.am.org 2008-10-19 18:25:30.000000000 +0900
> +++ lib/driver/Makefile.am 2009-01-06 12:42:40.000000000 +0900
> @@ -90,6 +90,7 @@
> MSWindows/win32.h \
> netbsd.c \
> osx.c \
> + os2.c \
> read.c \
> sector.c \
> solaris.c \
> diff -buNr lib/driver/os2.c.org lib/driver/os2.c
> --- lib/driver/os2.c.org 2009-01-09 23:57:26.000000000 +0900
> +++ lib/driver/os2.c 2009-01-11 17:49:36.000000000 +0900
> @@ -0,0 +1,1554 @@
> +/*
> + $Id: os2.c,v 1.30 2008/04/21 18:30:21 karl Exp $
> +
> + Copyright (C) 2009 KO Myung-Hun <address@hidden>
> +
> + This program is free software: you can redistribute it and/or modify
> + it under the terms of the GNU General Public License as published by
> + the Free Software Foundation, either version 3 of the License, or
> + (at your option) any later version.
> +
> + This program is distributed in the hope that it will be useful,
> + but WITHOUT ANY WARRANTY; without even the implied warranty of
> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + GNU General Public License for more details.
> +
> + You should have received a copy of the GNU General Public License
> + along with this program. If not, see <http://www.gnu.org/licenses/>.
> +*/
> +
> +/* This file contains OS/2-specific code using the DosDevIOCtl
> + access method.
> +*/
> +
> +#ifdef HAVE_CONFIG_H
> +# include "config.h"
> +#endif
> +
> +static const char _rcsid[] = "$Id: os2.c,v 1.30 2008/04/21 18:30:21 karl
> Exp $";
> +
> +#include <cdio/cdio.h>
> +#include <cdio/sector.h>
> +#include <cdio/util.h>
> +#include <cdio/mmc.h>
> +#include "cdio_assert.h"
> +#include "cdio_private.h"
> +
> +#include <string.h>
> +
> +#ifdef HAVE_OS2_CDROM
> +
> +#define INCL_DOS
> +#define INCL_DOSDEVIOCTL
> +#include <os2.h>
> +
> +#include <ctype.h>
> +
> +
> +typedef struct {
> + lsn_t lsn_start;
> + UCHAR uc_adr;
> + UCHAR uc_control;
> +} toc_t;
> +
> +typedef enum {
> + _AM_NONE,
> + _AM_OS2,
> +} access_mode_t;
> +
> +typedef struct {
> + /* Things common to all drivers like this.
> + This must be first. */
> + generic_img_private_t gen;
> +
> + access_mode_t access_mode;
> +
> + /* Track information */
> + toc_t toc[CDIO_CD_MAX_TRACKS + 1]; /* 1 more for leadout */
> + int i_first_track;
> + int i_last_track;
> +
> + /* Some of the more OS specific things. */
> + HFILE h_cd;
> + BYTE uc_drive;
> +} _img_private_t;
> +
> +#pragma pack(1)
> +
> +static track_format_t
> +get_track_format_os2(const _img_private_t *p_env, track_t i_track);
> +
> +static bool read_toc_os2 (void *p_user_data);
> +
> +static int
> +run_mmc_cmd_os2( void *p_user_data, unsigned int i_timeout_ms,
> + unsigned int i_cdb, const mmc_cdb_t *p_cdb,
> + cdio_mmc_direction_t e_direction,
> + unsigned int i_buf, /*in/out*/ void *p_buf );
> +
> +/*!
> + Set the volume of an audio CD.
> +
> + @param p_cdio the CD object to be acted upon.
> +
> +*/
> +static driver_return_code_t
> +audio_get_volume_os2 (void *p_user_data,
> + /*out*/ cdio_audio_volume_t *p_volume)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + struct {
> + UCHAR auch_sign[4];
> + } s_param = {{'C', 'D', '0', '1'}};
> +
> + struct {
> + struct {
> + BYTE uc_in_ch;
> + BYTE uc_vol;
> + } as_out_ch[4];
> + } s_data;
> +
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> + int i;
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_GETCHANNEL,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + &s_data, sizeof( s_data ), &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("audio_get_volume_os2 : DosDevIOCtl(GETCHANNEL) = 0x%lx\n",
> rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + for( i = 0; i < 4; i++ )
> + p_volume->level[ i ] = s_data.as_out_ch[ i ].uc_vol;
> +
> + return DRIVER_OP_SUCCESS;
> +}
> +
> +/*!
> + Pause playing CD through analog output
> +
> + @param p_cdio the CD object to be acted upon.
> +*/
> +static driver_return_code_t
> +audio_pause_os2 (void *p_user_data)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + struct {
> + UCHAR auch_sign[4];
> + } s_param = {{'C', 'D', '0', '1'}};
> +
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_STOPAUDIO,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + NULL, 0, &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("audio_pause_os2 : DosDevIOCtl(STOPAUDIO) = 0x%lx\n", rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + return DRIVER_OP_SUCCESS;
> +}
> +
> +/*!
> + Playing CD through analog output at the given MSF.
> +
> + @param p_cdio the CD object to be acted upon.
> +*/
> +static driver_return_code_t
> +audio_play_msf_os2 (void *p_user_data, msf_t *p_start_msf, msf_t *p_end_msf)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + struct {
> + UCHAR auch_sign[4];
> + BYTE uc_access_mode;
> + BYTE uc_start_msf_f;
> + BYTE uc_start_msf_s;
> + BYTE uc_start_msf_m;
> + BYTE uc_start_msf_reserved;
> + BYTE uc_end_msf_f;
> + BYTE uc_end_msf_s;
> + BYTE uc_end_msf_m;
> + BYTE uc_end_msf_reserved;
> + } s_param = {
> + .auch_sign = {'C', 'D', '0', '1'},
> + .uc_access_mode = 01, /* use MSF format */
> + };
> +
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> +
> + s_param.uc_start_msf_m = cdio_from_bcd8(p_start_msf->m);
> + s_param.uc_start_msf_s = cdio_from_bcd8(p_start_msf->s);
> + s_param.uc_start_msf_f = cdio_from_bcd8(p_start_msf->f);
> +
> + s_param.uc_end_msf_m = cdio_from_bcd8(p_end_msf->m);
> + s_param.uc_end_msf_s = cdio_from_bcd8(p_end_msf->s);
> + s_param.uc_end_msf_f = cdio_from_bcd8(p_end_msf->f);
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_PLAYAUDIO,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + NULL, 0, &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("audio_play_msf_os2 : DosDevIOCtl(PLAYAUDIO) = 0x%lx\n", rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + return DRIVER_OP_SUCCESS;
> +}
> +
> +/*!
> + Read Audio Subchannel information
> +
> + @param p_cdio the CD object to be acted upon.
> +
> +*/
> +static driver_return_code_t
> +audio_read_subchannel_os2 (void *p_user_data,
> + cdio_subchannel_t *p_subchannel)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + struct {
> + UCHAR auch_sign[4];
> + } s_param = {{'C', 'D', '0', '1'}};
> +
> + struct {
> + BYTE uc_control_and_adr;
> + BYTE uc_track_number; /* in BCD */
> + BYTE uc_index; /* in BCD */
> + BYTE uc_running_time_in_track_m;
> + BYTE uc_running_time_in_track_s;
> + BYTE uc_running_time_in_track_f;
> + BYTE uc_reserved;
> + BYTE uc_running_time_on_disk_m;
> + BYTE uc_running_time_on_disk_s;
> + BYTE uc_running_time_on_disk_f;
> + } s_data_subchannel_q;
> +
> + struct {
> + USHORT us_audio_status_bits;
> + ULONG ul_start_msf;
> + ULONG ul_end_msf;
> + } s_data_audio_status;
> +
> + ULONG ul_data_device_status;
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_GETSUBCHANNELQ,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + &s_data_subchannel_q, sizeof( s_data_subchannel_q ), &ul_data_len
> );
> +
> + if( rc )
> + {
> + cdio_warn("audio_read_subchannel_os2 : DosDevIOCtl(GETSUBCHANNELQ) =
> 0x%lx\n", rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_GETAUDIOSTATUS,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + &s_data_audio_status, sizeof( s_data_audio_status ), &ul_data_len
> );
> +
> + if( rc )
> + {
> + cdio_warn("audio_read_subchannel_os2 : DosDevIOCtl(GETAUDIOSTATUS) =
> 0x%lx\n", rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMDISK, CDROMDISK_DEVICESTATUS,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + &ul_data_device_status, sizeof( ul_data_device_status ),
> &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("audio_read_subchannel_os2 : DosDevIOCtl(DEVICESTATUS) =
> 0x%lx\n", rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + p_subchannel->track = cdio_from_bcd8(s_data_subchannel_q.uc_track_number);
> + p_subchannel->index = cdio_from_bcd8(s_data_subchannel_q.uc_index);
> +
> + p_subchannel->abs_addr.m =
> cdio_to_bcd8(s_data_subchannel_q.uc_running_time_on_disk_m);
> + p_subchannel->abs_addr.s =
> cdio_to_bcd8(s_data_subchannel_q.uc_running_time_on_disk_s);
> + p_subchannel->abs_addr.f =
> cdio_to_bcd8(s_data_subchannel_q.uc_running_time_on_disk_f);
> + p_subchannel->rel_addr.m =
> cdio_to_bcd8(s_data_subchannel_q.uc_running_time_in_track_m);
> + p_subchannel->rel_addr.s =
> cdio_to_bcd8(s_data_subchannel_q.uc_running_time_in_track_s);
> + p_subchannel->rel_addr.f =
> cdio_to_bcd8(s_data_subchannel_q.uc_running_time_in_track_f);
> +
> + p_subchannel->address = s_data_subchannel_q.uc_control_and_adr &
> 0x0F;
> + p_subchannel->control = ( s_data_subchannel_q.uc_control_and_adr >> 4 ) &
> 0x0F;
> +
> + if( ul_data_device_status & 0x1000 )
> + p_subchannel->audio_status = CDIO_MMC_READ_SUB_ST_PLAY;
> + else if( s_data_audio_status.us_audio_status_bits & 1 )
> + p_subchannel->audio_status = CDIO_MMC_READ_SUB_ST_PAUSED;
> + else if( s_data_audio_status.ul_start_msf == 0 &&
> + s_data_audio_status.ul_end_msf == 0 )
> + p_subchannel->audio_status = CDIO_MMC_READ_SUB_ST_NO_STATUS;
> + else
> + p_subchannel->audio_status = CDIO_MMC_READ_SUB_ST_COMPLETED;
> +
> + return DRIVER_OP_SUCCESS;
> +}
> +
> + /*!
> + Resume playing an audio CD.
> +
> + @param p_cdio the CD object to be acted upon.
> +
> + */
> +static driver_return_code_t
> +audio_resume_os2 (void *p_user_data)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + struct {
> + UCHAR auch_sign[4];
> + } s_param = {{'C', 'D', '0', '1'}};
> +
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_RESUMEAUDIO,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + NULL, 0, &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("audio_resume_os2 : DosDevIOCtl(RESUMEAUDIO) = 0x%lx\n", rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + return DRIVER_OP_SUCCESS;
> +}
> +
> +/*!
> + Set the volume of an audio CD.
> +
> + @param p_cdio the CD object to be acted upon.
> +
> +*/
> +static driver_return_code_t
> +audio_set_volume_os2 ( void *p_user_data, cdio_audio_volume_t *p_volume)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + struct {
> + UCHAR auch_sign[4];
> + } s_param = {{'C', 'D', '0', '1'}};
> +
> + struct {
> + struct {
> + BYTE uc_in_ch;
> + BYTE uc_vol;
> + } as_out_ch[4];
> + } s_data;
> +
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> + int i;
> +
> + /* first retrive current input ch. */
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_GETCHANNEL,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + &s_data, sizeof( s_data ), &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("audio_set_volume_os2 : DosDevIOCtl(GETCHANNEL) = 0x%lx\n",
> rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + for( i = 0; i < 4; i++ )
> + s_data.as_out_ch[ i ].uc_vol = p_volume->level[ i ];
> +
> + /* now set volumes */
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_SETCHANNELCTRL,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + &s_data, sizeof( s_data ), &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("audio_set_volume_os2 : DosDevIOCtl(SETCHANNELCTRL) =
> 0x%lx\n", rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + return DRIVER_OP_SUCCESS;
> +}
> +
> +static driver_return_code_t
> +audio_stop_os2 (void *p_user_data)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + struct {
> + UCHAR auch_sign[4];
> + } s_param = {{'C', 'D', '0', '1'}};
> +
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_STOPAUDIO,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + NULL, 0, &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("audio_stop_os2 : DosDevIOCtl(STOPAUDIO) = 0x%lx\n", rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + return DRIVER_OP_SUCCESS;
> +}
> +
> +/*!
> + Get disc type associated with cd object.
> +*/
> +static discmode_t
> +dvd_discmode_os2 (_img_private_t *p_env)
> +{
> + discmode_t discmode=CDIO_DISC_MODE_NO_INFO;
> + driver_return_code_t rc;
> +
> + /* See if this is a DVD. */
> + cdio_dvd_struct_t dvd; /* DVD READ STRUCT for layer 0. */
> +
> + dvd.physical.type = CDIO_DVD_STRUCT_PHYSICAL;
> + dvd.physical.layer_num = 0;
> +
> + rc = mmc_get_dvd_struct_physical_private (p_env, &run_mmc_cmd_os2,
> + &dvd);
> +
> + if (DRIVER_OP_SUCCESS == rc) {
> + switch(dvd.physical.layer[0].book_type) {
> + case CDIO_DVD_BOOK_DVD_ROM: return CDIO_DISC_MODE_DVD_ROM;
> + case CDIO_DVD_BOOK_DVD_RAM: return CDIO_DISC_MODE_DVD_RAM;
> + case CDIO_DVD_BOOK_DVD_R: return CDIO_DISC_MODE_DVD_R;
> + case CDIO_DVD_BOOK_DVD_RW: return CDIO_DISC_MODE_DVD_RW;
> + case CDIO_DVD_BOOK_DVD_PR: return CDIO_DISC_MODE_DVD_PR;
> + case CDIO_DVD_BOOK_DVD_PRW: return CDIO_DISC_MODE_DVD_PRW;
> + default: return CDIO_DISC_MODE_DVD_OTHER;
> + }
> + }
> + return discmode;
> +}
> +
> +/*!
> + Get disc type associated with the cd object.
> +*/
> +static discmode_t
> +get_discmode_os2(void *p_user_data)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + track_t i_track;
> + discmode_t discmode;
> +
> + if (!p_env) return CDIO_DISC_MODE_ERROR;
> +
> + discmode = dvd_discmode_os2(p_env);
> +
> + if (CDIO_DISC_MODE_NO_INFO != discmode) return discmode;
> +
> + if (!p_env->gen.toc_init) read_toc_os2 (p_env);
> +
> + if (!p_env->gen.toc_init) return CDIO_DISC_MODE_ERROR;
> +
> + for (i_track = p_env->gen.i_first_track;
> + i_track < p_env->gen.i_first_track + p_env->gen.i_tracks ;
> + i_track ++) {
> + track_format_t track_fmt=get_track_format_os2(p_env, i_track);
> +
> + switch(track_fmt) {
> + case TRACK_FORMAT_AUDIO:
> + switch(discmode) {
> + case CDIO_DISC_MODE_NO_INFO:
> + discmode = CDIO_DISC_MODE_CD_DA;
> + break;
> + case CDIO_DISC_MODE_CD_DA:
> + case CDIO_DISC_MODE_CD_MIXED:
> + case CDIO_DISC_MODE_ERROR:
> + /* No change*/
> + break;
> + default:
> + discmode = CDIO_DISC_MODE_CD_MIXED;
> + }
> + break;
> + case TRACK_FORMAT_XA:
> + switch(discmode) {
> + case CDIO_DISC_MODE_NO_INFO:
> + discmode = CDIO_DISC_MODE_CD_XA;
> + break;
> + case CDIO_DISC_MODE_CD_XA:
> + case CDIO_DISC_MODE_CD_MIXED:
> + case CDIO_DISC_MODE_ERROR:
> + /* No change*/
> + break;
> + default:
> + discmode = CDIO_DISC_MODE_CD_MIXED;
> + }
> + break;
> + case TRACK_FORMAT_DATA:
> + switch(discmode) {
> + case CDIO_DISC_MODE_NO_INFO:
> + discmode = CDIO_DISC_MODE_CD_DATA;
> + break;
> + case CDIO_DISC_MODE_CD_DATA:
> + case CDIO_DISC_MODE_CD_MIXED:
> + case CDIO_DISC_MODE_ERROR:
> + /* No change*/
> + break;
> + default:
> + discmode = CDIO_DISC_MODE_CD_MIXED;
> + }
> + break;
> + case TRACK_FORMAT_ERROR:
> + default:
> + discmode = CDIO_DISC_MODE_ERROR;
> + }
> + }
> + return discmode;
> +}
> +
> +#define CDROMDISK_EXECMD 0x7A
> +
> +/* 0, if transfer data to device, 1, if transfer data from device */
> +#define EX_DIRECTION_IN 0x0001
> +/* 0, if don't check playing audio, 1, if device plays audio return error */
> +#define EX_PLAYING_CHK 0x0002
> +
> +/*!
> + Run a SCSI MMC command.
> +
> + env private CD structure
> + i_timeout_ms time in milliseconds we will wait for the command
> + to complete. If this value is -1, use the default
> + time-out value.
> + p_buf Buffer for data, both sending and receiving
> + i_buf Size of buffer
> + e_direction direction the transfer is to go.
> + cdb CDB bytes. All values that are needed should be set on
> + input. We'll figure out what the right CDB length should be.
> +
> + Return 0 if command completed successfully.
> + */
> +static int
> +run_mmc_cmd_os2( void *p_user_data, unsigned int i_timeout_ms,
> + unsigned int i_cdb, const mmc_cdb_t *p_cdb,
> + cdio_mmc_direction_t e_direction,
> + unsigned int i_buf, /*in/out*/ void *p_buf )
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + struct {
> + UCHAR auch_sign[4]; // 'CD01'
> + USHORT us_data_length; // length of the Data Packet
> + USHORT us_cmd_length; // length of the Command Buffer
> + USHORT us_flags; // flags
> + BYTE auc_cmd_buffer[16]; // Command Buffer for SCSI command
> + } s_param = {
> + .auch_sign = {'C', 'D', '0', '1'},
> + };
> +
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> +
> + s_param.us_data_length = i_buf;
> + s_param.us_cmd_length = i_cdb;
> + s_param.us_flags =
> + ( e_direction == SCSI_MMC_DATA_READ ) ? EX_DIRECTION_IN : 0;
> +
> + memcpy( s_param.auc_cmd_buffer, p_cdb, i_cdb );
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMDISK, CDROMDISK_EXECMD,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + p_buf, i_buf, &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("run_mmc_cmd_os2 : DosDevIOCtl(EXECMD) = 0x%lx\n", rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + return DRIVER_OP_SUCCESS;
> +}
> +
> +/*!
> + Initialize CD device.
> + */
> +static bool
> +init_os2 (void *p_user_data)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + ULONG ul_action;
> + ULONG rc;
> +
> + if (p_env->gen.init) {
> + cdio_warn ("init called more than once");
> + return false;
> + }
> +
> + /* Initializations */
> + p_env->h_cd = 0;
> +
> + rc = DosOpen((PSZ)p_env->gen.source_name, &p_env->h_cd,
> + &ul_action, 0, FILE_NORMAL,
> + OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW,
> + OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE | OPEN_FLAGS_DASD,
> + NULL );
> + if( rc )
> + {
> + cdio_warn("init_os2 : DosOpen(%s) = %ld\n", p_env->gen.source_name, rc
> );
> +
> + return false;
> + }
> +
> + p_env->uc_drive = toupper( p_env->gen.source_name[ 0 ]) - 'A';
> +
> + p_env->gen.init = true;
> + p_env->gen.toc_init = false;
> + p_env->gen.b_cdtext_init = false;
> + p_env->gen.b_cdtext_error = false;
> + p_env->gen.fd = p_env->h_cd;
> +
> + return true;
> +}
> +
> +/*!
> + Release and free resources associated with cd.
> + */
> +static void
> +free_os2 (void *p_user_data)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + if( !p_env )
> + return;
> +
> + free (p_env->gen.source_name);
> +
> + if( p_env->h_cd )
> + DosClose( p_env->h_cd );
> +
> + free (p_env);
> +
> +}
> +
> +/*!
> + Reads i_blocks of audio sectors from cd device into p_data starting
> + from i_lsn.
> + Returns DRIVER_OP_SUCCESS if no error.
> + */
> +static int
> +read_audio_sectors_os2 (void *p_user_data, void *p_buf, lsn_t i_lsn,
> + unsigned int i_blocks)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + struct
> + {
> + UCHAR auch_sign[ 4 ];
> + BYTE uc_addr_mode;
> + USHORT us_sectors;
> + ULONG ul_start_sector;
> + BYTE uc_reserved;
> + BYTE uc_interleaved_size;
> + } s_param = {
> + .auch_sign = {'C', 'D', '0', '1'},
> + .uc_addr_mode = 0, /* use LBA format */
> + };
> +
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> +
> + s_param.us_sectors = i_blocks;
> + s_param.ul_start_sector = i_lsn;
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMDISK, CDROMDISK_READLONG,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + p_buf, CDIO_CD_FRAMESIZE_RAW * i_blocks, &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("read_audio_sectors_os2 : DosDevIOCtl(READLONG) = 0x%lx\n",
> rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + return DRIVER_OP_SUCCESS;
> +}
> +
> +/*!
> + Reads a single raw sector using the DosDevIOCtl method into
> + data starting from lsn. Returns 0 if no error.
> + */
> +static int
> +read_raw_sector (_img_private_t *p_env, void *p_buf, lsn_t lsn)
> +{
> + struct
> + {
> + UCHAR auch_sign[ 4 ];
> + BYTE uc_addr_mode;
> + USHORT us_sectors;
> + ULONG ul_start_sector;
> + BYTE uc_reserved;
> + BYTE uc_interleaved_size;
> + } s_param = {
> + .auch_sign = {'C', 'D', '0', '1'},
> + .uc_addr_mode = 0, /* use LBA format */
> + .us_sectors = 1,
> + };
> +
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> +
> + s_param.ul_start_sector = lsn;
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMDISK, CDROMDISK_READLONG,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + p_buf, CDIO_CD_FRAMESIZE_RAW, &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("read_raw_sector : DosDevIOCtl(READLONG) = 0x%lx\n", rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + return DRIVER_OP_SUCCESS;
> +}
> +
> +/*!
> + Reads a single mode1 sector from cd device into data starting from
> + lsn. Returns 0 if no error.
> + */
> +static int
> +read_mode1_sector_os2 (void *p_user_data, void *p_buf, lsn_t lsn,
> + bool b_form2)
> +{
> + _img_private_t *p_env = p_user_data;
> + char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, };
> + int ret = read_raw_sector (p_env, buf, lsn);
> +
> + if ( 0 != ret) return ret;
> +
> + memcpy (p_buf,
> + buf + CDIO_CD_SYNC_SIZE+CDIO_CD_HEADER_SIZE,
> + b_form2 ? M2RAW_SECTOR_SIZE: CDIO_CD_FRAMESIZE);
> +
> + return 0;
> +}
> +
> +/*!
> + Reads nblocks of mode1 sectors from cd device into data starting
> + from lsn.
> + Returns 0 if no error.
> + */
> +static int
> +read_mode1_sectors_os2 (void *p_user_data, void *p_buf, lsn_t lsn,
> + bool b_form2, unsigned int nblocks)
> +{
> + _img_private_t *p_env = p_user_data;
> + int i;
> + int retval;
> +
> + for (i = 0; i < nblocks; i++) {
> + if (b_form2) {
> + retval = read_mode1_sector_os2 (
> + p_env, ((char *)p_buf) +
> + (M2RAW_SECTOR_SIZE * i),
> + lsn + i, true);
> + if ( retval ) return retval;
> + } else {
> + char buf[M2RAW_SECTOR_SIZE] = { 0, };
> + if ( (retval = read_mode1_sector_os2 (p_env, buf, lsn + i, false)) )
> + return retval;
> +
> + memcpy (((char *)p_buf) + (CDIO_CD_FRAMESIZE * i),
> + buf, CDIO_CD_FRAMESIZE);
> + }
> + }
> + return 0;
> +}
> +
> +/*!
> + Reads a single mode2 sector from cd device into data starting
> + from lsn. Returns 0 if no error.
> + */
> +static int
> +read_mode2_sector_os2 (void *p_user_data, void *data, lsn_t lsn,
> + bool b_form2)
> +{
> + _img_private_t *p_env = p_user_data;
> + char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, };
> + int ret = read_raw_sector (p_env, buf, lsn);
> +
> + if ( 0 != ret) return ret;
> +
> + memcpy (data,
> + buf + CDIO_CD_SYNC_SIZE + CDIO_CD_XA_HEADER,
> + b_form2 ? M2RAW_SECTOR_SIZE: CDIO_CD_FRAMESIZE);
> +
> + return 0;
> +}
> +
> +/*!
> + Reads nblocks of mode2 sectors from cd device into data starting
> + from lsn.
> + Returns 0 if no error.
> + */
> +static int
> +read_mode2_sectors_os2 (void *p_user_data, void *data, lsn_t lsn,
> + bool b_form2, unsigned int i_blocks)
> +{
> + int i;
> + int retval;
> + unsigned int blocksize = b_form2 ? M2RAW_SECTOR_SIZE : CDIO_CD_FRAMESIZE;
> +
> + for (i = 0; i < i_blocks; i++) {
> + if ( (retval = read_mode2_sector_os2 (p_user_data,
> + ((char *)data) + (blocksize * i),
> + lsn + i, b_form2)) )
> + return retval;
> + }
> + return 0;
> +}
> +
> +/*!
> + Return the size of the CD in logical block address (LBA) units.
> + */
> +static lsn_t
> +get_disc_last_lsn_os2 (void *p_user_data)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + struct {
> + UCHAR auch_sign[4];
> + } s_param = {{'C', 'D', '0', '1'}};
> +
> + ULONG ul_data_volume_size;
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMDISK, CDROMDISK_GETVOLUMESIZE,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + &ul_data_volume_size, sizeof( ul_data_volume_size ), &ul_data_len
> );
> +
> + if( rc )
> + {
> + cdio_warn("get_disc_last_lsn_os2 : DosDevIOCtl(GETVOLUMESIZE) =
> 0x%lx\n", rc );
> +
> + return CDIO_INVALID_LSN;
> + }
> +
> + return ul_data_volume_size;
> +}
> +
> +/*!
> + Set the key "arg" to "value" in source device.
> +*/
> +static int
> +set_arg_os2 (void *p_user_data, const char key[], const char value[])
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + if (!strcmp (key, "source"))
> + {
> + if (!value)
> + return DRIVER_OP_ERROR;
> +
> + free (p_env->gen.source_name);
> + p_env->gen.source_name = strdup (value);
> + }
> + else if (!strcmp (key, "access-mode"))
> + {
> + if (!strcmp(value, "OS2"))
> + p_env->access_mode = _AM_OS2;
> + else
> + cdio_warn ("unknown access type: %s. ignored.", value);
> + }
> + else
> + return DRIVER_OP_ERROR;
> +
> + return DRIVER_OP_SUCCESS;
> +}
> +
> +/*!
> + Read and cache the CD's Track Table of Contents and track info.
> + Return true if successful or false if an error.
> +*/
> +static bool
> +read_toc_os2 (void *p_user_data)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + struct {
> + UCHAR auch_sign[4];
> + } s_param_disk = {{'C', 'D', '0', '1'}};
> +
> + struct {
> + BYTE uc_first_track;
> + BYTE uc_last_track;
> + ULONG ul_lead_out_addr; /* in MSF */
> + } s_data_disk;
> +
> + struct {
> + UCHAR auch_sign[4];
> + BYTE uc_track;
> + } s_param_track = {
> + .auch_sign = {'C', 'D', '0', '1'},
> + };
> +
> + struct {
> + ULONG ul_track_addr; /* in MSF */
> + BYTE uc_control_and_adr;
> + } s_data_track;
> +
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> + int i_track;
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_GETAUDIODISK,
> + &s_param_disk, sizeof( s_param_disk ), &ul_param_len,
> + &s_data_disk, sizeof( s_data_disk ), &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("read_toc_os2 : DosDevIOCtl(GETAUDIODISK) = 0x%lx\n", rc );
> +
> + return false;
> + }
> +
> + p_env->gen.i_first_track = s_data_disk.uc_first_track;
> + p_env->gen.i_tracks = s_data_disk.uc_last_track -
> s_data_disk.uc_first_track + 1;
> +
> + p_env->i_first_track = s_data_disk.uc_first_track;
> + p_env->i_last_track = s_data_disk.uc_last_track;
> +
> + for( i_track = p_env->i_first_track; i_track <= p_env->i_last_track;
> i_track++ )
> + {
> + s_param_track.uc_track = i_track;
> +
> + rc = DosDevIOCtl(
> + p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_GETAUDIOTRACK,
> + &s_param_track, sizeof( s_param_track ), &ul_param_len,
> + &s_data_track, sizeof( s_data_track ), &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("read_toc_os2 : DosDevIOCtl(GETAUDIOTRACK) = 0x%lx\n", rc );
> +
> + return false;
> + }
> +
> + p_env->toc[i_track].lsn_start =
> + cdio_lba_to_lsn( cdio_msf3_to_lba(
> + ( s_data_track.ul_track_addr >> 16 ) & 0xFF,
> + ( s_data_track.ul_track_addr >> 8 ) & 0xFF,
> + s_data_track.ul_track_addr & 0xFF ));
> +
> + p_env->toc[i_track].uc_adr = s_data_track.uc_control_and_adr
> & 0x0F;
> + p_env->toc[i_track].uc_control = ( s_data_track.uc_control_and_adr >> 4
> ) & 0x0F;
> +
> + p_env->gen.track_flags[i_track].preemphasis =
> + p_env->toc[i_track].uc_control & 0x01
> + ? CDIO_TRACK_FLAG_TRUE : CDIO_TRACK_FLAG_FALSE;
> +
> + p_env->gen.track_flags[i_track].copy_permit =
> + p_env->toc[i_track].uc_control & 0x02
> + ? CDIO_TRACK_FLAG_TRUE : CDIO_TRACK_FLAG_FALSE;
> +
> + p_env->gen.track_flags[i_track].channels =
> + p_env->toc[i_track].uc_control & 0x08 ? 4 : 2;
> + }
> +
> + /* store lead out info */
> + p_env->toc[p_env->i_last_track + 1].lsn_start =
> + cdio_lba_to_lsn( cdio_msf3_to_lba(
> + ( s_data_disk.ul_lead_out_addr >> 16 ) & 0xFF,
> + ( s_data_disk.ul_lead_out_addr >> 8 ) & 0xFF,
> + s_data_disk.ul_lead_out_addr & 0xFF ));
> +
> + p_env->gen.toc_init = true;
> +
> + return true;
> +}
> +
> +/*!
> + Eject media.
> + */
> +static driver_return_code_t
> +eject_media_os2 (void *p_user_data)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + struct {
> + BYTE uc_cmd_info;
> + BYTE uc_drive;
> + } s_param;
> +
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> +
> + s_param.uc_cmd_info = 2;
> + s_param.uc_drive = p_env->uc_drive;
> +
> + rc = DosDevIOCtl(
> + ( HFILE )-1, IOCTL_DISK, DSK_UNLOCKEJECTMEDIA,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + NULL, 0, &ul_data_len );
> +
> + if( rc )
> + {
> + cdio_warn("eject_media_os2 : DosDevIOCtl(UNLOCKEJECTMEDIA) = 0x%lx\n",
> rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + return DRIVER_OP_SUCCESS;
> +}
> +
> +/*!
> + Return the value associated with the key "arg".
> +*/
> +static const char *
> +get_arg_os2 (void *p_user_data, const char key[])
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + if (!strcmp (key, "source")) {
> + return p_env->gen.source_name;
> + } else if (!strcmp (key, "access-mode")) {
> + switch (p_env->access_mode) {
> + case _AM_OS2:
> + return "OS2";
> + case _AM_NONE:
> + return "no access method";
> + }
> + }
> + return NULL;
> +}
> +
> +/*!
> + Return the media catalog number MCN.
> +
> + Note: string is malloc'd so caller should free() then returned
> + string when done with it.
> +
> + */
> +static char *
> +_cdio_get_mcn (const void *p_user_data) {
> + const _img_private_t *p_env = p_user_data;
> + return mmc_get_mcn( p_env->gen.cdio );
> +}
> +
> +/*!
> + Get the format (XA, DATA, AUDIO) of a track.
> +*/
> +static track_format_t
> +get_track_format_os2(const _img_private_t *p_env, track_t i_track)
> +{
> + /* This is pretty much copied from the "badly broken" cdrom_count_tracks
> + in linux/cdrom.c.
> + */
> +
> + if (p_env->toc[i_track].uc_control & 0x04) {
> + if (p_env->toc[i_track].uc_adr == 0x10)
> + return TRACK_FORMAT_CDI;
> + else if (p_env->toc[i_track].uc_adr == 0x20)
> + return TRACK_FORMAT_XA;
> + else
> + return TRACK_FORMAT_DATA;
> + } else
> + return TRACK_FORMAT_AUDIO;
> +}
> +
> +/*!
> + Get format of track.
> +*/
> +static track_format_t
> +_cdio_get_track_format(void *p_obj, track_t i_track)
> +{
> + _img_private_t *p_env = p_obj;
> +
> + if ( !p_env )
> + return TRACK_FORMAT_ERROR;
> +
> + if (!p_env->gen.toc_init)
> + if (!read_toc_os2 (p_env))
> + return TRACK_FORMAT_ERROR;
> +
> + if ( i_track < p_env->gen.i_first_track
> + || i_track >= p_env->gen.i_tracks + p_env->gen.i_first_track )
> + return TRACK_FORMAT_ERROR;
> +
> + return get_track_format_os2(p_env, i_track);
> +}
> +
> +/*!
> + Return true if we have XA data (green, mode2 form1) or
> + XA data (green, mode2 form2). That is track begins:
> + sync - header - subheader
> + 12 4 - 8
> +
> + FIXME: there's gotta be a better design for this and get_track_format?
> +*/
> +static bool
> +_cdio_get_track_green(void *p_obj, track_t i_track)
> +{
> + _img_private_t *p_env = p_obj;
> +
> + switch (_cdio_get_track_format(p_env, i_track)) {
> + case TRACK_FORMAT_XA:
> + return true;
> + case TRACK_FORMAT_ERROR:
> + case TRACK_FORMAT_CDI:
> + case TRACK_FORMAT_AUDIO:
> + return false;
> + case TRACK_FORMAT_DATA:
> + default:
> + break;
> + }
> +
> + /* FIXME: Dunno if this is the right way, but it's what
> + I was using in cd-info for a while.
> + */
> + return ((p_env->toc[i_track].uc_control & 2) != 0);
> +}
> +
> +/*!
> + Return the starting MSF (minutes/secs/frames) for track number
> + i_tracks in obj. Track numbers start at 1.
> + The "leadout" track is specified either by
> + using i_tracks LEADOUT_TRACK or the total tracks+1.
> + False is returned if there is no track entry.
> +*/
> +static bool
> +_cdio_get_track_msf(void *p_user_data, track_t i_tracks, msf_t *p_msf)
> +{
> + _img_private_t *p_env = p_user_data;
> +
> + if (!p_msf)
> + return false;
> +
> + if (!p_env->gen.toc_init)
> + if (!read_toc_os2 (p_env))
> + return false;
> +
> + if (i_tracks == CDIO_CDROM_LEADOUT_TRACK)
> + i_tracks = p_env->gen.i_tracks+1;
> +
> + if (i_tracks > p_env->gen.i_tracks+1 || i_tracks == 0) {
> + return false;
> + } else {
> + cdio_lsn_to_msf(p_env->toc[i_tracks].lsn_start, p_msf);
> + return true;
> + }
> +}
> +
> +#endif /* HAVE_OS2_CDROM */
> +
> +/*!
> + Return an array of strings giving possible CD devices.
> + */
> +char **
> +cdio_get_devices_os2 (void)
> +{
> +#ifndef HAVE_OS2_CDROM
> + return NULL;
> +#else
> + char **drives = NULL;
> + unsigned int num_drives=0;
> +
> + struct {
> + BYTE uc_cmd_info;
> + BYTE uc_drive;
> + } s_param;
> +
> + struct {
> + struct {
> + USHORT us_bytes_per_sector;
> + BYTE uc_sectors_per_cluster;
> + USHORT us_reserved_sectors;
> + BYTE uc_number_of_fats;
> + USHORT us_root_dir_entries;
> + USHORT us_total_sectors;
> + BYTE uc_media_descriptor;
> + USHORT us_sectors_per_fat;
> + USHORT us_sectors_per_track;
> + USHORT us_number_of_heads;
> + ULONG ul_hidden_sectors;
> + ULONG ul_large_total_sectors;
> + BYTE auc_reserved[6];
> + } s_ebpb;
> +
> + USHORT us_cylinders;
> + BYTE uc_dev_type;
> + USHORT us_dev_attr;
> + } s_data;
> +
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + UCHAR uc_drive;
> + char sz_drive_str[ 3 ] = "X:";
> + ULONG rc;
> +
> + /* Scan the system for CD-ROM drives.
> + */
> +
> + for( uc_drive = 0; uc_drive < 26; uc_drive++ )
> + {
> + s_param.uc_cmd_info = 0;
> + s_param.uc_drive = uc_drive;
> +
> + rc = DosDevIOCtl(
> + ( HFILE )-1, IOCTL_DISK, DSK_GETDEVICEPARAMS,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + &s_data, sizeof( s_data ), &ul_data_len );
> +
> + if( rc )
> + continue;
> +
> + switch( s_data.s_ebpb.uc_media_descriptor )
> + {
> + case 4 : /* CD-R */
> + case 128 + 4 : /* CD-R but cannot be written */
> + case 5 : /* CD-ROM */
> + case 128 + 5 : /* CD-ROM but cannot be written */
> + case 6 : /* DVD-ROM */
> + case 128 + 6 : /* DVD-ROM but cannot be written */
> + case 7 : /* DVD-RAM */
> + case 128 + 7 : /* DVD-RAM but cannot be written */
> + case 8 : /* CD-RW */
> + case 128 + 8 : /* CD-RW but cannot be written */
> + case 9 : /* DVD-R */
> + case 128 + 9 : /* DVD-R but cannot be written */
> + case 10 : /* DVD-RW */
> + case 128 + 10 : /* DVD-RW but cannot be written */
> + case 11 : /* DVD+RW */
> + case 128 + 11 : /* DVD+RW but cannot be written */
> + sz_drive_str[0] = 'A' + uc_drive;
> + cdio_add_device_list(&drives, strdup(sz_drive_str), &num_drives);
> + break;
> + }
> + }
> +
> + cdio_add_device_list(&drives, NULL, &num_drives);
> + return drives;
> +#endif /*HAVE_OS2_CDROM*/
> +}
> +
> +#define IOCTL_CDROMDISK2 0x82
> +
> +#define CDROMDISK2_DRIVELETTERS 0x60
> +
> +/*!
> + Return a string containing the default CD device if none is specified.
> + if CdIo is NULL (we haven't initialized a specific device driver),
> + then find a suitable one and return the default device for that.
> +
> + NULL is returned if we couldn't get a default device.
> +*/
> +char *
> +cdio_get_default_device_os2(void)
> +{
> +#ifdef HAVE_OS2_CDROM
> + struct {
> + USHORT us_drive_count;
> + USHORT us_drive_first;
> + } s_drive_letters;
> +
> + HFILE h_cd2;
> + ULONG ul_action;
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + char sz_drive_str[ 3 ] = "X:";
> + ULONG rc;
> +
> + rc = DosOpen((PSZ)"CD-ROM2$", &h_cd2, &ul_action, 0, FILE_NORMAL,
> + OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW,
> + OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE,
> + NULL );
> +
> + if( rc )
> + {
> + cdio_warn("cdio_get_default_device_os2 : DosOpen(CD-ROM2$) = %ld\n", rc
> );
> +
> + return NULL;
> + }
> +
> + rc = DosDevIOCtl(
> + h_cd2, IOCTL_CDROMDISK2, CDROMDISK2_DRIVELETTERS,
> + NULL, 0, &ul_param_len,
> + &s_drive_letters, sizeof( s_drive_letters ), &ul_data_len );
> +
> + DosClose( h_cd2 );
> +
> + if( rc )
> + {
> + cdio_warn("cdio_get_default_device_os2 : DosDevIOCtl(DRIVELETTERS) =
> 0x%lx\n", rc );
> +
> + return NULL;
> + }
> +
> + if( s_drive_letters.us_drive_count == 0 )
> + return NULL;
> +
> + sz_drive_str[0] = 'A' + s_drive_letters.us_drive_first;
> +
> + return strdup( sz_drive_str );
> +#else
> + return NULL;
> +#endif
> +}
> +
> +/*!
> + Return true if source_name could be a device containing a CD-ROM.
> +*/
> +bool
> +cdio_is_device_os2(const char *source_name)
> +{
> + if (!source_name)
> + return false;
> +
> +#ifdef HAVE_OS2_CDROM
> + return (isalpha(source_name[0]) &&
> + source_name[1] == ':' &&
> + source_name[2] == '\0');
> +#else
> + return false;
> +#endif
> +}
> +
> +/*!
> + Close tray on CD-ROM.
> +
> + @param p_user_data the CD object to be acted upon.
> +
> +*/
> +driver_return_code_t
> +close_tray_os2 (const char *psz_os2_drive)
> +{
> +#ifdef HAVE_OS2_CDROM
> + struct {
> + BYTE uc_cmd_info;
> + BYTE uc_drive;
> + } s_param;
> +
> + ULONG ul_param_len;
> + ULONG ul_data_len;
> + ULONG rc;
> +
> + s_param.uc_cmd_info = 3;
> + s_param.uc_drive = toupper(psz_os2_drive[0]) - 'A';
> +
> + rc = DosDevIOCtl(
> + ( HFILE )-1, IOCTL_DISK, DSK_UNLOCKEJECTMEDIA,
> + &s_param, sizeof( s_param ), &ul_param_len,
> + NULL, 0, &ul_data_len );
> +
> + if( rc && rc != 99 /* device in use */ )
> + {
> + cdio_warn("close_tray_os2 : DosDevIOCtl(UNLOCKEJECTMEDIA) = 0x%lx\n",
> rc );
> +
> + return DRIVER_OP_ERROR;
> + }
> +
> + return DRIVER_OP_SUCCESS;
> +#else
> + return DRIVER_OP_UNSUPPORTED;
> +#endif /* HAVE_OS2_CDROM */
> +}
> +
> +/*!
> + Initialization routine. This is the only thing that doesn't
> + get called via a function pointer. In fact *we* are the
> + ones to set that up.
> + */
> +CdIo_t *
> +cdio_open_os2 (const char *psz_orig_source)
> +{
> +
> +#ifdef HAVE_OS2_CDROM
> + CdIo_t *ret;
> + _img_private_t *_data;
> + char *psz_source;
> +
> + cdio_funcs_t _funcs;
> +
> + memset( &_funcs, 0, sizeof(_funcs) );
> +
> + _funcs.audio_get_volume = audio_get_volume_os2;
> + _funcs.audio_pause = audio_pause_os2;
> + _funcs.audio_play_msf = audio_play_msf_os2;
> +#if 0
> + _funcs.audio_play_track_index = audio_play_track_index_os2;
> +#endif
> + _funcs.audio_read_subchannel = audio_read_subchannel_os2;
> + _funcs.audio_resume = audio_resume_os2;
> + _funcs.audio_set_volume = audio_set_volume_os2;
> + _funcs.audio_stop = audio_stop_os2;
> + _funcs.eject_media = eject_media_os2;
> + _funcs.free = free_os2;
> + _funcs.get_arg = get_arg_os2;
> +#if 0
> + _funcs.get_blocksize = get_blocksize_os2;
> +#endif
> + _funcs.get_cdtext = get_cdtext_generic;
> + _funcs.get_default_device = cdio_get_default_device_os2;
> + _funcs.get_devices = cdio_get_devices_os2;
> + _funcs.get_disc_last_lsn = get_disc_last_lsn_os2;
> + _funcs.get_discmode = get_discmode_os2;
> + _funcs.get_drive_cap = get_drive_cap_mmc;
> + _funcs.get_first_track_num = get_first_track_num_generic;
> + _funcs.get_hwinfo = NULL;
> +#if 0
> + _funcs.get_last_session = get_last_session_os2;
> +#endif
> + _funcs.get_media_changed = get_media_changed_mmc;
> + _funcs.get_mcn = _cdio_get_mcn;
> + _funcs.get_num_tracks = get_num_tracks_generic;
> + _funcs.get_track_channels = get_track_channels_generic;
> + _funcs.get_track_copy_permit = get_track_copy_permit_generic;
> + _funcs.get_track_format = _cdio_get_track_format;
> + _funcs.get_track_green = _cdio_get_track_green;
> + _funcs.get_track_lba = NULL; /* This could be done if need be. */
> +#if 0
> + _funcs.get_track_pregap_lba = get_track_pregap_lba_os2;
> + _funcs.get_track_isrc = get_track_isrc_os2;
> +#endif
> + _funcs.get_track_msf = _cdio_get_track_msf;
> + _funcs.get_track_preemphasis = get_track_preemphasis_generic;
> + _funcs.lseek = cdio_generic_lseek;
> + _funcs.read = cdio_generic_read;
> + _funcs.read_audio_sectors = read_audio_sectors_os2;
> + _funcs.read_data_sectors = read_data_sectors_mmc;
> + _funcs.read_mode1_sector = read_mode1_sector_os2;
> + _funcs.read_mode1_sectors = read_mode1_sectors_os2;
> + _funcs.read_mode2_sector = read_mode2_sector_os2;
> + _funcs.read_mode2_sectors = read_mode2_sectors_os2;
> + _funcs.read_toc = read_toc_os2;
> + _funcs.run_mmc_cmd = run_mmc_cmd_os2;
> + _funcs.set_arg = set_arg_os2;
> + _funcs.set_blocksize = set_blocksize_mmc;
> + _funcs.set_speed = set_drive_speed_mmc;
> +
> + _data = calloc(1, sizeof (_img_private_t));
> + _data->access_mode = _AM_OS2;
> + _data->gen.init = false;
> + _data->gen.fd = -1;
> +
> + if (NULL == psz_orig_source) {
> + psz_source=cdio_get_default_device_os2();
> + if (NULL == psz_source) return NULL;
> + set_arg_os2(_data, "source", psz_source);
> + free(psz_source);
> + } else {
> + if (cdio_is_device_os2(psz_orig_source))
> + set_arg_os2(_data, "source", psz_orig_source);
> + else {
> + /* The below would be okay if all device drivers worked this way. */
> +#if 0
> + cdio_info ("source %s is a not a device", psz_orig_source);
> +#endif
> + free(_data);
> + return NULL;
> + }
> + }
> +
> + ret = cdio_new ((void *)_data, &_funcs);
> + if (ret == NULL) return NULL;
> +
> + ret->driver_id = DRIVER_OS2;
> +
> + if (init_os2(_data))
> + return ret;
> + else {
> + free_os2 (_data);
> + return NULL;
> + }
> +#else
> + return NULL;
> +#endif /* HAVE_OS2_CDROM */
> +
> +}
> +
> +/*!
> + Initialization routine. This is the only thing that doesn't
> + get called via a function pointer. In fact *we* are the
> + ones to set that up.
> + */
> +CdIo_t *
> +cdio_open_am_os2 (const char *psz_source_name, const char *psz_access_mode)
> +{
> +
> + if (psz_access_mode != NULL)
> + cdio_warn ("there is only one access mode for OS/2. Arg %s ignored",
> + psz_access_mode);
> + return cdio_open_os2(psz_source_name);
> +}
> +
> +bool
> +cdio_have_os2 (void)
> +{
> +#ifdef HAVE_OS2_CDROM
> + return true;
> +#else
> + return false;
> +#endif /* HAVE_OS2_CDROM */
> +}
> +
> +
> diff -buNr src/util.c.org src/util.c
> --- src/util.c.org 2008-04-15 10:22:12.000000000 +0900
> +++ src/util.c 2009-01-09 01:59:12.000000000 +0900
> @@ -160,7 +160,7 @@
> char *
> fillout_device_name(const char *device_name)
> {
> -#if defined(HAVE_WIN32_CDROM)
> +#if defined(HAVE_WIN32_CDROM) || defined(HAVE_OS2_CDROM)
> return strdup(device_name);
> #else
> unsigned int prefix_len = strlen(DEV_PREFIX);