claunia/libcdio-osx
Archived
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Start to implement ability to a detect media change.

Browse Source 
scsi_mmc -> mmc. Warning: some breakage may occur.
This commit is contained in:
rocky
2005-02-06 11:13:37 +00:00
parent fc60baec9c
commit 71a71d7f56
24 changed files with 404 additions and 694 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
example/mmc1.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: mmc1.c,v 1.1 2005/02/04 23:12:16 rocky Exp $ $Id: mmc1.c,v 1.2 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2004 Rocky Bernstein <rocky@panix.com> Copyright (C) 2004 Rocky Bernstein <rocky@panix.com>
@@ -51,9 +51,8 @@ main(int argc, const char *argv[])
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_INQUIRY); CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_INQUIRY);
cdb.field[4] = sizeof(buf); cdb.field[4] = sizeof(buf);
i_status = scsi_mmc_run_cmd(p_cdio, DEFAULT_TIMEOUT_MS, i_status = mmc_run_cmd(p_cdio, DEFAULT_TIMEOUT_MS, &cdb,
&cdb, SCSI_MMC_DATA_READ, SCSI_MMC_DATA_READ, sizeof(buf), &buf);
sizeof(buf), &buf);
if (i_status == 0) { if (i_status == 0) {
char psz_vendor[CDIO_MMC_HW_VENDOR_LEN+1]; char psz_vendor[CDIO_MMC_HW_VENDOR_LEN+1];
char psz_model[CDIO_MMC_HW_MODEL_LEN+1]; char psz_model[CDIO_MMC_HW_MODEL_LEN+1];

7
example/mmc2.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: mmc2.c,v 1.1 2005/02/04 23:12:16 rocky Exp $ $Id: mmc2.c,v 1.2 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2004 Rocky Bernstein <rocky@panix.com> Copyright (C) 2004 Rocky Bernstein <rocky@panix.com>
@@ -52,9 +52,8 @@ main(int argc, const char *argv[])
cdb.field[1] = CDIO_MMC_GET_CONF_ALL_FEATURES; cdb.field[1] = CDIO_MMC_GET_CONF_ALL_FEATURES;
cdb.field[3] = 0x0; cdb.field[3] = 0x0;
i_status = scsi_mmc_run_cmd(p_cdio, 0, i_status = mmc_run_cmd(p_cdio, 0, &cdb, SCSI_MMC_DATA_READ, sizeof(buf),
&cdb, SCSI_MMC_DATA_READ, &buf);
sizeof(buf), &buf);
if (i_status == 0) { if (i_status == 0) {
uint8_t *p; uint8_t *p;
uint32_t i_data; uint32_t i_data;

83
example/scsi-mmc1.c
View File

@@ -1,83 +0,0 @@
/*
$Id: scsi-mmc1.c,v 1.4 2005/01/29 20:54:20 rocky Exp $
Copyright (C) 2004 Rocky Bernstein <rocky@panix.com>
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 2 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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/* Simple program to show use of SCSI MMC interface. Is basically the
the libdio scsi_mmc_get_hwinfo() routine.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdio.h>
#include <sys/types.h>
#include <cdio/cdio.h>
#include <cdio/scsi_mmc.h>
#include <string.h>
/* Set how long to wait for MMC commands to complete */
#define DEFAULT_TIMEOUT_MS 10000
int
main(int argc, const char *argv[])
{
CdIo_t *p_cdio;
p_cdio = cdio_open (NULL, DRIVER_UNKNOWN);
if (NULL == p_cdio) {
printf("Couldn't find CD\n");
return 1;
} else {
int i_status; /* Result of MMC command */
char buf[36] = { 0, }; /* Place to hold returned data */
scsi_mmc_cdb_t cdb = {{0, }}; /* Command Descriptor Buffer */
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_INQUIRY);
cdb.field[4] = sizeof(buf);
i_status = scsi_mmc_run_cmd(p_cdio, DEFAULT_TIMEOUT_MS,
&cdb, SCSI_MMC_DATA_READ,
sizeof(buf), &buf);
if (i_status == 0) {
char psz_vendor[CDIO_MMC_HW_VENDOR_LEN+1];
char psz_model[CDIO_MMC_HW_MODEL_LEN+1];
char psz_rev[CDIO_MMC_HW_REVISION_LEN+1];
memcpy(psz_vendor, buf + 8, sizeof(psz_vendor)-1);
psz_vendor[sizeof(psz_vendor)-1] = '\0';
memcpy(psz_model,
buf + 8 + CDIO_MMC_HW_VENDOR_LEN,
sizeof(psz_model)-1);
psz_model[sizeof(psz_model)-1] = '\0';
memcpy(psz_rev,
buf + 8 + CDIO_MMC_HW_VENDOR_LEN +CDIO_MMC_HW_MODEL_LEN,
sizeof(psz_rev)-1);
psz_rev[sizeof(psz_rev)-1] = '\0';
printf("Vendor: %s\nModel: %s\nRevision: %s\n",
psz_vendor, psz_model, psz_rev);
} else {
printf("Couldn't get INQUIRY data (vendor, model, and revision).\n");
}
}
cdio_destroy(p_cdio);
return 0;
}

324
example/scsi-mmc2.c
View File

@@ -1,324 +0,0 @@
/*
$Id: scsi-mmc2.c,v 1.3 2005/01/29 20:54:20 rocky Exp $
Copyright (C) 2004 Rocky Bernstein <rocky@panix.com>
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 2 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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/* A program to using the MMC interface to list CD and drive features
from the MMC GET_CONFIGURATION command . */
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdio.h>
#include <sys/types.h>
#include <cdio/cdio.h>
#include <cdio/scsi_mmc.h>
#include <string.h>
/* Set how long do wto wait for SCSI-MMC commands to complete */
#define DEFAULT_TIMEOUT_MS 10000
int
main(int argc, const char *argv[])
{
CdIo_t *p_cdio;
p_cdio = cdio_open (NULL, DRIVER_UNKNOWN);
if (NULL == p_cdio) {
printf("Couldn't find CD\n");
return 1;
} else {
int i_status; /* Result of MMC command */
uint8_t buf[500] = { 0, }; /* Place to hold returned data */
scsi_mmc_cdb_t cdb = {{0, }}; /* Command Descriptor Buffer */
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_GET_CONFIGURATION);
CDIO_MMC_SET_READ_LENGTH8(cdb.field, sizeof(buf));
cdb.field[1] = CDIO_MMC_GET_CONF_ALL_FEATURES;
cdb.field[3] = 0x0;
i_status = scsi_mmc_run_cmd(p_cdio, 0,
&cdb, SCSI_MMC_DATA_READ,
sizeof(buf), &buf);
if (i_status == 0) {
uint8_t *p;
uint32_t i_data;
uint8_t *p_max = buf + 65530;
i_data = (unsigned int) CDIO_MMC_GET_LEN32(buf);
/* set to first sense feature code, and then walk through the masks */
p = buf + 8;
while( (p < &(buf[i_data])) && (p < p_max) ) {
uint16_t i_feature;
uint8_t i_feature_additional = p[3];
i_feature = CDIO_MMC_GET_LEN16(p);
switch( i_feature )
{
uint8_t *q;
case CDIO_MMC_FEATURE_PROFILE_LIST:
printf("Profile List Feature\n");
for ( q = p+4 ; q < p + i_feature_additional ; q += 4 ) {
int i_profile=CDIO_MMC_GET_LEN16(q);
switch (i_profile) {
case CDIO_MMC_FEATURE_PROF_NON_REMOVABLE:
printf("\tRe-writable disk, capable of changing behavior");
break;
case CDIO_MMC_FEATURE_PROF_REMOVABLE:
printf("\tdisk Re-writable; with removable media");
break;
case CDIO_MMC_FEATURE_PROF_MO_ERASABLE:
printf("\tErasable Magneto-Optical disk with sector erase capability");
break;
case CDIO_MMC_FEATURE_PROF_MO_WRITE_ONCE:
printf("\tWrite Once Magneto-Optical write once");
break;
case CDIO_MMC_FEATURE_PROF_AS_MO:
printf("\tAdvance Storage Magneto-Optical");
break;
case CDIO_MMC_FEATURE_PROF_CD_ROM:
printf("\tRead only Compact Disc capable");
break;
case CDIO_MMC_FEATURE_PROF_CD_R:
printf("\tWrite once Compact Disc capable");
break;
case CDIO_MMC_FEATURE_PROF_CD_RW:
printf("\tCD-RW Re-writable Compact Disc capable");
break;
case CDIO_MMC_FEATURE_PROF_DVD_ROM:
printf("\tRead only DVD");
break;
case CDIO_MMC_FEATURE_PROF_DVD_R_SEQ:
printf("\tRe-recordable DVD using Sequential recording");
break;
case CDIO_MMC_FEATURE_PROF_DVD_RAM:
printf("\tRe-writable DVD");
break;
case CDIO_MMC_FEATURE_PROF_DVD_RW_RO:
printf("\tRe-recordable DVD using Restricted Overwrite");
break;
case CDIO_MMC_FEATURE_PROF_DVD_RW_SEQ:
printf("\tRe-recordable DVD using Sequential recording");
break;
case CDIO_MMC_FEATURE_PROF_DVD_PRW:
printf("\tDVD+RW - DVD ReWritable");
break;
case CDIO_MMC_FEATURE_PROF_DVD_PR:
printf("\tDVD+R - DVD Recordable");
break;
case CDIO_MMC_FEATURE_PROF_DDCD_ROM:
printf("\tRead only DDCD");
break;
case CDIO_MMC_FEATURE_PROF_DDCD_R:
printf("\tDDCD-R Write only DDCD");
break;
case CDIO_MMC_FEATURE_PROF_DDCD_RW:
printf("\tRe-Write only DDCD");
break;
case CDIO_MMC_FEATURE_PROF_NON_CONFORM:
printf("\tThe Logical Unit does not conform to any Profile.");
break;
default:
printf("\tUnknown Profile %x", i_profile);
break;
}
if (q[2] & 1) {
printf(" - on");
}
printf("\n");
}
printf("\n");
break;
case CDIO_MMC_FEATURE_CORE:
{
uint8_t *q = p+4;
uint32_t i_interface_standard = CDIO_MMC_GET_LEN32(q);
printf("Core Feature\n");
switch(i_interface_standard) {
case 0:
printf("\tunspecified interface\n");
break;
case 1:
printf("\tSCSI interface\n");
break;
case 2:
printf("\tATAPI interface\n");
break;
case 3:
printf("\tIEEE 1394 interface\n");
break;
case 4:
printf("\tIEEE 1394A interface\n");
break;
case 5:
printf("\tFibre Channel interface\n");
}
printf("\n");
break;
}
case CDIO_MMC_FEATURE_REMOVABLE_MEDIUM:
printf("Removable Medium Feature\n");
switch(p[4] >> 5) {
case 0:
printf("\tCaddy/Slot type loading mechanism\n");
break;
case 1:
printf("\tTray type loading mechanism\n");
break;
case 2:
printf("\tPop-up type loading mechanism\n");
break;
case 4:
printf("\tEmbedded changer with individually changeable discs\n");
break;
case 5:
printf("\tEmbedded changer using a magazine mechanism\n");
break;
default:
printf("\tUnknown changer mechanism\n");
}
printf("\tcan%s eject the medium or magazine via the normal "
"START/STOP command\n",
(p[4] & 8) ? "": "not");
printf("\tcan%s be locked into the Logical Unit\n",
(p[4] & 1) ? "": "not");
printf("\n");
break;
case CDIO_MMC_FEATURE_WRITE_PROTECT:
printf("Write Protect Feature\n");
break;
case CDIO_MMC_FEATURE_RANDOM_READABLE:
printf("Random Readable Feature\n");
break;
case CDIO_MMC_FEATURE_MULTI_READ:
printf("Multi-Read Feature\n");
break;
case CDIO_MMC_FEATURE_CD_READ:
printf("CD Read Feature\n");
printf("\tC2 Error pointers are %ssupported\n",
(p[4] & 2) ? "": "not ");
printf("\tCD-Text is %ssupported\n",
(p[4] & 1) ? "": "not ");
printf("\n");
break;
case CDIO_MMC_FEATURE_DVD_READ:
printf("DVD Read Feature\n");
break;
case CDIO_MMC_FEATURE_RANDOM_WRITABLE:
printf("Random Writable Feature\n");
break;
case CDIO_MMC_FEATURE_INCR_WRITE:
printf("Incremental Streaming Writable Feature\n");
break;
case CDIO_MMC_FEATURE_SECTOR_ERASE:
printf("Sector Erasable Feature\n");
break;
case CDIO_MMC_FEATURE_FORMATABLE:
printf("Formattable Feature\n");
break;
case CDIO_MMC_FEATURE_DEFECT_MGMT:
printf("Management Ability of the Logical Unit/media system "
"to provide an apparently defect-free space.\n");
break;
case CDIO_MMC_FEATURE_WRITE_ONCE:
printf("Write Once Feature\n");
break;
case CDIO_MMC_FEATURE_RESTRICT_OVERW:
printf("Restricted Overwrite Feature\n");
break;
case CDIO_MMC_FEATURE_CD_RW_CAV:
printf("CD-RW CAV Write Feature\n");
break;
case CDIO_MMC_FEATURE_MRW:
printf("MRW Feature\n");
break;
case CDIO_MMC_FEATURE_DVD_PRW:
printf("DVD+RW Feature\n");
break;
case CDIO_MMC_FEATURE_DVD_PR:
printf("DVD+R Feature\n");
break;
case CDIO_MMC_FEATURE_CD_TAO:
printf("CD Track at Once Feature\n");
break;
case CDIO_MMC_FEATURE_CD_SAO:
printf("CD Mastering (Session at Once) Feature\n");
break;
case CDIO_MMC_FEATURE_POWER_MGMT:
printf("Initiator and device directed power management\n");
break;
case CDIO_MMC_FEATURE_CDDA_EXT_PLAY:
printf("CD Audio External Play Feature\n");
printf("\tSCAN command is %ssupported\n",
(p[4] & 4) ? "": "not ");
printf("\taudio channels can %sbe muted separately\n",
(p[4] & 2) ? "": "not ");
printf("\taudio channels can %shave separate volume levels\n",
(p[4] & 1) ? "": "not ");
{
uint8_t *q = p+6;
uint16_t i_vol_levels = CDIO_MMC_GET_LEN16(q);
printf("\t%d volume levels can be set\n", i_vol_levels);
}
printf("\n");
break;
case CDIO_MMC_FEATURE_MCODE_UPGRADE:
printf("Ability for the device to accept new microcode via "
"the interface\n");
break;
case CDIO_MMC_FEATURE_TIME_OUT:
printf("Ability to respond to all commands within a "
"specific time\n");
break;
case CDIO_MMC_FEATURE_DVD_CSS:
printf("Ability to perform DVD CSS/CPPM authentication and"
" RPC\n");
break;
case CDIO_MMC_FEATURE_RT_STREAMING:
printf("Ability to read and write using Initiator requested performance parameters\n");
break;
case CDIO_MMC_FEATURE_LU_SN: {
uint8_t i_serial = *(p+3);
char serial[257] = { '\0', };
printf("The Logical Unit has a unique identifier:\n");
memcpy(serial, p+4, i_serial);
printf("\t%s\n\n", serial);
break;
}
default:
if ( 0 != (i_feature & 0xFF00) ) {
printf("Vendor-specific feature code %x\n", i_feature);
} else {
printf("Unknown feature code %x\n", i_feature);
}
}
p += i_feature_additional + 4;
}
} else {
printf("Didn't get all feature codes\n");
}
}
cdio_destroy(p_cdio);
return 0;
}

26
include/cdio/device.h
View File

@@ -1,5 +1,5 @@
/* -*- c -*- /* -*- c -*-
$Id: device.h,v 1.11 2005/02/06 04:20:25 rocky Exp $ $Id: device.h,v 1.12 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2005 Rocky Bernstein <rocky@panix.com>
@@ -274,16 +274,13 @@ extern "C" {
/* out*/ cdio_hwinfo_t *p_hw_info ); /* out*/ cdio_hwinfo_t *p_hw_info );
/*! /*!
Get the drive speed. Find out if media has changed since the last call.
@param p_cdio the CD object to be acted upon.
@return the drive speed if greater than 0. DRIVER_OP_ERROR if we @return 1 if media has changed since last call, 0 if not. Error
had an error, DRIVER_OP_UNSUPPORTED if this is not implemented for return codes are the same as driver_return_code_t
the current driver. */
int cdio_get_media_changed(CdIo_t *p_cdio);
@see cdio_set_speed
*/
int cdio_get_speed ( const CdIo_t *p_cdio, int i_speed );
/*! True if AIX driver is available. */ /*! True if AIX driver is available. */
bool cdio_have_aix (void); bool cdio_have_aix (void);
@@ -392,10 +389,9 @@ extern "C" {
char **cdio_get_devices_bincue(void); char **cdio_get_devices_bincue(void);
/*! Return a string containing the default CUE file that would /*! @return string containing the default CUE file that would be
be used when none is specified. used when none is specified. NULL is returned on error or there
is no device.
NULL is returned on error or there is no device.
*/ */
char * cdio_get_default_device_cdrdao(void); char * cdio_get_default_device_cdrdao(void);

53
include/cdio/scsi_mmc.h
View File

@@ -1,5 +1,5 @@
/* /*
$Id: scsi_mmc.h,v 1.43 2005/02/05 14:42:28 rocky Exp $ $Id: scsi_mmc.h,v 1.44 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -83,6 +83,8 @@ typedef enum {
handled by Plextor drives. handled by Plextor drives.
*/ */
CDIO_MMC_GPCMD_GET_EVENT_STATUS = 0x4a, /**< Report events and
Status. */
CDIO_MMC_GPCMD_PAUSE_RESUME = 0x4b, /**< Stop or restart audio CDIO_MMC_GPCMD_PAUSE_RESUME = 0x4b, /**< Stop or restart audio
playback. (10 bytes). playback. (10 bytes).
Used with a PLAY command. */ Used with a PLAY command. */
@@ -394,7 +396,7 @@ typedef enum scsi_mmc_direction {
Buffer (CDB) for a given MMC command. The length will be Buffer (CDB) for a given MMC command. The length will be
either 6, 10, or 12. either 6, 10, or 12.
*/ */
uint8_t scsi_mmc_get_cmd_len(uint8_t scsi_cmd); uint8_t mmc_get_cmd_len(uint8_t scsi_cmd);
/*! /*!
@@ -412,7 +414,7 @@ uint8_t scsi_mmc_get_cmd_len(uint8_t scsi_cmd);
@return 0 if command completed successfully. @return 0 if command completed successfully.
*/ */
int scsi_mmc_run_cmd( const CdIo_t *p_cdio, unsigned int i_timeout_ms, int mmc_run_cmd( const CdIo_t *p_cdio, unsigned int i_timeout_ms,
const scsi_mmc_cdb_t *p_cdb, const scsi_mmc_cdb_t *p_cdb,
scsi_mmc_direction_t e_direction, unsigned int i_buf, scsi_mmc_direction_t e_direction, unsigned int i_buf,
/*in/out*/ void *p_buf ); /*in/out*/ void *p_buf );
@@ -421,14 +423,14 @@ int scsi_mmc_run_cmd( const CdIo_t *p_cdio, unsigned int i_timeout_ms,
@return 0 if successful. @return 0 if successful.
*/ */
int scsi_mmc_eject_media( const CdIo_t *p_cdio ); int mmc_eject_media( const CdIo_t *p_cdio );
/*! /*!
Get the lsn of the end of the CD Get the lsn of the end of the CD
@return the lsn. On error return CDIO_INVALID_LSN. @return the lsn. On error return CDIO_INVALID_LSN.
*/ */
lsn_t scsi_mmc_get_disc_last_lsn( const CdIo_t *p_cdio ); lsn_t mmc_get_disc_last_lsn( const CdIo_t *p_cdio );
/*! /*!
Return the discmode as reported by the MMC Read (FULL) TOC Return the discmode as reported by the MMC Read (FULL) TOC
@@ -439,14 +441,14 @@ lsn_t scsi_mmc_get_disc_last_lsn( const CdIo_t *p_cdio );
at http://www.t10.org/ftp/t10/drafts/mmc/mmc-r10a.pdf See at http://www.t10.org/ftp/t10/drafts/mmc/mmc-r10a.pdf See
especially tables 72, 73 and 75. especially tables 72, 73 and 75.
*/ */
discmode_t scsi_mmc_get_discmode( const CdIo_t *p_cdio ); discmode_t mmc_get_discmode( const CdIo_t *p_cdio );
/*! /*!
Get drive capabilities for a device. Get drive capabilities for a device.
@return the drive capabilities. @return the drive capabilities.
*/ */
void scsi_mmc_get_drive_cap (const CdIo_t *p_cdio, void mmc_get_drive_cap (const CdIo_t *p_cdio,
/*out*/ cdio_drive_read_cap_t *p_read_cap, /*out*/ cdio_drive_read_cap_t *p_read_cap,
/*out*/ cdio_drive_write_cap_t *p_write_cap, /*out*/ cdio_drive_write_cap_t *p_write_cap,
/*out*/ cdio_drive_misc_cap_t *p_misc_cap); /*out*/ cdio_drive_misc_cap_t *p_misc_cap);
@@ -456,7 +458,7 @@ void scsi_mmc_get_drive_cap (const CdIo_t *p_cdio,
@return the DVD discmode. @return the DVD discmode.
*/ */
discmode_t scsi_mmc_get_dvd_struct_physical ( const CdIo_t *p_cdio, discmode_t mmc_get_dvd_struct_physical ( const CdIo_t *p_cdio,
cdio_dvd_struct_t *s); cdio_dvd_struct_t *s);
/*! /*!
@@ -465,10 +467,18 @@ discmode_t scsi_mmc_get_dvd_struct_physical ( const CdIo_t *p_cdio,
@return true if we were able to get hardware info, false if we had @return true if we were able to get hardware info, false if we had
an error. an error.
*/ */
bool scsi_mmc_get_hwinfo ( const CdIo_t *p_cdio, bool mmc_get_hwinfo ( const CdIo_t *p_cdio,
/* out*/ cdio_hwinfo_t *p_hw_info ); /* out*/ cdio_hwinfo_t *p_hw_info );
/*!
Find out if media has changed since the last call.
@param p_cdio the CD object to be acted upon.
@return 1 if media has changed since last call, 0 if not. Error
return codes are the same as driver_return_code_t
*/
int mmc_get_media_changed(const CdIo_t *p_cdio);
/*! /*!
Get the media catalog number (MCN) from the CD via MMC. Get the media catalog number (MCN) from the CD via MMC.
@@ -479,25 +489,25 @@ bool scsi_mmc_get_hwinfo ( const CdIo_t *p_cdio,
string when done with it. string when done with it.
*/ */
char *scsi_mmc_get_mcn ( const CdIo_t *p_cdio ); char * mmc_get_mcn ( const CdIo_t *p_cdio );
/*! Packet driver to read mode2 sectors. /*! Packet driver to read mode2 sectors.
Can read only up to 25 blocks. Can read only up to 25 blocks.
*/ */
int scsi_mmc_read_sectors ( const CdIo_t *p_cdio, void *p_buf, lba_t lba, int mmc_read_sectors ( const CdIo_t *p_cdio, void *p_buf, lba_t lba,
int sector_type, unsigned int i_blocks); int sector_type, unsigned int i_blocks);
/*! /*!
Set the block size for subsequest read requests, via an MMC Set the block size for subsequest read requests, via an MMC
MODE_SELECT 6 command. MODE_SELECT 6 command.
*/ */
int scsi_mmc_set_blocksize ( const CdIo_t *p_cdio, unsigned int i_bsize); int mmc_set_blocksize ( const CdIo_t *p_cdio, unsigned int i_bsize);
/*! /*!
Set the block size for subsequest read requests, via an MMC Set the block size for subsequest read requests, via an MMC
MODE_SENSE 6 command. MODE_SENSE 6 command.
*/ */
int scsi_mmc_get_blocksize ( const CdIo_t *p_cdio ); int mmc_get_blocksize ( const CdIo_t *p_cdio );
/*! /*!
Set the drive speed. Set the drive speed.
@@ -507,8 +517,21 @@ int scsi_mmc_get_blocksize ( const CdIo_t *p_cdio );
@see scsi_mmc_get_speed @see scsi_mmc_get_speed
*/ */
int int mmc_set_speed( const CdIo_t *p_cdio, int i_speed );
scsi_mmc_set_speed( const CdIo_t *p_cdio, int i_speed );
/** For backward compatibility. */
#define scsi_mmc_get_cmd_len mmc_get_cmd_len
#define scsi_mmc_run_cmd mmc_run_cmd
#define scsi_mmc_eject_media mmc_eject_media
#define scsi_mmc_get_disc_last_lsn mmc_get_disc_last_lsn
#define scsi_mmc_get_discmode mmc_get_discmode
#define scsi_mmc_get_drive_cap mmc_get_drive_cap
#define scsi_mmc_get_dvd_struct_physical mmc_get_dvd_struct_physical
#define scsi_mmc_get_hwinfo mmc_get_hwinfo
#define scsi_mmc_get_mcn mmc_get_mcn
#define scsi_mmc_read_sectors mmc_read_sectors
#define scsi_mmc_set_blocksize mmc_set_blocksize
#define scsi_mmc_get_blocksize mmc_get_blocksize
#define scsi_mmc_set_speed mmc_set_speed
#endif /* __SCSI_MMC_H__ */ #endif /* __SCSI_MMC_H__ */

20
lib/driver/FreeBSD/freebsd.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: freebsd.c,v 1.15 2005/02/03 07:35:15 rocky Exp $ $Id: freebsd.c,v 1.16 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -27,7 +27,7 @@
# include "config.h" # include "config.h"
#endif #endif
static const char _rcsid[] = "$Id: freebsd.c,v 1.15 2005/02/03 07:35:15 rocky Exp $"; static const char _rcsid[] = "$Id: freebsd.c,v 1.16 2005/02/06 11:13:37 rocky Exp $";
#include "freebsd.h" #include "freebsd.h"
@@ -92,7 +92,7 @@ _read_audio_sectors_freebsd (void *p_user_data, void *p_buf, lsn_t i_lsn,
{ {
_img_private_t *p_env = p_user_data; _img_private_t *p_env = p_user_data;
if ( p_env->access_mode == _AM_CAM ) { if ( p_env->access_mode == _AM_CAM ) {
return scsi_mmc_read_sectors( p_env->gen.cdio, p_buf, i_lsn, return mmc_read_sectors( p_env->gen.cdio, p_buf, i_lsn,
CDIO_MMC_READ_TYPE_CDDA, i_blocks); CDIO_MMC_READ_TYPE_CDDA, i_blocks);
} else } else
return read_audio_sectors_freebsd_ioctl(p_user_data, p_buf, i_lsn, return read_audio_sectors_freebsd_ioctl(p_user_data, p_buf, i_lsn,
@@ -312,7 +312,7 @@ _get_mcn_freebsd (const void *p_user_data) {
return (p_env->access_mode == _AM_IOCTL) return (p_env->access_mode == _AM_IOCTL)
? get_mcn_freebsd_ioctl(p_env) ? get_mcn_freebsd_ioctl(p_env)
: scsi_mmc_get_mcn(p_env->gen.cdio); : mmc_get_mcn(p_env->gen.cdio);
} }
@@ -343,10 +343,10 @@ get_drive_cap_freebsd (const void *p_user_data,
p_buf Buffer for data, both sending and receiving p_buf Buffer for data, both sending and receiving
*/ */
static driver_return_code_t static driver_return_code_t
run_scsi_cmd_freebsd( void *p_user_data, unsigned int i_timeout_ms, run_mmc_cmd_freebsd( void *p_user_data, unsigned int i_timeout_ms,
unsigned int i_cdb, const scsi_mmc_cdb_t *p_cdb, unsigned int i_cdb, const mmc_cdb_t *p_cdb,
scsi_mmc_direction_t e_direction, mmc_direction_t e_direction,
unsigned int i_buf, /*in/out*/ void *p_buf ) unsigned int i_buf, /*in/out*/ void *p_buf )
{ {
const _img_private_t *p_env = p_user_data; const _img_private_t *p_env = p_user_data;
@@ -606,9 +606,9 @@ cdio_open_am_freebsd (const char *psz_orig_source_name,
.read_mode2_sector = _read_mode2_sector_freebsd, .read_mode2_sector = _read_mode2_sector_freebsd,
.read_mode2_sectors = _read_mode2_sectors_freebsd, .read_mode2_sectors = _read_mode2_sectors_freebsd,
.read_toc = read_toc_freebsd, .read_toc = read_toc_freebsd,
.run_scsi_mmc_cmd = run_scsi_cmd_freebsd, .run_mmc_cmd = run_mmc_cmd_freebsd,
.set_arg = _set_arg_freebsd, .set_arg = _set_arg_freebsd,
.set_blocksize = set_blocksize_mmc, .set_blocksize = set_blocksize_mmc,
.set_speed = set_speed_freebsd, .set_speed = set_speed_freebsd,
}; };

62
lib/driver/FreeBSD/freebsd_cam.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: freebsd_cam.c,v 1.4 2005/01/27 04:00:48 rocky Exp $ $Id: freebsd_cam.c,v 1.5 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -26,7 +26,7 @@
# include "config.h" # include "config.h"
#endif #endif
static const char _rcsid[] = "$Id: freebsd_cam.c,v 1.4 2005/01/27 04:00:48 rocky Exp $"; static const char _rcsid[] = "$Id: freebsd_cam.c,v 1.5 2005/02/06 11:13:37 rocky Exp $";
#ifdef HAVE_FREEBSD_CDROM #ifdef HAVE_FREEBSD_CDROM
@@ -53,10 +53,10 @@ static const char _rcsid[] = "$Id: freebsd_cam.c,v 1.4 2005/01/27 04:00:48 rocky
Return 0 if no error. Return 0 if no error.
*/ */
int int
run_scsi_cmd_freebsd_cam( const void *p_user_data, unsigned int i_timeout_ms, run_mmc_cmd_freebsd_cam( const void *p_user_data, unsigned int i_timeout_ms,
unsigned int i_cdb, const scsi_mmc_cdb_t *p_cdb, unsigned int i_cdb, const scsi_mmc_cdb_t *p_cdb,
scsi_mmc_direction_t e_direction, scsi_mmc_direction_t e_direction,
unsigned int i_buf, /*in/out*/ void *p_buf ) unsigned int i_buf, /*in/out*/ void *p_buf )
{ {
const _img_private_t *p_env = p_user_data; const _img_private_t *p_env = p_user_data;
int i_status; int i_status;
@@ -83,7 +83,7 @@ run_scsi_cmd_freebsd_cam( const void *p_user_data, unsigned int i_timeout_ms,
memcpy(ccb.csio.cdb_io.cdb_bytes, p_cdb, i_cdb); memcpy(ccb.csio.cdb_io.cdb_bytes, p_cdb, i_cdb);
ccb.csio.cdb_len = ccb.csio.cdb_len =
scsi_mmc_get_cmd_len(ccb.csio.cdb_io.cdb_bytes[0]); mmc_get_cmd_len(ccb.csio.cdb_io.cdb_bytes[0]);
if ((i_status = cam_send_ccb(p_env->cam, &ccb)) < 0) if ((i_status = cam_send_ccb(p_env->cam, &ccb)) < 0)
{ {
@@ -191,31 +191,31 @@ read_mode2_sectors_freebsd_cam (_img_private_t *p_env, void *p_buf,
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_10); CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_10);
CDIO_MMC_SET_READ_LENGTH16(cdb.field, nblocks); CDIO_MMC_SET_READ_LENGTH16(cdb.field, nblocks);
if ((retval = scsi_mmc_set_blocksize (p_env->gen.cdio, M2RAW_SECTOR_SIZE))) if ((retval = mmc_set_blocksize (p_env->gen.cdio, M2RAW_SECTOR_SIZE)))
return retval; return retval;
if ((retval = run_scsi_cmd_freebsd_cam (p_env, 0, if ((retval = run_mmc_cmd_freebsd_cam (p_env, 0,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, &cdb,
SCSI_MMC_DATA_READ, SCSI_MMC_DATA_READ,
M2RAW_SECTOR_SIZE * nblocks, M2RAW_SECTOR_SIZE * nblocks,
p_buf))) p_buf)))
{ {
scsi_mmc_set_blocksize (p_env->gen.cdio, CDIO_CD_FRAMESIZE); mmc_set_blocksize (p_env->gen.cdio, CDIO_CD_FRAMESIZE);
return retval; return retval;
} }
return scsi_mmc_set_blocksize (p_env->gen.cdio, CDIO_CD_FRAMESIZE); return mmc_set_blocksize (p_env->gen.cdio, CDIO_CD_FRAMESIZE);
} else { } else {
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_CD); CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_CD);
CDIO_MMC_SET_READ_LENGTH24(cdb.field, nblocks); CDIO_MMC_SET_READ_LENGTH24(cdb.field, nblocks);
cdb.field[1] = 0; /* sector size mode2 */ cdb.field[1] = 0; /* sector size mode2 */
cdb.field[9] = 0x58; /* 2336 mode2 */ cdb.field[9] = 0x58; /* 2336 mode2 */
return run_scsi_cmd_freebsd_cam (p_env, 0, return run_mmc_cmd_freebsd_cam (p_env, 0,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, &cdb,
SCSI_MMC_DATA_READ, SCSI_MMC_DATA_READ,
M2RAW_SECTOR_SIZE * nblocks, p_buf); M2RAW_SECTOR_SIZE * nblocks, p_buf);
} }
} }
@@ -227,29 +227,29 @@ int
eject_media_freebsd_cam (_img_private_t *p_env) eject_media_freebsd_cam (_img_private_t *p_env)
{ {
int i_status; int i_status;
scsi_mmc_cdb_t cdb = {{0, }}; mmc_cdb_t cdb = {{0, }};
uint8_t buf[1]; uint8_t buf[1];
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_ALLOW_MEDIUM_REMOVAL); CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_ALLOW_MEDIUM_REMOVAL);
i_status = run_scsi_cmd_freebsd_cam (p_env, DEFAULT_TIMEOUT_MSECS, i_status = run_mmc_cmd_freebsd_cam (p_env, DEFAULT_TIMEOUT_MSECS,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, SCSI_MMC_DATA_WRITE, 0, &buf); &cdb, SCSI_MMC_DATA_WRITE, 0, &buf);
if (i_status) return i_status; if (i_status) return i_status;
cdb.field[4] = 1; cdb.field[4] = 1;
i_status = run_scsi_cmd_freebsd_cam (p_env, DEFAULT_TIMEOUT_MSECS, i_status = run_mmc_cmd_freebsd_cam (p_env, DEFAULT_TIMEOUT_MSECS,
scsi_mmc_get_cmd_len(cdb.field[0]), &cdb, mmc_get_cmd_len(cdb.field[0]), &cdb,
SCSI_MMC_DATA_WRITE, 0, &buf); SCSI_MMC_DATA_WRITE, 0, &buf);
if (i_status) return i_status; if (i_status) return i_status;
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_START_STOP); CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_START_STOP);
cdb.field[4] = 2; /* eject */ cdb.field[4] = 2; /* eject */
return run_scsi_cmd_freebsd_cam (p_env, DEFAULT_TIMEOUT_MSECS, return run_mmc_cmd_freebsd_cam (p_env, DEFAULT_TIMEOUT_MSECS,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, &cdb,
SCSI_MMC_DATA_WRITE, 0, &buf); SCSI_MMC_DATA_WRITE, 0, &buf);
} }
#endif /* HAVE_FREEBSD_CDROM */ #endif /* HAVE_FREEBSD_CDROM */

32
lib/driver/MSWindows/win32_ioctl.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: win32_ioctl.c,v 1.10 2005/02/05 13:13:31 rocky Exp $ $Id: win32_ioctl.c,v 1.11 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -26,7 +26,7 @@
# include "config.h" # include "config.h"
#endif #endif
static const char _rcsid[] = "$Id: win32_ioctl.c,v 1.10 2005/02/05 13:13:31 rocky Exp $"; static const char _rcsid[] = "$Id: win32_ioctl.c,v 1.11 2005/02/06 11:13:37 rocky Exp $";
#ifdef HAVE_WIN32_CDROM #ifdef HAVE_WIN32_CDROM
@@ -184,11 +184,11 @@ typedef struct _SUB_Q_MEDIA_CATALOG_NUMBER {
Return 0 if command completed successfully. Return 0 if command completed successfully.
*/ */
int int
run_scsi_cmd_win32ioctl( void *p_user_data, run_mmc_cmd_win32ioctl( void *p_user_data,
unsigned int i_timeout_ms, unsigned int i_timeout_ms,
unsigned int i_cdb, const scsi_mmc_cdb_t * p_cdb, unsigned int i_cdb, const scsi_mmc_cdb_t * p_cdb,
scsi_mmc_direction_t e_direction, scsi_mmc_direction_t e_direction,
unsigned int i_buf, /*in/out*/ void *p_buf ) unsigned int i_buf, /*in/out*/ void *p_buf )
{ {
const _img_private_t *p_env = p_user_data; const _img_private_t *p_env = p_user_data;
SCSI_PASS_THROUGH_DIRECT sptd; SCSI_PASS_THROUGH_DIRECT sptd;
@@ -245,7 +245,7 @@ get_discmode_win32ioctl (_img_private_t *p_env)
dvd.physical.type = CDIO_DVD_STRUCT_PHYSICAL; dvd.physical.type = CDIO_DVD_STRUCT_PHYSICAL;
dvd.physical.layer_num = 0; dvd.physical.layer_num = 0;
if (0 == mmc_get_dvd_struct_physical_private (p_env, if (0 == mmc_get_dvd_struct_physical_private (p_env,
&run_scsi_cmd_win32ioctl, &run_mmc_cmd_win32ioctl,
&dvd)) { &dvd)) {
switch(dvd.physical.layer[0].book_type) { switch(dvd.physical.layer[0].book_type) {
case CDIO_DVD_BOOK_DVD_ROM: return CDIO_DISC_MODE_DVD_ROM; case CDIO_DVD_BOOK_DVD_ROM: return CDIO_DISC_MODE_DVD_ROM;
@@ -409,10 +409,10 @@ read_raw_sector (_img_private_t *p_env, void *p_buf, lsn_t lsn)
cdb.field[9]=0xF8; /* Raw read, 2352 bytes per sector */ cdb.field[9]=0xF8; /* Raw read, 2352 bytes per sector */
return run_scsi_cmd_win32ioctl(p_env, OP_TIMEOUT_MS, return run_mmc_cmd_win32ioctl(p_env, OP_TIMEOUT_MS,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, SCSI_MMC_DATA_READ, &cdb, SCSI_MMC_DATA_READ,
CDIO_CD_FRAMESIZE_RAW, p_buf); CDIO_CD_FRAMESIZE_RAW, p_buf);
} }
/*! /*!
@@ -574,10 +574,10 @@ read_fulltoc_win32mmc (_img_private_t *p_env)
/* Setup to read header, to get length of data */ /* Setup to read header, to get length of data */
CDIO_MMC_SET_READ_LENGTH16(cdb.field, sizeof(cdrom_toc_full)); CDIO_MMC_SET_READ_LENGTH16(cdb.field, sizeof(cdrom_toc_full));
i_status = run_scsi_cmd_win32ioctl (p_env, 1000*60*3, i_status = run_mmc_cmd_win32ioctl (p_env, 1000*60*3,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, SCSI_MMC_DATA_READ, &cdb, SCSI_MMC_DATA_READ,
sizeof(cdrom_toc_full), &cdrom_toc_full); sizeof(cdrom_toc_full), &cdrom_toc_full);
if ( 0 != i_status ) { if ( 0 != i_status ) {
cdio_debug ("SCSI MMC READ_TOC failed\n"); cdio_debug ("SCSI MMC READ_TOC failed\n");

24
lib/driver/_cdio_aix.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: _cdio_aix.c,v 1.9 2005/02/03 07:35:14 rocky Exp $ $Id: _cdio_aix.c,v 1.10 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -37,7 +37,7 @@
#ifdef HAVE_AIX_CDROM #ifdef HAVE_AIX_CDROM
static const char _rcsid[] = "$Id: _cdio_aix.c,v 1.9 2005/02/03 07:35:14 rocky Exp $"; static const char _rcsid[] = "$Id: _cdio_aix.c,v 1.10 2005/02/06 11:13:37 rocky Exp $";
#ifdef HAVE_GLOB_H #ifdef HAVE_GLOB_H
#include <glob.h> #include <glob.h>
@@ -195,17 +195,17 @@ init_aix (_img_private_t *p_env)
p_buf Buffer for data, both sending and receiving p_buf Buffer for data, both sending and receiving
*/ */
static driver_return_code_t static driver_return_code_t
run_scsi_cmd_aix( void *p_user_data, unsigned int i_timeout_ms, run_mmc_cmd_aix( void *p_user_data, unsigned int i_timeout_ms,
unsigned int i_cdb, const scsi_mmc_cdb_t *p_cdb, unsigned int i_cdb, const mmc_cdb_t *p_cdb,
scsi_mmc_direction_t e_direction, mmc_direction_t e_direction,
unsigned int i_buf, /*in/out*/ void *p_buf ) unsigned int i_buf, /*in/out*/ void *p_buf )
{ {
const _img_private_t *p_env = p_user_data; const _img_private_t *p_env = p_user_data;
struct sc_passthru cgc; struct sc_passthru cgc;
int i_rc; int i_rc;
memset (&cgc, 0, sizeof (cgc)); memset (&cgc, 0, sizeof (cgc));
memcpy(cgc.scsi_cdb, p_cdb, sizeof(scsi_mmc_cdb_t)); memcpy(cgc.scsi_cdb, p_cdb, sizeof(mmc_cdb_t));
#ifdef AIX_DISABLE_ASYNC #ifdef AIX_DISABLE_ASYNC
/* This enables synchronous negotiation mode. Some CD-ROM drives /* This enables synchronous negotiation mode. Some CD-ROM drives
@@ -217,7 +217,7 @@ run_scsi_cmd_aix( void *p_user_data, unsigned int i_timeout_ms,
#endif #endif
if (0 != i_buf) if (0 != i_buf)
cgc.flags |= SCSI_MMC_DATA_READ == e_direction ? B_READ : B_WRITE; cgc.flags |= MMC_DATA_READ == e_direction ? B_READ : B_WRITE;
cgc.timeout_value = msecs2secs(i_timeout_ms); cgc.timeout_value = msecs2secs(i_timeout_ms);
cgc.buffer = p_buf; cgc.buffer = p_buf;
@@ -554,7 +554,7 @@ static bool
read_toc_aix (void *p_user_data) read_toc_aix (void *p_user_data)
{ {
_img_private_t *p_env = p_user_data; _img_private_t *p_env = p_user_data;
scsi_mmc_cdb_t cdb = {{0, }}; mmc_cdb_t cdb = {{0, }};
CDROM_TOC_FULL cdrom_toc_full; CDROM_TOC_FULL cdrom_toc_full;
int i_status, i, i_seen_flag; int i_status, i, i_seen_flag;
int i_track_format = 0; int i_track_format = 0;
@@ -573,8 +573,8 @@ read_toc_aix (void *p_user_data)
CDIO_MMC_SET_READ_LENGTH16(cdb.field, sizeof(cdrom_toc_full)); CDIO_MMC_SET_READ_LENGTH16(cdb.field, sizeof(cdrom_toc_full));
i_status = run_scsi_cmd_aix (p_env, 1000*60*3, i_status = run_scsi_cmd_aix (p_env, 1000*60*3,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, SCSI_MMC_DATA_READ, &cdb, MMC_DATA_READ,
sizeof(cdrom_toc_full), &cdrom_toc_full); sizeof(cdrom_toc_full), &cdrom_toc_full);
if ( 0 != i_status ) { if ( 0 != i_status ) {
@@ -960,7 +960,7 @@ cdio_open_am_aix (const char *psz_orig_source, const char *access_mode)
_funcs.read_mode2_sector = _read_mode2_sector_aix; _funcs.read_mode2_sector = _read_mode2_sector_aix;
_funcs.read_mode2_sectors = _read_mode2_sectors_aix; _funcs.read_mode2_sectors = _read_mode2_sectors_aix;
_funcs.read_toc = read_toc_aix; _funcs.read_toc = read_toc_aix;
_funcs.run_scsi_mmc_cmd = run_scsi_cmd_aix; _funcs.run_mmc_cmd = run_mmc_cmd_aix;
_funcs.set_arg = _set_arg_aix; _funcs.set_arg = _set_arg_aix;
_data = calloc (1, sizeof (_img_private_t)); _data = calloc (1, sizeof (_img_private_t));

18
lib/driver/_cdio_bsdi.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: _cdio_bsdi.c,v 1.11 2005/02/03 07:35:15 rocky Exp $ $Id: _cdio_bsdi.c,v 1.12 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2001 Herbert Valerio Riedel <hvr@gnu.org> Copyright (C) 2001 Herbert Valerio Riedel <hvr@gnu.org>
Copyright (C) 2002, 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2002, 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -27,7 +27,7 @@
# include "config.h" # include "config.h"
#endif #endif
static const char _rcsid[] = "$Id: _cdio_bsdi.c,v 1.11 2005/02/03 07:35:15 rocky Exp $"; static const char _rcsid[] = "$Id: _cdio_bsdi.c,v 1.12 2005/02/06 11:13:37 rocky Exp $";
#include <cdio/logging.h> #include <cdio/logging.h>
#include <cdio/sector.h> #include <cdio/sector.h>
@@ -81,7 +81,7 @@ typedef struct {
/* Define the Cdrom Generic Command structure */ /* Define the Cdrom Generic Command structure */
typedef struct cgc typedef struct cgc
{ {
scsi_mmc_cdb_t cdb; mmc_cdb_t cdb;
u_char *buf; u_char *buf;
int buflen; int buflen;
int rw; int rw;
@@ -94,10 +94,10 @@ typedef struct cgc
This code adapted from Steven M. Schultz's libdvd This code adapted from Steven M. Schultz's libdvd
*/ */
static driver_return_code_t static driver_return_code_t
run_scsi_cmd_bsdi(void *p_user_data, unsigned int i_timeout_ms, run_mmc_cmd_bsdi(void *p_user_data, unsigned int i_timeout_ms,
unsigned int i_cdb, const scsi_mmc_cdb_t *p_cdb, unsigned int i_cdb, const mmc_cdb_t *p_cdb,
scsi_mmc_direction_t e_direction, mmc_direction_t e_direction,
unsigned int i_buf, /*in/out*/ void *p_buf ) unsigned int i_buf, /*in/out*/ void *p_buf )
{ {
const _img_private_t *p_env = p_user_data; const _img_private_t *p_env = p_user_data;
int i_status, i_asc; int i_status, i_asc;
@@ -105,7 +105,7 @@ run_scsi_cmd_bsdi(void *p_user_data, unsigned int i_timeout_ms,
struct scsi_sense *sp; struct scsi_sense *sp;
again: again:
suc.suc_flags = SCSI_MMC_DATA_READ == e_direction ? suc.suc_flags = MMC_DATA_READ == e_direction ?
SUC_READ : SUC_WRITE; SUC_READ : SUC_WRITE;
suc.suc_cdblen = i_cdb; suc.suc_cdblen = i_cdb;
memcpy(suc.suc_cdb, p_cdb, i_cdb); memcpy(suc.suc_cdb, p_cdb, i_cdb);
@@ -784,7 +784,7 @@ cdio_open_bsdi (const char *psz_orig_source)
.read_mode2_sector = _read_mode2_sector_bsdi, .read_mode2_sector = _read_mode2_sector_bsdi,
.read_mode2_sectors = _read_mode2_sectors_bsdi, .read_mode2_sectors = _read_mode2_sectors_bsdi,
.read_toc = &read_toc_bsdi, .read_toc = &read_toc_bsdi,
.run_scsi_mmc_cmd = &run_scsi_cmd_bsdi, .run_mmc_cmd = &run_mmc_cmd_bsdi,
.set_arg = _set_arg_bsdi, .set_arg = _set_arg_bsdi,
}; };

8
lib/driver/_cdio_generic.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: _cdio_generic.c,v 1.14 2005/02/05 13:07:02 rocky Exp $ $Id: _cdio_generic.c,v 1.15 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -25,7 +25,7 @@
# include "config.h" # include "config.h"
#endif #endif
static const char _rcsid[] = "$Id: _cdio_generic.c,v 1.14 2005/02/05 13:07:02 rocky Exp $"; static const char _rcsid[] = "$Id: _cdio_generic.c,v 1.15 2005/02/06 11:13:37 rocky Exp $";
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@@ -290,7 +290,7 @@ get_discmode_generic (void *p_user_data )
dvd.physical.type = CDIO_DVD_STRUCT_PHYSICAL; dvd.physical.type = CDIO_DVD_STRUCT_PHYSICAL;
dvd.physical.layer_num = 0; dvd.physical.layer_num = 0;
if (0 == scsi_mmc_get_dvd_struct_physical (p_env->cdio, &dvd)) { if (0 == mmc_get_dvd_struct_physical (p_env->cdio, &dvd)) {
switch(dvd.physical.layer[0].book_type) { switch(dvd.physical.layer[0].book_type) {
case CDIO_DVD_BOOK_DVD_ROM: return CDIO_DISC_MODE_DVD_ROM; 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_RAM: return CDIO_DISC_MODE_DVD_RAM;
@@ -436,7 +436,7 @@ bool
init_cdtext_generic (generic_img_private_t *p_env) init_cdtext_generic (generic_img_private_t *p_env)
{ {
return mmc_init_cdtext_private( p_env, return mmc_init_cdtext_private( p_env,
p_env->cdio->op.run_scsi_mmc_cmd, p_env->cdio->op.run_mmc_cmd,
set_cdtext_field_generic set_cdtext_field_generic
); );
} }

69
lib/driver/_cdio_linux.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: _cdio_linux.c,v 1.20 2005/02/03 07:35:15 rocky Exp $ $Id: _cdio_linux.c,v 1.21 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2001 Herbert Valerio Riedel <hvr@gnu.org> Copyright (C) 2001 Herbert Valerio Riedel <hvr@gnu.org>
Copyright (C) 2002, 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2002, 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -27,7 +27,7 @@
# include "config.h" # include "config.h"
#endif #endif
static const char _rcsid[] = "$Id: _cdio_linux.c,v 1.20 2005/02/03 07:35:15 rocky Exp $"; static const char _rcsid[] = "$Id: _cdio_linux.c,v 1.21 2005/02/06 11:13:37 rocky Exp $";
#include <string.h> #include <string.h>
@@ -99,13 +99,13 @@ typedef struct {
/**** prototypes for static functions ****/ /**** prototypes for static functions ****/
static bool is_cdrom_linux(const char *drive, char *mnttype); static bool is_cdrom_linux(const char *drive, char *mnttype);
static bool read_toc_linux (void *p_user_data); static bool read_toc_linux (void *p_user_data);
static driver_return_code_t run_scsi_cmd_linux( void *p_user_data, static driver_return_code_t run_mmc_cmd_linux( void *p_user_data,
unsigned int i_timeout, unsigned int i_timeout,
unsigned int i_cdb, unsigned int i_cdb,
const scsi_mmc_cdb_t *p_cdb, const scsi_mmc_cdb_t *p_cdb,
scsi_mmc_direction_t e_direction, scsi_mmc_direction_t e_direction,
unsigned int i_buf, unsigned int i_buf,
/*in/out*/ void *p_buf ); /*in/out*/ void *p_buf );
static access_mode_t static access_mode_t
str_to_access_mode_linux(const char *psz_access_mode) str_to_access_mode_linux(const char *psz_access_mode)
@@ -287,6 +287,18 @@ get_drive_cap_linux (const void *p_user_data,
} }
#endif #endif
/*!
Find out if media has changed since the last call.
@param p_user_data the environment object to be acted upon.
@return 1 if media has changed since last call, 0 if not. Error
return codes are the same as driver_return_code_t
*/
static int
get_media_changed_linux (void *p_user_data) {
const _img_private_t *p_env = p_user_data;
return ioctl(p_env->gen.fd, CDROM_MEDIA_CHANGED, 0);
}
/*! /*!
Return the media catalog number MCN. Return the media catalog number MCN.
@@ -423,7 +435,7 @@ eject_media_linux (void *p_user_data) {
if((ret = ioctl(fd, CDROMEJECT)) != 0) { if((ret = ioctl(fd, CDROMEJECT)) != 0) {
int eject_error = errno; int eject_error = errno;
/* Try ejecting the MMC way... */ /* Try ejecting the MMC way... */
ret = scsi_mmc_eject_media(p_env->gen.cdio); ret = mmc_eject_media(p_env->gen.cdio);
if (0 != ret) { if (0 != ret) {
cdio_warn("ioctl CDROMEJECT failed: %s\n", cdio_warn("ioctl CDROMEJECT failed: %s\n",
strerror(eject_error)); strerror(eject_error));
@@ -483,7 +495,7 @@ get_discmode_linux (void *p_user_data)
issue a SCSI MMC-2 FULL TOC command first to try get more issue a SCSI MMC-2 FULL TOC command first to try get more
accurate information. accurate information.
*/ */
discmode = scsi_mmc_get_discmode(p_env->gen.cdio); discmode = mmc_get_discmode(p_env->gen.cdio);
if (CDIO_DISC_MODE_NO_INFO != discmode) if (CDIO_DISC_MODE_NO_INFO != discmode)
return discmode; return discmode;
else { else {
@@ -551,8 +563,8 @@ _read_audio_sectors_linux (void *p_user_data, void *buf, lsn_t lsn,
unsigned int nblocks) unsigned int nblocks)
{ {
_img_private_t *p_env = p_user_data; _img_private_t *p_env = p_user_data;
return scsi_mmc_read_sectors( p_env->gen.cdio, buf, lsn, return mmc_read_sectors( p_env->gen.cdio, buf, lsn, CDIO_MMC_READ_TYPE_CDDA,
CDIO_MMC_READ_TYPE_CDDA, nblocks); nblocks);
} }
/* Packet driver to read mode2 sectors. /* Packet driver to read mode2 sectors.
@@ -572,22 +584,22 @@ _read_mode2_sectors_mmc (_img_private_t *p_env, void *p_buf, lba_t lba,
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_10); CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_10);
CDIO_MMC_SET_READ_LENGTH16(cdb.field, nblocks); CDIO_MMC_SET_READ_LENGTH16(cdb.field, nblocks);
if ((retval = scsi_mmc_set_blocksize (p_env->gen.cdio, M2RAW_SECTOR_SIZE))) if ((retval = mmc_set_blocksize (p_env->gen.cdio, M2RAW_SECTOR_SIZE)))
return retval; return retval;
if ((retval = run_scsi_cmd_linux (p_env, 0, if ((retval = run_mmc_cmd_linux (p_env, 0,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, &cdb,
SCSI_MMC_DATA_READ, SCSI_MMC_DATA_READ,
M2RAW_SECTOR_SIZE * nblocks, M2RAW_SECTOR_SIZE * nblocks,
p_buf))) p_buf)))
{ {
scsi_mmc_set_blocksize (p_env->gen.cdio, CDIO_CD_FRAMESIZE); mmc_set_blocksize (p_env->gen.cdio, CDIO_CD_FRAMESIZE);
return retval; return retval;
} }
/* Restore blocksize. */ /* Restore blocksize. */
retval = scsi_mmc_set_blocksize (p_env->gen.cdio, CDIO_CD_FRAMESIZE); retval = mmc_set_blocksize (p_env->gen.cdio, CDIO_CD_FRAMESIZE);
return retval; return retval;
} else { } else {
@@ -597,10 +609,10 @@ _read_mode2_sectors_mmc (_img_private_t *p_env, void *p_buf, lba_t lba,
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_CD); CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_CD);
CDIO_MMC_SET_READ_LENGTH24(cdb.field, nblocks); CDIO_MMC_SET_READ_LENGTH24(cdb.field, nblocks);
return run_scsi_cmd_linux (p_env, 0, return run_mmc_cmd_linux (p_env, 0,
scsi_mmc_get_cmd_len(cdb.field[0]), &cdb, mmc_get_cmd_len(cdb.field[0]), &cdb,
SCSI_MMC_DATA_READ, SCSI_MMC_DATA_READ,
M2RAW_SECTOR_SIZE * nblocks, p_buf); M2RAW_SECTOR_SIZE * nblocks, p_buf);
} }
} }
@@ -897,7 +909,7 @@ read_toc_linux (void *p_user_data)
We return true if command completed successfully and false if not. We return true if command completed successfully and false if not.
*/ */
static driver_return_code_t static driver_return_code_t
run_scsi_cmd_linux( void *p_user_data, run_mmc_cmd_linux( void *p_user_data,
unsigned int i_timeout_ms, unsigned int i_timeout_ms,
unsigned int i_cdb, const scsi_mmc_cdb_t *p_cdb, unsigned int i_cdb, const scsi_mmc_cdb_t *p_cdb,
scsi_mmc_direction_t e_direction, scsi_mmc_direction_t e_direction,
@@ -1148,6 +1160,7 @@ cdio_open_am_linux (const char *psz_orig_source, const char *access_mode)
#endif #endif
.get_first_track_num = get_first_track_num_generic, .get_first_track_num = get_first_track_num_generic,
.get_hwinfo = NULL, .get_hwinfo = NULL,
.get_media_changed = get_media_changed_linux,
.get_mcn = get_mcn_linux, .get_mcn = get_mcn_linux,
.get_num_tracks = get_num_tracks_generic, .get_num_tracks = get_num_tracks_generic,
.get_track_channels = get_track_channels_generic, .get_track_channels = get_track_channels_generic,
@@ -1165,7 +1178,7 @@ cdio_open_am_linux (const char *psz_orig_source, const char *access_mode)
.read_mode2_sector = _read_mode2_sector_linux, .read_mode2_sector = _read_mode2_sector_linux,
.read_mode2_sectors = _read_mode2_sectors_linux, .read_mode2_sectors = _read_mode2_sectors_linux,
.read_toc = read_toc_linux, .read_toc = read_toc_linux,
.run_scsi_mmc_cmd = run_scsi_cmd_linux, .run_mmc_cmd = run_mmc_cmd_linux,
.set_arg = set_arg_linux, .set_arg = set_arg_linux,
.set_blocksize = set_blocksize_mmc, .set_blocksize = set_blocksize_mmc,
.set_speed = set_speed_linux, .set_speed = set_speed_linux,

20
lib/driver/_cdio_osx.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: _cdio_osx.c,v 1.14 2005/02/03 07:35:15 rocky Exp $ $Id: _cdio_osx.c,v 1.15 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com>
from vcdimager code: from vcdimager code:
@@ -34,7 +34,7 @@
#include "config.h" #include "config.h"
#endif #endif
static const char _rcsid[] = "$Id: _cdio_osx.c,v 1.14 2005/02/03 07:35:15 rocky Exp $"; static const char _rcsid[] = "$Id: _cdio_osx.c,v 1.15 2005/02/06 11:13:37 rocky Exp $";
#include <cdio/logging.h> #include <cdio/logging.h>
#include <cdio/sector.h> #include <cdio/sector.h>
@@ -355,8 +355,8 @@ init_osx(_img_private_t *p_env) {
static int static int
run_scsi_cmd_osx( void *p_user_data, run_scsi_cmd_osx( void *p_user_data,
unsigned int i_timeout_ms, unsigned int i_timeout_ms,
unsigned int i_cdb, const scsi_mmc_cdb_t *p_cdb, unsigned int i_cdb, const mmc_cdb_t *p_cdb,
scsi_mmc_direction_t e_direction, mmc_direction_t e_direction,
unsigned int i_buf, /*in/out*/ void *p_buf ) unsigned int i_buf, /*in/out*/ void *p_buf )
{ {
_img_private_t *p_env = p_user_data; _img_private_t *p_env = p_user_data;
@@ -486,11 +486,11 @@ run_scsi_cmd_osx( void *p_user_data,
We return true if command completed successfully and false if not. We return true if command completed successfully and false if not.
*/ */
static int static int
run_scsi_cmd_osx( const void *p_user_data, run_mmc_cmd_osx( const void *p_user_data,
unsigned int i_timeout_ms, unsigned int i_timeout_ms,
unsigned int i_cdb, const scsi_mmc_cdb_t *p_cdb, unsigned int i_cdb, const scsi_mmc_cdb_t *p_cdb,
scsi_mmc_direction_t e_direction, scsi_mmc_direction_t e_direction,
unsigned int i_buf, /*in/out*/ void *p_buf ) unsigned int i_buf, /*in/out*/ void *p_buf )
{ {
#ifndef SCSI_MMC_FIXED #ifndef SCSI_MMC_FIXED
@@ -1689,7 +1689,7 @@ cdio_open_osx (const char *psz_orig_source)
.read_mode2_sector = _get_read_mode2_sector_osx, .read_mode2_sector = _get_read_mode2_sector_osx,
.read_mode2_sectors = _get_read_mode2_sectors_osx, .read_mode2_sectors = _get_read_mode2_sectors_osx,
.read_toc = read_toc_osx, .read_toc = read_toc_osx,
.run_scsi_mmc_cmd = run_scsi_cmd_osx, .run_mmc_cmd = run_mmc_cmd_osx,
.set_arg = _set_arg_osx, .set_arg = _set_arg_osx,
.set_speed = set_speed_osx, .set_speed = set_speed_osx,
}; };

14
lib/driver/_cdio_sunos.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: _cdio_sunos.c,v 1.18 2005/02/03 07:35:15 rocky Exp $ $Id: _cdio_sunos.c,v 1.19 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2001 Herbert Valerio Riedel <hvr@gnu.org> Copyright (C) 2001 Herbert Valerio Riedel <hvr@gnu.org>
Copyright (C) 2002, 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2002, 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -38,7 +38,7 @@
#ifdef HAVE_SOLARIS_CDROM #ifdef HAVE_SOLARIS_CDROM
static const char _rcsid[] = "$Id: _cdio_sunos.c,v 1.18 2005/02/03 07:35:15 rocky Exp $"; static const char _rcsid[] = "$Id: _cdio_sunos.c,v 1.19 2005/02/06 11:13:37 rocky Exp $";
#ifdef HAVE_GLOB_H #ifdef HAVE_GLOB_H
#include <glob.h> #include <glob.h>
@@ -146,8 +146,8 @@ init_solaris (_img_private_t *p_env)
*/ */
static driver_return_code_t static driver_return_code_t
run_scsi_cmd_solaris( void *p_user_data, unsigned int i_timeout_ms, run_scsi_cmd_solaris( void *p_user_data, unsigned int i_timeout_ms,
unsigned int i_cdb, const scsi_mmc_cdb_t *p_cdb, unsigned int i_cdb, const mmc_cdb_t *p_cdb,
scsi_mmc_direction_t e_direction, mmc_direction_t e_direction,
unsigned int i_buf, /*in/out*/ void *p_buf ) unsigned int i_buf, /*in/out*/ void *p_buf )
{ {
const _img_private_t *p_env = p_user_data; const _img_private_t *p_env = p_user_data;
@@ -575,7 +575,7 @@ get_discmode_solaris (void *p_user_data)
Issue a SCSI MMC-2 FULL TOC command first to try get more Issue a SCSI MMC-2 FULL TOC command first to try get more
accurate information. accurate information.
*/ */
discmode = scsi_mmc_get_discmode(p_env->gen.cdio); discmode = mmc_get_discmode(p_env->gen.cdio);
if (CDIO_DISC_MODE_NO_INFO != discmode) if (CDIO_DISC_MODE_NO_INFO != discmode)
return discmode; return discmode;
@@ -872,12 +872,12 @@ cdio_open_am_solaris (const char *psz_orig_source, const char *access_mode)
_funcs.read_mode2_sector = _read_mode2_sector_solaris; _funcs.read_mode2_sector = _read_mode2_sector_solaris;
_funcs.read_mode2_sectors = _read_mode2_sectors_solaris; _funcs.read_mode2_sectors = _read_mode2_sectors_solaris;
_funcs.read_toc = read_toc_solaris; _funcs.read_toc = read_toc_solaris;
_funcs.run_scsi_mmc_cmd = run_scsi_cmd_solaris; _funcs.run_mmc_cmd = run_mmc_cmd_solaris;
_funcs.set_arg = _set_arg_solaris; _funcs.set_arg = _set_arg_solaris;
_funcs.set_blocksize = set_blocksize_mmc; _funcs.set_blocksize = set_blocksize_mmc;
_funcs.set_speed = set_speed_solaris; _funcs.set_speed = set_speed_solaris;
_data = calloc(1, sizeof (_img_private_t)); _data = calloc(1, sizeof (_img_private_t));
_data->access_mode = _AM_SUN_CTRL_SCSI; _data->access_mode = _AM_SUN_CTRL_SCSI;
_data->gen.init = false; _data->gen.init = false;

35
lib/driver/cdio_private.h
View File

@@ -1,5 +1,5 @@
/* /*
$Id: cdio_private.h,v 1.12 2005/02/05 13:07:02 rocky Exp $ $Id: cdio_private.h,v 1.13 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -56,6 +56,9 @@ extern "C" {
/*! /*!
Eject media in CD drive. If successful, as a side effect we Eject media in CD drive. If successful, as a side effect we
also free obj. Return 0 if success and 1 for failure. also free obj. Return 0 if success and 1 for failure.
@param p_cdio the CD object to be acted upon.
If the CD is ejected *p_cdio is freed and p_cdio set to NULL.
*/ */
int (*eject_media) (void *p_env); int (*eject_media) (void *p_env);
@@ -97,7 +100,14 @@ extern "C" {
char ** (*get_devices) (void); char ** (*get_devices) (void);
/*! /*!
Return a string containing the default CD device if none is specified. Get the default CD device.
@return a string containing the default CD device or NULL is
if we couldn't get a default device.
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 * (*get_default_device)(void); char * (*get_default_device)(void);
@@ -134,6 +144,14 @@ extern "C" {
bool (*get_hwinfo) ( const CdIo_t *p_cdio, bool (*get_hwinfo) ( const CdIo_t *p_cdio,
/* out*/ cdio_hwinfo_t *p_hw_info ); /* out*/ cdio_hwinfo_t *p_hw_info );
/*!
Find out if media has changed since the last call.
@param p_env the CD object to be acted upon.
@return 1 if media has changed since last call, 0 if not. Error
return codes are the same as driver_return_code_t
*/
int (*get_media_changed) (void *p_env);
/*! /*!
Return the media catalog number MCN from the CD or NULL if Return the media catalog number MCN from the CD or NULL if
there is none or we don't have the ability to get it. there is none or we don't have the ability to get it.
@@ -172,12 +190,6 @@ extern "C" {
*/ */
track_format_t (*get_track_format) (void *p_env, track_t i_track); track_format_t (*get_track_format) (void *p_env, track_t i_track);
/*!
Set the drive speed. -1 is returned if we had an error.
-2 is returned if this is not implemented for the current driver.
*/
int (*get_speed) (void *p_env);
/*! /*!
Return true if we have XA data (green, mode2 form1) or Return true if we have XA data (green, mode2 form1) or
XA data (green, mode2 form2). That is track begins: XA data (green, mode2 form2). That is track begins:
@@ -273,7 +285,7 @@ extern "C" {
Returns 0 if command completed successfully. Returns 0 if command completed successfully.
*/ */
scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd; mmc_run_cmd_fn_t run_mmc_cmd;
/*! /*!
Set the arg "key" with "value" in the source device. Set the arg "key" with "value" in the source device.
@@ -282,11 +294,8 @@ extern "C" {
/*! /*!
Set the blocksize for subsequent reads. Set the blocksize for subsequent reads.
@return 0 if everything went okay, -1 if we had an error. is -2
returned if this is not implemented for the current driver.
*/ */
int (*set_blocksize) ( void *p_env, int i_blocksize ); driver_return_code_t (*set_blocksize) ( void *p_env, int i_blocksize );
/*! /*!
Set the drive speed. Set the drive speed.

24
lib/driver/device.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: device.c,v 1.8 2005/01/26 01:03:16 rocky Exp $ $Id: device.c,v 1.9 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2005 Rocky Bernstein <rocky@panix.com>
@@ -290,7 +290,7 @@ driver_return_code_t
cdio_eject_media (CdIo_t **pp_cdio) cdio_eject_media (CdIo_t **pp_cdio)
{ {
if ((pp_cdio == NULL) || (*pp_cdio == NULL)) return 1; if ((pp_cdio == NULL) || (*pp_cdio == NULL)) return DRIVER_OP_UNINIT;
if ((*pp_cdio)->op.eject_media) { if ((*pp_cdio)->op.eject_media) {
int ret = (*pp_cdio)->op.eject_media ((*pp_cdio)->env); int ret = (*pp_cdio)->op.eject_media ((*pp_cdio)->env);
@@ -564,10 +564,25 @@ cdio_get_hwinfo (const CdIo_t *p_cdio, cdio_hwinfo_t *hw_info)
} else { } else {
/* Perhaps driver forgot to initialize. We are no worse off Using /* Perhaps driver forgot to initialize. We are no worse off Using
scsi_mmc than returning false here. */ scsi_mmc than returning false here. */
return scsi_mmc_get_hwinfo(p_cdio, hw_info); return mmc_get_hwinfo(p_cdio, hw_info);
} }
} }
/*!
Find out if media has changed since the last call.
@param p_cdio the CD object to be acted upon.
@return 1 if media has changed since last call, 0 if not. Error
return codes are the same as driver_return_code_t
*/
int
cdio_get_media_changed(CdIo_t *p_cdio)
{
if (!p_cdio) return DRIVER_OP_UNINIT;
if (p_cdio->op.get_media_changed)
return p_cdio->op.get_media_changed(p_cdio->env);
return DRIVER_OP_UNSUPPORTED;
}
bool bool
cdio_have_driver(driver_id_t driver_id) cdio_have_driver(driver_id_t driver_id)
{ {
@@ -581,6 +596,7 @@ cdio_is_device(const char *psz_source, driver_id_t driver_id)
return (*CdIo_all_drivers[driver_id].is_device)(psz_source); return (*CdIo_all_drivers[driver_id].is_device)(psz_source);
} }
/*! Sets up to read from place specified by source_name and /*! Sets up to read from place specified by source_name and
driver_id. This should be called before using any other routine, driver_id. This should be called before using any other routine,
except cdio_init. This will call cdio_init, if that hasn't been except cdio_init. This will call cdio_init, if that hasn't been
@@ -707,7 +723,7 @@ cdio_set_blocksize ( const CdIo_t *p_cdio, int i_blocksize )
/*! /*!
Set the drive speed. Set the drive speed.
@see cdio_get_speed @see cdio_set_speed
*/ */
driver_return_code_t driver_return_code_t
cdio_set_speed (const CdIo_t *p_cdio, int i_speed) cdio_set_speed (const CdIo_t *p_cdio, int i_speed)

5
lib/driver/image/bincue.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: bincue.c,v 1.11 2005/02/03 07:35:16 rocky Exp $ $Id: bincue.c,v 1.12 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2002, 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2002, 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com>
Copyright (C) 2001 Herbert Valerio Riedel <hvr@gnu.org> Copyright (C) 2001 Herbert Valerio Riedel <hvr@gnu.org>
@@ -26,7 +26,7 @@
(*.cue). (*.cue).
*/ */
static const char _rcsid[] = "$Id: bincue.c,v 1.11 2005/02/03 07:35:16 rocky Exp $"; static const char _rcsid[] = "$Id: bincue.c,v 1.12 2005/02/06 11:13:37 rocky Exp $";
#include "image.h" #include "image.h"
#include "cdio_assert.h" #include "cdio_assert.h"
@@ -1146,6 +1146,7 @@ cdio_open_cue (const char *psz_cue_name)
_funcs.get_drive_cap = _get_drive_cap_image; _funcs.get_drive_cap = _get_drive_cap_image;
_funcs.get_first_track_num = _get_first_track_num_image; _funcs.get_first_track_num = _get_first_track_num_image;
_funcs.get_hwinfo = get_hwinfo_bincue; _funcs.get_hwinfo = get_hwinfo_bincue;
_funcs.get_media_changed = get_media_changed_image;
_funcs.get_mcn = _get_mcn_image; _funcs.get_mcn = _get_mcn_image;
_funcs.get_num_tracks = _get_num_tracks_image; _funcs.get_num_tracks = _get_num_tracks_image;
_funcs.get_track_channels = get_track_channels_image, _funcs.get_track_channels = get_track_channels_image,

5
lib/driver/image/cdrdao.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: cdrdao.c,v 1.12 2005/02/03 07:35:16 rocky Exp $ $Id: cdrdao.c,v 1.13 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com>
toc reading routine adapted from cuetools toc reading routine adapted from cuetools
@@ -25,7 +25,7 @@
(*.cue). (*.cue).
*/ */
static const char _rcsid[] = "$Id: cdrdao.c,v 1.12 2005/02/03 07:35:16 rocky Exp $"; static const char _rcsid[] = "$Id: cdrdao.c,v 1.13 2005/02/06 11:13:37 rocky Exp $";
#include "image.h" #include "image.h"
#include "cdio_assert.h" #include "cdio_assert.h"
@@ -1273,6 +1273,7 @@ cdio_open_cdrdao (const char *psz_cue_name)
_funcs.get_drive_cap = _get_drive_cap_image; _funcs.get_drive_cap = _get_drive_cap_image;
_funcs.get_first_track_num = _get_first_track_num_image; _funcs.get_first_track_num = _get_first_track_num_image;
_funcs.get_hwinfo = get_hwinfo_cdrdao; _funcs.get_hwinfo = get_hwinfo_cdrdao;
_funcs.get_media_changed = get_media_changed_image;
_funcs.get_mcn = _get_mcn_image; _funcs.get_mcn = _get_mcn_image;
_funcs.get_num_tracks = _get_num_tracks_image; _funcs.get_num_tracks = _get_num_tracks_image;
_funcs.get_track_channels = get_track_channels_image, _funcs.get_track_channels = get_track_channels_image,

5
lib/driver/image/nrg.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: nrg.c,v 1.10 2005/02/03 07:35:16 rocky Exp $ $Id: nrg.c,v 1.11 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2003, 2004, 2005 Rocky Bernstein <rocky@panix.com>
Copyright (C) 2001, 2003 Herbert Valerio Riedel <hvr@gnu.org> Copyright (C) 2001, 2003 Herbert Valerio Riedel <hvr@gnu.org>
@@ -46,7 +46,7 @@
#include "_cdio_stdio.h" #include "_cdio_stdio.h"
#include "nrg.h" #include "nrg.h"
static const char _rcsid[] = "$Id: nrg.c,v 1.10 2005/02/03 07:35:16 rocky Exp $"; static const char _rcsid[] = "$Id: nrg.c,v 1.11 2005/02/06 11:13:37 rocky Exp $";
/* reader */ /* reader */
@@ -1226,6 +1226,7 @@ cdio_open_nrg (const char *psz_source)
_funcs.get_drive_cap = _get_drive_cap_image; _funcs.get_drive_cap = _get_drive_cap_image;
_funcs.get_first_track_num = _get_first_track_num_image; _funcs.get_first_track_num = _get_first_track_num_image;
_funcs.get_hwinfo = get_hwinfo_nrg; _funcs.get_hwinfo = get_hwinfo_nrg;
_funcs.get_media_changed = get_media_changed_image;
_funcs.get_mcn = _get_mcn_image; _funcs.get_mcn = _get_mcn_image;
_funcs.get_num_tracks = _get_num_tracks_image; _funcs.get_num_tracks = _get_num_tracks_image;
_funcs.get_track_channels = get_track_channels_generic, _funcs.get_track_channels = get_track_channels_generic,

17
lib/driver/image_common.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: image_common.c,v 1.7 2005/01/23 05:31:03 rocky Exp $ $Id: image_common.c,v 1.8 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -41,7 +41,7 @@
/*! /*!
Eject media -- there's nothing to do here except free resources. Eject media -- there's nothing to do here except free resources.
We always return -2. We always return DRIVER_OP_UNSUPPORTED.
*/ */
driver_return_code_t driver_return_code_t
_eject_media_image(void *p_user_data) _eject_media_image(void *p_user_data)
@@ -146,6 +146,19 @@ _get_first_track_num_image(void *p_user_data)
return p_env->gen.i_first_track; return p_env->gen.i_first_track;
} }
/*!
Find out if media has changed since the last call.
@param p_user_data the CD object to be acted upon.
@return 1 if media has changed since last call, 0 if not. Error
return codes are the same as driver_return_code_t
We always return DRIVER_OP_UNSUPPORTED.
*/
int
get_media_changed_image(void *p_user_data)
{
return DRIVER_OP_UNSUPPORTED;
}
/*! /*!
Return the media catalog number (MCN) from the CD or NULL if there Return the media catalog number (MCN) from the CD or NULL if there
is none or we don't have the ability to get it. is none or we don't have the ability to get it.

11
lib/driver/image_common.h
View File

@@ -1,5 +1,5 @@
/* /*
$Id: image_common.h,v 1.6 2005/01/18 00:57:20 rocky Exp $ $Id: image_common.h,v 1.7 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -99,6 +99,15 @@ void _get_drive_cap_image (const void *user_data,
*/ */
track_t _get_first_track_num_image(void *p_user_data); track_t _get_first_track_num_image(void *p_user_data);
/*!
Find out if media has changed since the last call.
@param p_user_data the CD object to be acted upon.
@return 1 if media has changed since last call, 0 if not. Error
return codes are the same as driver_return_code_t
We always return DRIVER_OP_UNSUPPORTED.
*/
int get_media_changed_image(void *p_user_data);
/*! /*!
Return the media catalog number (MCN) from the CD or NULL if there Return the media catalog number (MCN) from the CD or NULL if there
is none or we don't have the ability to get it. is none or we don't have the ability to get it.

209
lib/driver/mmc.c
View File

@@ -1,6 +1,6 @@
/* Common Multimedia Command (MMC) routines. /* Common Multimedia Command (MMC) routines.
$Id: mmc.c,v 1.1 2005/02/05 13:07:02 rocky Exp $ $Id: mmc.c,v 1.2 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -56,7 +56,7 @@ get_blocksize_mmc (void *p_user_data)
{ {
generic_img_private_t *p_env = p_user_data; generic_img_private_t *p_env = p_user_data;
if (!p_env) return DRIVER_OP_UNINIT; if (!p_env) return DRIVER_OP_UNINIT;
return scsi_mmc_get_blocksize(p_env->cdio); return mmc_get_blocksize(p_env->cdio);
} }
/*! /*!
@@ -69,7 +69,7 @@ get_disc_last_lsn_mmc (void *p_user_data)
{ {
generic_img_private_t *p_env = p_user_data; generic_img_private_t *p_env = p_user_data;
if (!p_env) return CDIO_INVALID_LSN; if (!p_env) return CDIO_INVALID_LSN;
return scsi_mmc_get_disc_last_lsn(p_env->cdio); return mmc_get_disc_last_lsn(p_env->cdio);
} }
void void
@@ -79,15 +79,22 @@ get_drive_cap_mmc (const void *p_user_data,
/*out*/ cdio_drive_misc_cap_t *p_misc_cap) /*out*/ cdio_drive_misc_cap_t *p_misc_cap)
{ {
const generic_img_private_t *p_env = p_user_data; const generic_img_private_t *p_env = p_user_data;
scsi_mmc_get_drive_cap( p_env->cdio, mmc_get_drive_cap( p_env->cdio,
p_read_cap, p_write_cap, p_misc_cap ); p_read_cap, p_write_cap, p_misc_cap );
} }
int
get_media_changed_mmc (const void *p_user_data)
{
const generic_img_private_t *p_env = p_user_data;
return mmc_get_media_changed( p_env->cdio );
}
char * char *
get_mcn_mmc (const void *p_user_data) get_mcn_mmc (const void *p_user_data)
{ {
const generic_img_private_t *p_env = p_user_data; const generic_img_private_t *p_env = p_user_data;
return scsi_mmc_get_mcn( p_env->cdio ); return mmc_get_mcn( p_env->cdio );
} }
/* Set read blocksize (via MMC) */ /* Set read blocksize (via MMC) */
@@ -96,7 +103,7 @@ set_blocksize_mmc (void *p_user_data, int i_blocksize)
{ {
generic_img_private_t *p_env = p_user_data; generic_img_private_t *p_env = p_user_data;
if (!p_env) return DRIVER_OP_UNINIT; if (!p_env) return DRIVER_OP_UNINIT;
return scsi_mmc_set_blocksize(p_env->cdio, i_blocksize); return mmc_set_blocksize(p_env->cdio, i_blocksize);
} }
/* Set CD-ROM drive speed (via MMC) */ /* Set CD-ROM drive speed (via MMC) */
@@ -105,7 +112,7 @@ set_speed_mmc (void *p_user_data, int i_speed)
{ {
generic_img_private_t *p_env = p_user_data; generic_img_private_t *p_env = p_user_data;
if (!p_env) return DRIVER_OP_UNINIT; if (!p_env) return DRIVER_OP_UNINIT;
return scsi_mmc_set_speed( p_env->cdio, i_speed ); return mmc_set_speed( p_env->cdio, i_speed );
} }
/************************************************************************* /*************************************************************************
@@ -115,7 +122,7 @@ set_speed_mmc (void *p_user_data, int i_speed)
int int
mmc_get_blocksize_private ( void *p_env, mmc_get_blocksize_private ( void *p_env,
const scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd) const mmc_run_cmd_fn_t run_mmc_cmd)
{ {
int i_status = 0; int i_status = 0;
scsi_mmc_cdb_t cdb = {{0, }}; scsi_mmc_cdb_t cdb = {{0, }};
@@ -139,7 +146,7 @@ mmc_get_blocksize_private ( void *p_env,
uint8_t *p = &mh.block_length_med; uint8_t *p = &mh.block_length_med;
if ( ! p_env ) return DRIVER_OP_UNINIT; if ( ! p_env ) return DRIVER_OP_UNINIT;
if ( ! run_scsi_mmc_cmd ) return DRIVER_OP_UNSUPPORTED; if ( ! run_mmc_cmd ) return DRIVER_OP_UNSUPPORTED;
memset (&mh, 0, sizeof (mh)); memset (&mh, 0, sizeof (mh));
@@ -148,9 +155,9 @@ mmc_get_blocksize_private ( void *p_env,
cdb.field[1] = 0x3F&1; cdb.field[1] = 0x3F&1;
cdb.field[4] = 12; cdb.field[4] = 12;
i_status = run_scsi_mmc_cmd (p_env, DEFAULT_TIMEOUT_MS, i_status = run_mmc_cmd (p_env, DEFAULT_TIMEOUT_MS,
scsi_mmc_get_cmd_len(cdb.field[0]), &cdb, mmc_get_cmd_len(cdb.field[0]), &cdb,
SCSI_MMC_DATA_WRITE, sizeof(mh), &mh); SCSI_MMC_DATA_WRITE, sizeof(mh), &mh);
if (DRIVER_OP_SUCCESS != i_status) return i_status; if (DRIVER_OP_SUCCESS != i_status) return i_status;
return CDIO_MMC_GET_LEN16(p); return CDIO_MMC_GET_LEN16(p);
@@ -198,7 +205,7 @@ mmc_get_drive_cap_buf(const uint8_t *p,
*/ */
void void
mmc_get_drive_cap_private (void *p_env, mmc_get_drive_cap_private (void *p_env,
const scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd, const mmc_run_cmd_fn_t run_mmc_cmd,
/*out*/ cdio_drive_read_cap_t *p_read_cap, /*out*/ cdio_drive_read_cap_t *p_read_cap,
/*out*/ cdio_drive_write_cap_t *p_write_cap, /*out*/ cdio_drive_write_cap_t *p_write_cap,
/*out*/ cdio_drive_misc_cap_t *p_misc_cap) /*out*/ cdio_drive_misc_cap_t *p_misc_cap)
@@ -211,7 +218,7 @@ mmc_get_drive_cap_private (void *p_env,
int i_status; int i_status;
uint16_t i_data = BUF_MAX; uint16_t i_data = BUF_MAX;
if ( ! p_env || ! run_scsi_mmc_cmd ) if ( ! p_env || ! run_mmc_cmd )
return; return;
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_MODE_SENSE_10); CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_MODE_SENSE_10);
@@ -223,10 +230,10 @@ mmc_get_drive_cap_private (void *p_env,
/* In the first run we run MODE SENSE 10 we are trying to get the /* In the first run we run MODE SENSE 10 we are trying to get the
length of the data features. */ length of the data features. */
i_status = run_scsi_mmc_cmd (p_env, DEFAULT_TIMEOUT_MS, i_status = run_mmc_cmd (p_env, DEFAULT_TIMEOUT_MS,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, SCSI_MMC_DATA_READ, &cdb, SCSI_MMC_DATA_READ,
sizeof(buf), &buf); sizeof(buf), &buf);
if (0 == i_status) { if (0 == i_status) {
uint16_t i_data_try = (uint16_t) CDIO_MMC_GET_LEN16(buf); uint16_t i_data_try = (uint16_t) CDIO_MMC_GET_LEN16(buf);
if (i_data_try < BUF_MAX) i_data = i_data_try; if (i_data_try < BUF_MAX) i_data = i_data_try;
@@ -237,10 +244,10 @@ mmc_get_drive_cap_private (void *p_env,
length. */ length. */
CDIO_MMC_SET_READ_LENGTH16(cdb.field, i_data); CDIO_MMC_SET_READ_LENGTH16(cdb.field, i_data);
i_status = run_scsi_mmc_cmd (p_env, DEFAULT_TIMEOUT_MS, i_status = run_mmc_cmd (p_env, DEFAULT_TIMEOUT_MS,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, SCSI_MMC_DATA_READ, &cdb, SCSI_MMC_DATA_READ,
sizeof(buf), &buf); sizeof(buf), &buf);
if (0 != i_status && CDIO_MMC_CAPABILITIES_PAGE != cdb.field[2]) { if (0 != i_status && CDIO_MMC_CAPABILITIES_PAGE != cdb.field[2]) {
cdb.field[2] = CDIO_MMC_CAPABILITIES_PAGE; cdb.field[2] = CDIO_MMC_CAPABILITIES_PAGE;
@@ -289,7 +296,7 @@ mmc_get_drive_cap_private (void *p_env,
*/ */
discmode_t discmode_t
mmc_get_dvd_struct_physical_private ( void *p_env, mmc_get_dvd_struct_physical_private ( void *p_env,
scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd, mmc_run_cmd_fn_t run_mmc_cmd,
cdio_dvd_struct_t *s) cdio_dvd_struct_t *s)
{ {
scsi_mmc_cdb_t cdb = {{0, }}; scsi_mmc_cdb_t cdb = {{0, }};
@@ -300,7 +307,7 @@ mmc_get_dvd_struct_physical_private ( void *p_env,
cdio_dvd_layer_t *layer; cdio_dvd_layer_t *layer;
if (!p_env) return DRIVER_OP_UNINIT; if (!p_env) return DRIVER_OP_UNINIT;
if (!run_scsi_mmc_cmd) return DRIVER_OP_UNSUPPORTED; if (!run_mmc_cmd) return DRIVER_OP_UNSUPPORTED;
if (layer_num >= CDIO_DVD_MAX_LAYERS) if (layer_num >= CDIO_DVD_MAX_LAYERS)
return -EINVAL; return -EINVAL;
@@ -310,8 +317,8 @@ mmc_get_dvd_struct_physical_private ( void *p_env,
cdb.field[7] = CDIO_DVD_STRUCT_PHYSICAL; cdb.field[7] = CDIO_DVD_STRUCT_PHYSICAL;
cdb.field[9] = sizeof(buf) & 0xff; cdb.field[9] = sizeof(buf) & 0xff;
i_status = run_scsi_mmc_cmd(p_env, DEFAULT_TIMEOUT_MS, i_status = run_mmc_cmd(p_env, DEFAULT_TIMEOUT_MS,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, SCSI_MMC_DATA_READ, &cdb, SCSI_MMC_DATA_READ,
sizeof(buf), &buf); sizeof(buf), &buf);
if (0 != i_status) if (0 != i_status)
@@ -351,14 +358,14 @@ mmc_get_dvd_struct_physical_private ( void *p_env,
*/ */
char * char *
mmc_get_mcn_private ( void *p_env, mmc_get_mcn_private ( void *p_env,
const scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd const mmc_run_cmd_fn_t run_mmc_cmd
) )
{ {
scsi_mmc_cdb_t cdb = {{0, }}; scsi_mmc_cdb_t cdb = {{0, }};
char buf[28] = { 0, }; char buf[28] = { 0, };
int i_status; int i_status;
if ( ! p_env || ! run_scsi_mmc_cmd ) if ( ! p_env || ! run_mmc_cmd )
return NULL; return NULL;
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_SUBCHANNEL); CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_SUBCHANNEL);
@@ -367,8 +374,8 @@ mmc_get_mcn_private ( void *p_env,
cdb.field[3] = CDIO_SUBCHANNEL_MEDIA_CATALOG; cdb.field[3] = CDIO_SUBCHANNEL_MEDIA_CATALOG;
CDIO_MMC_SET_READ_LENGTH16(cdb.field, sizeof(buf)); CDIO_MMC_SET_READ_LENGTH16(cdb.field, sizeof(buf));
i_status = run_scsi_mmc_cmd(p_env, DEFAULT_TIMEOUT_MS, i_status = run_mmc_cmd(p_env, DEFAULT_TIMEOUT_MS,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, SCSI_MMC_DATA_READ, &cdb, SCSI_MMC_DATA_READ,
sizeof(buf), buf); sizeof(buf), buf);
if(i_status == 0) { if(i_status == 0) {
@@ -385,7 +392,7 @@ mmc_get_mcn_private ( void *p_env,
*/ */
bool bool
mmc_init_cdtext_private ( void *p_user_data, mmc_init_cdtext_private ( void *p_user_data,
const scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd, const mmc_run_cmd_fn_t run_mmc_cmd,
set_cdtext_field_fn_t set_cdtext_field_fn set_cdtext_field_fn_t set_cdtext_field_fn
) )
{ {
@@ -395,7 +402,7 @@ mmc_init_cdtext_private ( void *p_user_data,
unsigned char wdata[5000] = { 0, }; unsigned char wdata[5000] = { 0, };
int i_status, i_errno; int i_status, i_errno;
if ( ! p_env || ! run_scsi_mmc_cmd || p_env->b_cdtext_error ) if ( ! p_env || ! run_mmc_cmd || p_env->b_cdtext_error )
return false; return false;
/* Operation code */ /* Operation code */
@@ -415,8 +422,8 @@ mmc_init_cdtext_private ( void *p_user_data,
/* We may need to give CD-Text a little more time to complete. */ /* We may need to give CD-Text a little more time to complete. */
/* First off, just try and read the size */ /* First off, just try and read the size */
i_status = run_scsi_mmc_cmd (p_env, READ_TIMEOUT, i_status = run_mmc_cmd (p_env, READ_TIMEOUT,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, SCSI_MMC_DATA_READ, &cdb, SCSI_MMC_DATA_READ,
4, &wdata); 4, &wdata);
@@ -432,8 +439,8 @@ mmc_init_cdtext_private ( void *p_user_data,
if (i_cdtext > sizeof(wdata)) i_cdtext = sizeof(wdata); if (i_cdtext > sizeof(wdata)) i_cdtext = sizeof(wdata);
CDIO_MMC_SET_READ_LENGTH16(cdb.field, i_cdtext); CDIO_MMC_SET_READ_LENGTH16(cdb.field, i_cdtext);
i_status = run_scsi_mmc_cmd (p_env, READ_TIMEOUT, i_status = run_mmc_cmd (p_env, READ_TIMEOUT,
scsi_mmc_get_cmd_len(cdb.field[0]), mmc_get_cmd_len(cdb.field[0]),
&cdb, SCSI_MMC_DATA_READ, &cdb, SCSI_MMC_DATA_READ,
i_cdtext, &wdata); i_cdtext, &wdata);
if (i_status != 0) { if (i_status != 0) {
@@ -450,7 +457,7 @@ mmc_init_cdtext_private ( void *p_user_data,
driver_return_code_t driver_return_code_t
mmc_set_blocksize_private ( void *p_env, mmc_set_blocksize_private ( void *p_env,
const scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd, const mmc_run_cmd_fn_t run_mmc_cmd,
unsigned int i_bsize) unsigned int i_bsize)
{ {
scsi_mmc_cdb_t cdb = {{0, }}; scsi_mmc_cdb_t cdb = {{0, }};
@@ -472,7 +479,7 @@ mmc_set_blocksize_private ( void *p_env,
} mh; } mh;
if ( ! p_env ) return DRIVER_OP_UNINIT; if ( ! p_env ) return DRIVER_OP_UNINIT;
if ( ! run_scsi_mmc_cmd ) return DRIVER_OP_UNSUPPORTED; if ( ! run_mmc_cmd ) return DRIVER_OP_UNSUPPORTED;
memset (&mh, 0, sizeof (mh)); memset (&mh, 0, sizeof (mh));
mh.block_desc_length = 0x08; mh.block_desc_length = 0x08;
@@ -485,8 +492,8 @@ mmc_set_blocksize_private ( void *p_env,
cdb.field[1] = 1 << 4; cdb.field[1] = 1 << 4;
cdb.field[4] = 12; cdb.field[4] = 12;
return run_scsi_mmc_cmd (p_env, DEFAULT_TIMEOUT_MS, return run_mmc_cmd (p_env, DEFAULT_TIMEOUT_MS,
scsi_mmc_get_cmd_len(cdb.field[0]), &cdb, mmc_get_cmd_len(cdb.field[0]), &cdb,
SCSI_MMC_DATA_WRITE, sizeof(mh), &mh); SCSI_MMC_DATA_WRITE, sizeof(mh), &mh);
} }
@@ -499,7 +506,7 @@ mmc_set_blocksize_private ( void *p_env,
either 6, 10, or 12. either 6, 10, or 12.
*/ */
uint8_t uint8_t
scsi_mmc_get_cmd_len(uint8_t scsi_cmd) mmc_get_cmd_len(uint8_t scsi_cmd)
{ {
static const uint8_t scsi_cdblen[8] = {6, 10, 10, 12, 12, 12, 10, 10}; static const uint8_t scsi_cdblen[8] = {6, 10, 10, 12, 12, 12, 10, 10};
return scsi_cdblen[((scsi_cmd >> 5) & 7)]; return scsi_cdblen[((scsi_cmd >> 5) & 7)];
@@ -510,7 +517,7 @@ scsi_mmc_get_cmd_len(uint8_t scsi_cmd)
@return the lsn. On error 0 or CDIO_INVALD_LSN. @return the lsn. On error 0 or CDIO_INVALD_LSN.
*/ */
lsn_t lsn_t
scsi_mmc_get_disc_last_lsn ( const CdIo_t *p_cdio ) mmc_get_disc_last_lsn ( const CdIo_t *p_cdio )
{ {
scsi_mmc_cdb_t cdb = {{0, }}; scsi_mmc_cdb_t cdb = {{0, }};
uint8_t buf[12] = { 0, }; uint8_t buf[12] = { 0, };
@@ -530,9 +537,8 @@ scsi_mmc_get_disc_last_lsn ( const CdIo_t *p_cdio )
CDIO_MMC_SET_READ_LENGTH16(cdb.field, sizeof(buf)); CDIO_MMC_SET_READ_LENGTH16(cdb.field, sizeof(buf));
i_status = scsi_mmc_run_cmd(p_cdio, DEFAULT_TIMEOUT_MS, &cdb, i_status = mmc_run_cmd(p_cdio, DEFAULT_TIMEOUT_MS, &cdb, SCSI_MMC_DATA_READ,
SCSI_MMC_DATA_READ, sizeof(buf), buf);
sizeof(buf), buf);
if (i_status) return CDIO_INVALID_LSN; if (i_status) return CDIO_INVALID_LSN;
@@ -557,7 +563,7 @@ scsi_mmc_get_disc_last_lsn ( const CdIo_t *p_cdio )
especially tables 72, 73 and 75. especially tables 72, 73 and 75.
*/ */
discmode_t discmode_t
scsi_mmc_get_discmode( const CdIo_t *p_cdio ) mmc_get_discmode( const CdIo_t *p_cdio )
{ {
uint8_t buf[14] = { 0, }; uint8_t buf[14] = { 0, };
@@ -568,7 +574,7 @@ scsi_mmc_get_discmode( const CdIo_t *p_cdio )
cdb.field[1] = CDIO_CDROM_MSF; /* The MMC-5 spec may require this. */ cdb.field[1] = CDIO_CDROM_MSF; /* The MMC-5 spec may require this. */
cdb.field[2] = CDIO_MMC_READTOC_FMT_FULTOC; cdb.field[2] = CDIO_MMC_READTOC_FMT_FULTOC;
CDIO_MMC_SET_READ_LENGTH8(cdb.field, sizeof(buf)); CDIO_MMC_SET_READ_LENGTH8(cdb.field, sizeof(buf));
scsi_mmc_run_cmd(p_cdio, 2000, &cdb, SCSI_MMC_DATA_READ, sizeof(buf), buf); mmc_run_cmd(p_cdio, 2000, &cdb, SCSI_MMC_DATA_READ, sizeof(buf), buf);
if (buf[7] == 0xA0) { if (buf[7] == 0xA0) {
if (buf[13] == 0x00) { if (buf[13] == 0x00) {
if (buf[5] & 0x04) if (buf[5] & 0x04)
@@ -585,14 +591,14 @@ scsi_mmc_get_discmode( const CdIo_t *p_cdio )
} }
void void
scsi_mmc_get_drive_cap (const CdIo_t *p_cdio, mmc_get_drive_cap (const CdIo_t *p_cdio,
/*out*/ cdio_drive_read_cap_t *p_read_cap, /*out*/ cdio_drive_read_cap_t *p_read_cap,
/*out*/ cdio_drive_write_cap_t *p_write_cap, /*out*/ cdio_drive_write_cap_t *p_write_cap,
/*out*/ cdio_drive_misc_cap_t *p_misc_cap) /*out*/ cdio_drive_misc_cap_t *p_misc_cap)
{ {
if ( ! p_cdio ) return; if ( ! p_cdio ) return;
mmc_get_drive_cap_private (p_cdio->env, mmc_get_drive_cap_private (p_cdio->env,
p_cdio->op.run_scsi_mmc_cmd, p_cdio->op.run_mmc_cmd,
p_read_cap, p_write_cap, p_misc_cap); p_read_cap, p_write_cap, p_misc_cap);
} }
@@ -600,12 +606,12 @@ scsi_mmc_get_drive_cap (const CdIo_t *p_cdio,
Get the DVD type associated with cd object. Get the DVD type associated with cd object.
*/ */
discmode_t discmode_t
scsi_mmc_get_dvd_struct_physical ( const CdIo_t *p_cdio, cdio_dvd_struct_t *s) mmc_get_dvd_struct_physical ( const CdIo_t *p_cdio, cdio_dvd_struct_t *s)
{ {
if ( ! p_cdio ) return -2; if ( ! p_cdio ) return -2;
return return
mmc_get_dvd_struct_physical_private (p_cdio->env, mmc_get_dvd_struct_physical_private (p_cdio->env,
p_cdio->op.run_scsi_mmc_cmd, p_cdio->op.run_mmc_cmd,
s); s);
} }
@@ -614,7 +620,7 @@ scsi_mmc_get_dvd_struct_physical ( const CdIo_t *p_cdio, cdio_dvd_struct_t *s)
False is returned if we had an error getting the information. False is returned if we had an error getting the information.
*/ */
bool bool
scsi_mmc_get_hwinfo ( const CdIo_t *p_cdio, mmc_get_hwinfo ( const CdIo_t *p_cdio,
/*out*/ cdio_hwinfo_t *hw_info ) /*out*/ cdio_hwinfo_t *hw_info )
{ {
int i_status; /* Result of SCSI MMC command */ int i_status; /* Result of SCSI MMC command */
@@ -626,7 +632,7 @@ scsi_mmc_get_hwinfo ( const CdIo_t *p_cdio,
if (! p_cdio || ! hw_info ) return false; if (! p_cdio || ! hw_info ) return false;
i_status = scsi_mmc_run_cmd(p_cdio, DEFAULT_TIMEOUT_MS, i_status = mmc_run_cmd(p_cdio, DEFAULT_TIMEOUT_MS,
&cdb, SCSI_MMC_DATA_READ, &cdb, SCSI_MMC_DATA_READ,
sizeof(buf), &buf); sizeof(buf), &buf);
if (i_status == 0) { if (i_status == 0) {
@@ -648,11 +654,42 @@ scsi_mmc_get_hwinfo ( const CdIo_t *p_cdio,
return false; return false;
} }
/*!
Find out if media has changed since the last call.
@param p_cdio the CD object to be acted upon.
@return 1 if media has changed since last call, 0 if not. Error
return codes are the same as driver_return_code_t
*/
int mmc_get_media_changed(const CdIo_t *p_cdio)
{
scsi_mmc_cdb_t cdb = {{0, }};
char buf[8] = { 0, };
int i_status;
if ( ! p_cdio ) return DRIVER_OP_UNINIT;
if ( ! p_cdio->op.run_mmc_cmd ) return DRIVER_OP_UNSUPPORTED;
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_GET_EVENT_STATUS);
cdb.field[4] = 1 << 4; /* Media */
/* Setup to read header, to get length of data */
CDIO_MMC_SET_READ_LENGTH16(cdb.field, sizeof(buf));
i_status = p_cdio->op.run_mmc_cmd(p_cdio->env, DEFAULT_TIMEOUT_MS,
mmc_get_cmd_len(cdb.field[0]),
&cdb, SCSI_MMC_DATA_READ,
sizeof(buf), buf);
if(i_status == 0) {
return 0 != (buf[6] & 0x02);
}
return DRIVER_OP_ERROR;
}
char * char *
scsi_mmc_get_mcn ( const CdIo_t *p_cdio ) mmc_get_mcn ( const CdIo_t *p_cdio )
{ {
if ( ! p_cdio ) return NULL; if ( ! p_cdio ) return NULL;
return mmc_get_mcn_private (p_cdio->env, p_cdio->op.run_scsi_mmc_cmd ); return mmc_get_mcn_private (p_cdio->env, p_cdio->op.run_mmc_cmd );
} }
/*! /*!
@@ -669,24 +706,24 @@ scsi_mmc_get_mcn ( const CdIo_t *p_cdio )
input. We'll figure out what the right CDB length should be. input. We'll figure out what the right CDB length should be.
*/ */
driver_return_code_t driver_return_code_t
scsi_mmc_run_cmd( const CdIo_t *p_cdio, unsigned int i_timeout_ms, mmc_run_cmd( const CdIo_t *p_cdio, unsigned int i_timeout_ms,
const scsi_mmc_cdb_t *p_cdb, const scsi_mmc_cdb_t *p_cdb,
scsi_mmc_direction_t e_direction, unsigned int i_buf, scsi_mmc_direction_t e_direction, unsigned int i_buf,
/*in/out*/ void *p_buf ) /*in/out*/ void *p_buf )
{ {
if (!p_cdio) return DRIVER_OP_UNINIT; if (!p_cdio) return DRIVER_OP_UNINIT;
if (!p_cdio->op.run_scsi_mmc_cmd) return DRIVER_OP_UNSUPPORTED; if (!p_cdio->op.run_mmc_cmd) return DRIVER_OP_UNSUPPORTED;
return p_cdio->op.run_scsi_mmc_cmd(p_cdio->env, i_timeout_ms, return p_cdio->op.run_mmc_cmd(p_cdio->env, i_timeout_ms,
scsi_mmc_get_cmd_len(p_cdb->field[0]), scsi_mmc_get_cmd_len(p_cdb->field[0]),
p_cdb, e_direction, i_buf, p_buf); p_cdb, e_direction, i_buf, p_buf);
} }
int int
scsi_mmc_get_blocksize ( const CdIo_t *p_cdio) mmc_get_blocksize ( const CdIo_t *p_cdio)
{ {
if ( ! p_cdio ) return DRIVER_OP_UNINIT; if ( ! p_cdio ) return DRIVER_OP_UNINIT;
return return
mmc_get_blocksize_private (p_cdio->env, p_cdio->op.run_scsi_mmc_cmd); mmc_get_blocksize_private (p_cdio->env, p_cdio->op.run_mmc_cmd);
} }
@@ -694,29 +731,29 @@ scsi_mmc_get_blocksize ( const CdIo_t *p_cdio)
* Eject using SCSI MMC commands. Return 0 if successful. * Eject using SCSI MMC commands. Return 0 if successful.
*/ */
driver_return_code_t driver_return_code_t
scsi_mmc_eject_media( const CdIo_t *p_cdio ) mmc_eject_media( const CdIo_t *p_cdio )
{ {
int i_status = 0; int i_status = 0;
scsi_mmc_cdb_t cdb = {{0, }}; scsi_mmc_cdb_t cdb = {{0, }};
uint8_t buf[1]; uint8_t buf[1];
scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd; mmc_run_cmd_fn_t run_mmc_cmd;
if ( ! p_cdio ) return DRIVER_OP_UNINIT; if ( ! p_cdio ) return DRIVER_OP_UNINIT;
if ( ! p_cdio->op.run_scsi_mmc_cmd ) return DRIVER_OP_UNSUPPORTED; if ( ! p_cdio->op.run_mmc_cmd ) return DRIVER_OP_UNSUPPORTED;
run_scsi_mmc_cmd = p_cdio->op.run_scsi_mmc_cmd; run_mmc_cmd = p_cdio->op.run_mmc_cmd;
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_ALLOW_MEDIUM_REMOVAL); CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_ALLOW_MEDIUM_REMOVAL);
i_status = run_scsi_mmc_cmd (p_cdio->env, DEFAULT_TIMEOUT_MS, i_status = run_mmc_cmd (p_cdio->env, DEFAULT_TIMEOUT_MS,
scsi_mmc_get_cmd_len(cdb.field[0]), &cdb, mmc_get_cmd_len(cdb.field[0]), &cdb,
SCSI_MMC_DATA_WRITE, 0, &buf); SCSI_MMC_DATA_WRITE, 0, &buf);
if (0 != i_status) return i_status; if (0 != i_status) return i_status;
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_START_STOP); CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_START_STOP);
cdb.field[4] = 1; cdb.field[4] = 1;
i_status = run_scsi_mmc_cmd (p_cdio->env, DEFAULT_TIMEOUT_MS, i_status = run_mmc_cmd (p_cdio->env, DEFAULT_TIMEOUT_MS,
scsi_mmc_get_cmd_len(cdb.field[0]), &cdb, mmc_get_cmd_len(cdb.field[0]), &cdb,
SCSI_MMC_DATA_WRITE, 0, &buf); SCSI_MMC_DATA_WRITE, 0, &buf);
if (0 != i_status) if (0 != i_status)
return i_status; return i_status;
@@ -724,9 +761,9 @@ scsi_mmc_eject_media( const CdIo_t *p_cdio )
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_START_STOP); CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_START_STOP);
cdb.field[4] = 2; /* eject */ cdb.field[4] = 2; /* eject */
return run_scsi_mmc_cmd (p_cdio->env, DEFAULT_TIMEOUT_MS, return run_mmc_cmd (p_cdio->env, DEFAULT_TIMEOUT_MS,
scsi_mmc_get_cmd_len(cdb.field[0]), &cdb, mmc_get_cmd_len(cdb.field[0]), &cdb,
SCSI_MMC_DATA_WRITE, 0, &buf); SCSI_MMC_DATA_WRITE, 0, &buf);
} }
@@ -734,17 +771,17 @@ scsi_mmc_eject_media( const CdIo_t *p_cdio )
Can read only up to 25 blocks. Can read only up to 25 blocks.
*/ */
driver_return_code_t driver_return_code_t
scsi_mmc_read_sectors ( const CdIo_t *p_cdio, void *p_buf, lba_t lba, mmc_read_sectors ( const CdIo_t *p_cdio, void *p_buf, lba_t lba,
int sector_type, unsigned int i_blocks ) int sector_type, unsigned int i_blocks )
{ {
scsi_mmc_cdb_t cdb = {{0, }}; scsi_mmc_cdb_t cdb = {{0, }};
scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd; mmc_run_cmd_fn_t run_mmc_cmd;
if (!p_cdio) return DRIVER_OP_UNINIT; if (!p_cdio) return DRIVER_OP_UNINIT;
if (!p_cdio->op.run_scsi_mmc_cmd ) return DRIVER_OP_UNSUPPORTED; if (!p_cdio->op.run_mmc_cmd ) return DRIVER_OP_UNSUPPORTED;
run_scsi_mmc_cmd = p_cdio->op.run_scsi_mmc_cmd; run_mmc_cmd = p_cdio->op.run_mmc_cmd;
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_CD); CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_CD);
CDIO_MMC_SET_READ_TYPE (cdb.field, sector_type); CDIO_MMC_SET_READ_TYPE (cdb.field, sector_type);
@@ -753,19 +790,19 @@ scsi_mmc_read_sectors ( const CdIo_t *p_cdio, void *p_buf, lba_t lba,
CDIO_MMC_SET_MAIN_CHANNEL_SELECTION_BITS(cdb.field, CDIO_MMC_SET_MAIN_CHANNEL_SELECTION_BITS(cdb.field,
CDIO_MMC_MCSB_ALL_HEADERS); CDIO_MMC_MCSB_ALL_HEADERS);
return run_scsi_mmc_cmd (p_cdio->env, DEFAULT_TIMEOUT_MS, return run_mmc_cmd (p_cdio->env, DEFAULT_TIMEOUT_MS,
scsi_mmc_get_cmd_len(cdb.field[0]), &cdb, mmc_get_cmd_len(cdb.field[0]), &cdb,
SCSI_MMC_DATA_READ, SCSI_MMC_DATA_READ,
CDIO_CD_FRAMESIZE_RAW * i_blocks, CDIO_CD_FRAMESIZE_RAW * i_blocks,
p_buf); p_buf);
} }
driver_return_code_t driver_return_code_t
scsi_mmc_set_blocksize ( const CdIo_t *p_cdio, unsigned int i_blocksize) mmc_set_blocksize ( const CdIo_t *p_cdio, unsigned int i_blocksize)
{ {
if ( ! p_cdio ) return DRIVER_OP_UNINIT; if ( ! p_cdio ) return DRIVER_OP_UNINIT;
return return
mmc_set_blocksize_private (p_cdio->env, p_cdio->op.run_scsi_mmc_cmd, mmc_set_blocksize_private (p_cdio->env, p_cdio->op.run_mmc_cmd,
i_blocksize); i_blocksize);
} }
@@ -775,11 +812,9 @@ scsi_mmc_set_blocksize ( const CdIo_t *p_cdio, unsigned int i_blocksize)
@return the drive speed if greater than 0. -1 if we had an error. is -2 @return the drive speed if greater than 0. -1 if we had an error. is -2
returned if this is not implemented for the current driver. returned if this is not implemented for the current driver.
@see scsi_mmc_set_speed
*/ */
int int
scsi_mmc_set_speed( const CdIo_t *p_cdio, int i_speed ) mmc_set_speed( const CdIo_t *p_cdio, int i_speed )
{ {
uint8_t buf[14] = { 0, }; uint8_t buf[14] = { 0, };
@@ -800,8 +835,8 @@ scsi_mmc_set_speed( const CdIo_t *p_cdio, int i_speed )
the maximum allowable speed. the maximum allowable speed.
*/ */
CDIO_MMC_SET_LEN16(cdb.field, 4, 0xffff); CDIO_MMC_SET_LEN16(cdb.field, 4, 0xffff);
return scsi_mmc_run_cmd(p_cdio, 2000, &cdb, SCSI_MMC_DATA_READ, return mmc_run_cmd(p_cdio, 2000, &cdb, SCSI_MMC_DATA_READ,
sizeof(buf), buf); sizeof(buf), buf);
} }

20
lib/driver/mmc_private.h
View File

@@ -1,6 +1,6 @@
/* private MMC helper routines. /* private MMC helper routines.
$Id: mmc_private.h,v 1.1 2005/02/05 13:07:02 rocky Exp $ $Id: mmc_private.h,v 1.2 2005/02/06 11:13:37 rocky Exp $
Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com> Copyright (C) 2004, 2005 Rocky Bernstein <rocky@panix.com>
@@ -55,6 +55,8 @@ void get_drive_cap_mmc (const void *p_user_data,
/*out*/ cdio_drive_write_cap_t *p_write_cap, /*out*/ cdio_drive_write_cap_t *p_write_cap,
/*out*/ cdio_drive_misc_cap_t *p_misc_cap); /*out*/ cdio_drive_misc_cap_t *p_misc_cap);
int get_media_changed_mmc (const void *p_user_data);
char *get_mcn_mmc (const void *p_user_data); char *get_mcn_mmc (const void *p_user_data);
/* Set read blocksize (via MMC) */ /* Set read blocksize (via MMC) */
@@ -68,7 +70,7 @@ driver_return_code_t set_speed_mmc (void *p_user_data, int i_speed);
to better classify these. to better classify these.
************************************************************/ ************************************************************/
typedef driver_return_code_t (*scsi_mmc_run_cmd_fn_t) typedef driver_return_code_t (*mmc_run_cmd_fn_t)
( void *p_user_data, ( void *p_user_data,
unsigned int i_timeout_ms, unsigned int i_timeout_ms,
unsigned int i_cdb, unsigned int i_cdb,
@@ -77,7 +79,7 @@ typedef driver_return_code_t (*scsi_mmc_run_cmd_fn_t)
unsigned int i_buf, /*in/out*/ void *p_buf ); unsigned int i_buf, /*in/out*/ void *p_buf );
int mmc_set_blocksize_mmc_private ( const void *p_env, const int mmc_set_blocksize_mmc_private ( const void *p_env, const
scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd, mmc_run_cmd_fn_t run_mmc_cmd,
unsigned int bsize ); unsigned int bsize );
/*! /*!
@@ -85,20 +87,20 @@ int mmc_set_blocksize_mmc_private ( const void *p_env, const
*/ */
discmode_t discmode_t
mmc_get_dvd_struct_physical_private ( void *p_env, mmc_get_dvd_struct_physical_private ( void *p_env,
scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd, mmc_run_cmd_fn_t run_mmc_cmd,
cdio_dvd_struct_t *s ); cdio_dvd_struct_t *s );
int int
mmc_get_blocksize_private ( void *p_env, mmc_get_blocksize_private ( void *p_env,
scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd); mmc_run_cmd_fn_t run_mmc_cmd);
char *mmc_get_mcn_private ( void *p_env, char *mmc_get_mcn_private ( void *p_env,
scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd mmc_run_cmd_fn_t run_mmc_cmd
); );
bool mmc_init_cdtext_private ( void *p_user_data, bool mmc_init_cdtext_private ( void *p_user_data,
scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd, mmc_run_cmd_fn_t run_mmc_cmd,
set_cdtext_field_fn_t set_cdtext_field_fn set_cdtext_field_fn_t set_cdtext_field_fn
); );
@@ -121,11 +123,11 @@ void mmc_get_drive_cap_buf(const uint8_t *p,
*/ */
void void
mmc_get_drive_cap_private ( void *p_env, mmc_get_drive_cap_private ( void *p_env,
const scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd, const mmc_run_cmd_fn_t run_mmc_cmd,
/*out*/ cdio_drive_read_cap_t *p_read_cap, /*out*/ cdio_drive_read_cap_t *p_read_cap,
/*out*/ cdio_drive_write_cap_t *p_write_cap, /*out*/ cdio_drive_write_cap_t *p_write_cap,
/*out*/ cdio_drive_misc_cap_t *p_misc_cap); /*out*/ cdio_drive_misc_cap_t *p_misc_cap);
driver_return_code_t driver_return_code_t
mmc_set_blocksize_private ( void *p_env, mmc_set_blocksize_private ( void *p_env,
const scsi_mmc_run_cmd_fn_t run_scsi_mmc_cmd, const mmc_run_cmd_fn_t run_mmc_cmd,
unsigned int i_bsize); unsigned int i_bsize);