diff --git a/extras/MacOSX_dvdioctl/DVDioctl.cpp b/extras/MacOSX_dvdioctl/DVDioctl.cpp index 9eb0aed236357aa675fc27914100f57b7e6423e4..1faead5a21ffd5b0bf8e34bce79603ae48d65577 100644 --- a/extras/MacOSX_dvdioctl/DVDioctl.cpp +++ b/extras/MacOSX_dvdioctl/DVDioctl.cpp @@ -3,7 +3,7 @@ ***************************************************************************** * Copyright (C) 1998-2000 Apple Computer, Inc. All rights reserved. * Copyright (C) 2001 VideoLAN - * $Id: DVDioctl.cpp,v 1.1 2001/04/02 23:30:41 sam Exp $ + * $Id: DVDioctl.cpp,v 1.2 2001/04/04 02:49:18 sam Exp $ * * Authors: Samuel Hocevar * @@ -29,6 +29,9 @@ * it is still in use *****************************************************************************/ +//XXX: uncomment to activate the key exchange ioctls - may hang the machine +//#define ACTIVATE_DANGEROUS_IOCTL 1 + /***************************************************************************** * Preamble *****************************************************************************/ @@ -49,8 +52,9 @@ extern "C" #include #include -#include #include +#include +#include #include "DVDioctl.h" @@ -84,17 +88,17 @@ typedef struct buf buf_t; /***************************************************************************** * Local prototypes *****************************************************************************/ -static int DVDClose ( dev_t, int, int, struct proc * ); -static int DVDIoctl ( dev_t, u_long, caddr_t, int, struct proc * ); -static int DVDOpen ( dev_t, int, int, struct proc * ); -static int DVDSize ( dev_t ); -static void DVDStrategy ( buf_t * ); -static int DVDReadWrite( dkr_t, dkrtype_t ); +static int DVDClose ( dev_t, int, int, struct proc * ); +static int DVDBlockIoctl ( dev_t, u_long, caddr_t, int, struct proc * ); +static int DVDOpen ( dev_t, int, int, struct proc * ); +static int DVDSize ( dev_t ); +static void DVDStrategy ( buf_t * ); +static int DVDReadWrite ( dkr_t, dkrtype_t ); static void DVDReadWriteCompletion( void *, void *, IOReturn, UInt64 ); static struct bdevsw device_functions = { - DVDOpen, DVDClose, DVDStrategy, DVDIoctl, eno_dump, DVDSize, D_DISK + DVDOpen, DVDClose, DVDStrategy, DVDBlockIoctl, eno_dump, DVDSize, D_DISK }; /***************************************************************************** @@ -106,6 +110,7 @@ static bool b_inuse; static int i_major; static void *p_node; static IODVDMedia *p_dvd; +static IODVDBlockStorageDriver *p_drive; /***************************************************************************** * DKR_GET_DEV: borrowed from IOMediaBSDClient.cpp @@ -249,6 +254,7 @@ bool DVDioctl::init( OSDictionary *p_dict = 0 ) p_node = NULL; p_dvd = NULL; + p_drive = NULL; i_major = -1; b_inuse = false; @@ -341,20 +347,6 @@ void DVDioctl::free( void ) super::free( ); } -#if 0 -IOReturn DVDioctl::report( IODVDMedia *DVD, IOMemoryDescriptor *buffer, const DVDKeyClass keyClass, const UInt32 lba, const UInt8 agid, const DVDKeyFormat keyFormat ) -{ - IOLog( "DVD ioctl: reportkey\n" ); - return DVD->getProvider()->reportKey( buffer, keyClass, lba, agid, keyFormat ); -} - -IOReturn DVDioctl::send( IODVDMedia *DVD, IOMemoryDescriptor *buffer, const DVDKeyClass keyClass, const UInt32 lba, const DVDKeyFormat keyFormat ) -{ - IOLog( "DVD ioctl: sendkey\n" ); - return DVD->getProvider()->sendKey( buffer, keyClass, lba, keyFormat ); -} -#endif - /* following functions are local */ /***************************************************************************** @@ -363,7 +355,6 @@ IOReturn DVDioctl::send( IODVDMedia *DVD, IOMemoryDescriptor *buffer, const DVDK static int DVDOpen( dev_t dev, int flags, int devtype, struct proc * ) { IOStorageAccess level; - int i_err; /* Check that the device hasn't already been opened */ if( b_inuse ) @@ -408,19 +399,18 @@ static int DVDOpen( dev_t dev, int flags, int devtype, struct proc * ) level = (flags & FWRITE) ? kIOStorageAccessReaderWriter : kIOStorageAccessReader; - if( p_dvd->open( p_this, 0, level) ) - { - log( LOG_INFO, "DVD ioctl: IODVDMedia->open()\n" ); - i_err = 0; - } - else + if( ! p_dvd->open( p_this, 0, level) ) { log( LOG_INFO, "DVD ioctl: IODVDMedia object busy\n" ); b_inuse = false; - i_err = EBUSY; + return EBUSY; } - return i_err; + p_drive = p_dvd->getProvider(); + + log( LOG_INFO, "DVD ioctl: IODVDMedia->open()\n" ); + + return 0; } /***************************************************************************** @@ -430,6 +420,9 @@ static int DVDClose( dev_t dev, int flags, int devtype, struct proc * ) { /* Release the device */ p_dvd->close( p_this ); + + p_dvd = NULL; + p_drive = NULL; b_inuse = false; log( LOG_INFO, "DVD ioctl: IODVDMedia->close()\n" ); @@ -455,27 +448,59 @@ static void DVDStrategy( buf_t * bp ) } /***************************************************************************** - * DVDIoctl: issue an ioctl on the device + * DVDBlockIoctl: issue an ioctl on the block device *****************************************************************************/ -static int DVDIoctl( dev_t dev, u_long cmd, caddr_t addr, int flags, - struct proc *p ) +static int DVDBlockIoctl( dev_t dev, u_long cmd, caddr_t addr, int flags, + struct proc *p ) { + dvdioctl_data_t * p_data = (dvdioctl_data_t *)addr; + switch( cmd ) { case IODVD_READ_STRUCTURE: - //log( LOG_INFO, "DVD ioctl: IODVD_READ_STRUCTURE\n" ); + + log( LOG_INFO, "DVD ioctl: IODVD_READ_STRUCTURE\n" ); + return 0; case IODVD_SEND_KEY: - //log( LOG_INFO, "DVD ioctl: IODVD_SEND_KEY\n" ); - return 0; + + log( LOG_INFO, "DVD ioctl: send key to `%s', " + "buf %d, format %d, class %d, agid %d\n", + p_drive->getDeviceTypeName(), + (int)p_data->p_buffer, p_data->i_keyformat, + p_data->i_keyclass, p_data->i_agid ); + +#ifdef ACTIVATE_DANGEROUS_IOCTL + return p_drive->sendKey( (IOMemoryDescriptor *)p_data->p_buffer, + (DVDKeyClass)p_data->i_keyclass, + p_data->i_agid, + (DVDKeyFormat)p_data->i_keyformat ); +#else + return -1; +#endif case IODVD_REPORT_KEY: - //log( LOG_INFO, "DVD ioctl: IODVD_REPORT_KEY\n" ); - return 0; + + log( LOG_INFO, "DVD ioctl: report key from `%s', " + p_drive->getDeviceTypeName(), + "buf %d, class %d, lba %d, agid %d, format %d\n", + (int)p_data->p_buffer, p_data->i_keyclass, p_data->i_lba, + p_data->i_agid, p_data->i_keyformat ); + +#ifdef ACTIVATE_DANGEROUS_IOCTL + return p_drive->reportKey( (IOMemoryDescriptor *)p_data->p_buffer, + (DVDKeyClass)p_data->i_keyclass, + p_data->i_lba, p_data->i_agid, + (DVDKeyFormat)p_data->i_keyformat ); +#else + return -1; +#endif default: - //log( LOG_INFO, "DVD ioctl: unknown ioctl\n" ); + + log( LOG_INFO, "DVD ioctl: unknown ioctl\n" ); + return EINVAL; } } @@ -591,7 +616,7 @@ static void DVDReadWriteCompletion( void * target, if ( status != kIOReturnSuccess ) { - IOLog( "%s: %s.\n", /*p_this->name*/ "DVD ioctl", + IOLog( "DVD ioctl: %s (is the disc authenticated ?)\n", p_this->stringFromReturn(status) ); } diff --git a/extras/MacOSX_dvdioctl/DVDioctl.h b/extras/MacOSX_dvdioctl/DVDioctl.h index dd9e73e99477377fa38dfdbbff8764291d4556c3..c85c712f2ef1d4cb0480530a2dff337610ca1490 100644 --- a/extras/MacOSX_dvdioctl/DVDioctl.h +++ b/extras/MacOSX_dvdioctl/DVDioctl.h @@ -2,7 +2,7 @@ * DVDioctl.h: Linux-like DVD driver for Darwin and MacOS X ***************************************************************************** * Copyright (C) 2001 VideoLAN - * $Id: DVDioctl.h,v 1.1 2001/04/02 23:30:41 sam Exp $ + * $Id: DVDioctl.h,v 1.2 2001/04/04 02:49:18 sam Exp $ * * Authors: Samuel Hocevar * @@ -21,8 +21,49 @@ * under the License. *****************************************************************************/ -struct sum { int a, b, r; }; -#define IODVD_READ_STRUCTURE _IOWR('B', 1, struct sum) -#define IODVD_SEND_KEY _IOWR('B', 2, struct sum) -#define IODVD_REPORT_KEY _IOWR('B', 3, struct sum) +#if defined(KERNEL) +/* Everything has already been defined */ +#else +enum DVDKeyFormat +{ + kCSSAGID = 0x00, + kChallengeKey = 0x01, + kKey1 = 0x02, + kKey2 = 0x03, + kTitleKey = 0x04, + kASF = 0x05, + kSetRegion = 0x06, + kRPCState = 0x08, + kCSS2AGID = 0x10, + kCPRMAGID = 0x11, + kInvalidateAGID = 0x3f +}; + +enum DVDKeyClass +{ + kCSS_CSS2_CPRM = 0x00, + kRSSA = 0x01 +}; +#endif + +typedef struct dvdioctl_data +{ + void *p_buffer; + +#if defined(KERNEL) + UInt32 i_lba; + UInt8 i_agid; +#else + u32 i_lba; + u8 i_agid; +#endif + + int i_keyclass; + int i_keyformat; + +} dvdioctl_data_t; + +#define IODVD_READ_STRUCTURE _IOWR('B', 1, dvdioctl_data_t) +#define IODVD_SEND_KEY _IOWR('B', 2, dvdioctl_data_t) +#define IODVD_REPORT_KEY _IOWR('B', 3, dvdioctl_data_t) diff --git a/plugins/dvd/dvd_css.c b/plugins/dvd/dvd_css.c index e3fe4221c5d6981861e22e97acd88107bdf79732..991fc76c18f2f8976162cfb8ea076ab1806625bb 100644 --- a/plugins/dvd/dvd_css.c +++ b/plugins/dvd/dvd_css.c @@ -2,7 +2,7 @@ * dvd_css.c: Functions for DVD authentification and unscrambling ***************************************************************************** * Copyright (C) 1999-2001 VideoLAN - * $Id: dvd_css.c,v 1.19 2001/04/02 23:30:41 sam Exp $ + * $Id: dvd_css.c,v 1.20 2001/04/04 02:49:18 sam Exp $ * * Author: Stéphane Borel * @@ -71,7 +71,7 @@ int CSSTest( int i_fd ) { int i_ret, i_copyright; - i_ret = dvd_ReadCopyright( i_fd, 0 /* i_layer */, &i_copyright ); + i_ret = ioctl_ReadCopyright( i_fd, 0 /* i_layer */, &i_copyright ); if( i_ret < 0 ) { @@ -105,10 +105,11 @@ int CSSInit( css_t * p_css ) return -1; case 1: + intf_WarnMsg( 3, "css info: already authenticated" ); return 0; case 0: - intf_WarnMsg( 3, "css info: authenticating" ); + intf_WarnMsg( 3, "css info: need to authenticate" ); } /* Init sequence, request AGID */ @@ -116,7 +117,7 @@ int CSSInit( css_t * p_css ) { intf_WarnMsg( 3, "css info: requesting AGID %d", i ); - i_ret = dvd_LUSendAgid( p_css ); + i_ret = ioctl_LUSendAgid( p_css ); if( i_ret != -1 ) { @@ -127,7 +128,7 @@ int CSSInit( css_t * p_css ) intf_ErrMsg( "css error: AGID N/A, invalidating" ); p_css->i_agid = 0; - dvd_InvalidateAgid( p_css ); + ioctl_InvalidateAgid( p_css ); } /* Unable to authenticate without AGID */ @@ -149,14 +150,14 @@ int CSSInit( css_t * p_css ) } /* Send challenge to LU */ - if( dvd_HostSendChallenge( p_css, p_buffer ) < 0 ) + if( ioctl_HostSendChallenge( p_css, p_buffer ) < 0 ) { intf_ErrMsg( "css error: failed sending challenge to LU" ); return -1; } /* Get key1 from LU */ - if( dvd_LUSendKey1( p_css, p_buffer ) < 0) + if( ioctl_LUSendKey1( p_css, p_buffer ) < 0) { intf_ErrMsg( "css error: failed getting key1 from LU" ); return -1; @@ -189,7 +190,7 @@ int CSSInit( css_t * p_css ) } /* Get challenge from LU */ - if( dvd_LUSendChallenge( p_css, p_buffer ) < 0 ) + if( ioctl_LUSendChallenge( p_css, p_buffer ) < 0 ) { intf_ErrMsg( "css error: failed getting challenge from LU" ); return -1; @@ -211,7 +212,7 @@ int CSSInit( css_t * p_css ) } /* Send key2 to LU */ - if( dvd_HostSendKey2( p_css, p_buffer ) < 0 ) + if( ioctl_HostSendKey2( p_css, p_buffer ) < 0 ) { intf_ErrMsg( "css error: failed sending key2 to LU" ); return -1; @@ -238,14 +239,15 @@ int CSSInit( css_t * p_css ) return -1; case 1: + intf_WarnMsg( 3, "css info: already authenticated" ); return 0; case 0: - intf_WarnMsg( 3, "css info: getting disc key" ); + intf_WarnMsg( 3, "css info: need to get disc key" ); } /* Get encrypted disc key */ - if( dvd_ReadKey( p_css, p_buffer ) < 0 ) + if( ioctl_ReadKey( p_css, p_buffer ) < 0 ) { intf_ErrMsg( "css error: could not read Disc Key" ); return -1; @@ -262,21 +264,22 @@ int CSSInit( css_t * p_css ) switch( CSSGetASF( p_css ) ) { case -1: - case 0: return -1; case 1: + intf_WarnMsg( 3, "css info: successfully authenticated" ); return 0; - } - return 0; + case 0: + intf_WarnMsg( 3, "css info: no way to authenticate" ); + } #else /* HAVE_CSS */ intf_ErrMsg( "css error: CSS decryption is disabled in this module" ); +#endif /* HAVE_CSS */ return -1; -#endif /* HAVE_CSS */ } /***************************************************************************** @@ -475,8 +478,10 @@ int CSSGetKey( css_t * p_css ) p_title_key[i_highest].pi_key, KEY_SIZE ); return 0; + #else /* HAVE_CSS */ return 1; + #endif /* HAVE_CSS */ } @@ -522,15 +527,16 @@ int CSSDescrambleSector( dvd_key_t pi_key, u8* pi_sec ) } return 0; + #else /* HAVE_CSS */ return 1; + #endif /* HAVE_CSS */ } #ifdef HAVE_CSS -/* - * Following functions are local - */ + +/* Following functions are local */ /***************************************************************************** * CSSGetASF : Get Authentification success flag @@ -546,7 +552,7 @@ static int CSSGetASF( css_t *p_css ) for( p_css->i_agid = 0 ; p_css->i_agid < 4 ; p_css->i_agid++ ) { - if( dvd_LUSendASF( p_css, &i_asf ) == 0 ) + if( ioctl_LUSendASF( p_css, &i_asf ) == 0 ) { intf_WarnMsg( 3, "css info: %sauthenticated", i_asf ? "":"not " ); @@ -898,5 +904,6 @@ static int CSSCracker( int i_start, return i_exit; } + #endif /* HAVE_CSS */ diff --git a/plugins/dvd/dvd_ifo.h b/plugins/dvd/dvd_ifo.h index 8e99052364921586ee1be2702bd3c9286daac6dc..a0b1a60ee30da326838abb8963cb40b510708315 100644 --- a/plugins/dvd/dvd_ifo.h +++ b/plugins/dvd/dvd_ifo.h @@ -2,7 +2,7 @@ * dvd_ifo.h: Structures for ifo parsing ***************************************************************************** * Copyright (C) 1999-2001 VideoLAN - * $Id: dvd_ifo.h,v 1.9 2001/04/01 07:31:38 stef Exp $ + * $Id: dvd_ifo.h,v 1.10 2001/04/04 02:49:18 sam Exp $ * * Author: Stéphane Borel * @@ -86,8 +86,8 @@ typedef struct command_desc_s u8 i_sub_cmd :4; union { - u8 pi_8[6]; - u16 pi_16[3]; + u8 pi_8[6]; + u16 pi_16[3]; } data; } command_desc_t; diff --git a/plugins/dvd/dvd_ioctl.c b/plugins/dvd/dvd_ioctl.c index b2b035529ef8f983239ee43951a76e72afc07bf9..bec44ae1615db83cdedc03d897c6fc27e2245362 100644 --- a/plugins/dvd/dvd_ioctl.c +++ b/plugins/dvd/dvd_ioctl.c @@ -2,7 +2,7 @@ * dvd_ioctl.c: DVD ioctl replacement function ***************************************************************************** * Copyright (C) 1999-2001 VideoLAN - * $Id: dvd_ioctl.c,v 1.4 2001/04/02 23:30:41 sam Exp $ + * $Id: dvd_ioctl.c,v 1.5 2001/04/04 02:49:18 sam Exp $ * * Authors: Markus Kuespert * Samuel Hocevar @@ -29,6 +29,7 @@ #include #include + #ifdef HAVE_SYS_DVDIO_H # include # include @@ -44,12 +45,16 @@ #endif #ifdef SYS_DARWIN1_3 # include -# include #endif #include "common.h" + #include "intf_msg.h" +#ifdef SYS_DARWIN1_3 +# include "DVDioctl/DVDioctl.h" +#endif + #include "dvd_css.h" #include "dvd_ioctl.h" @@ -57,129 +62,117 @@ * Local prototypes - BeOS specific *****************************************************************************/ #if defined( SYS_BEOS ) -static void InitCommand ( struct cdrom_generic_command *p_cgc, - void *buf, int i_len, int i_type ); -static int SendCommand ( int i_fd, struct cdrom_generic_command *p_cgc ); +static void BeInitRDC ( raw_device_command *, void *, int ); #endif /***************************************************************************** - * dvd_ReadKey: - ***************************************************************************** - * + * ioctl_ReadCopyright: check whether the disc is encrypted or not *****************************************************************************/ -int dvd_ReadKey( css_t *p_css, u8 *p_key ) +int ioctl_ReadCopyright( int i_fd, int i_layer, int *pi_copyright ) { -#if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) int i_ret; - dvd_struct dvd; - - dvd.type = DVD_STRUCT_DISCKEY; - dvd.disckey.agid = p_css->i_agid; - memset( dvd.disckey.value, 0, 2048 ); +#if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) + dvd_struct dvd; - i_ret = ioctl( p_css->i_fd, DVD_READ_STRUCT, &dvd ); + dvd.type = DVD_STRUCT_COPYRIGHT; + dvd.copyright.layer_num = i_layer; - if( i_ret < 0 ) - { - return i_ret; - } + i_ret = ioctl( i_fd, DVD_READ_STRUCT, &dvd ); - memcpy( p_key, dvd.disckey.value, 2048 ); - return i_ret; + *pi_copyright = dvd.copyright.cpst; #elif defined( SYS_BEOS ) - int i_ret, size; - u8 p_buf[ 2048 + 4]; - struct cdrom_generic_command cgc; + raw_device_command rdc; + u8 p_buffer[ 8 ]; - size = 2048 + 4; + BeInitRDC( &rdc, p_buffer, 8 ); - InitCommand( &cgc, p_buf, size, CGC_DATA_READ ); + rdc.flags = B_RAW_DEVICE_DATA_IN; + rdc.command[ 0 ] = GPCMD_READ_DVD_STRUCTURE; + rdc.command[ 6 ] = i_layer; + rdc.command[ 7 ] = DVD_STRUCT_COPYRIGHT; - cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE; + i_ret = ioctl( i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); - cgc.cmd[7] = DVD_STRUCT_DISCKEY; - cgc.cmd[8] = size >> 8; - cgc.cmd[9] = size & 0xff; - cgc.cmd[10] = p_css->i_agid << 6; + *pi_copyright = p_buffer[ 4 ]; - i_ret = SendCommand( p_css->i_fd, &cgc ); +#elif defined( SYS_DARWIN1_3 ) + intf_ErrMsg( "css error: DVD ioctls not fully functional yet" ); - if( i_ret < 0 ) - { - return i_ret; - } + intf_ErrMsg( "css error: assuming disc is unencrypted" ); + *pi_copyright = 0; - memcpy( p_key, p_buf + 4, 2048 ); - return i_ret; + i_ret = 0; #else - return -1; + /* DVD ioctls unavailable - do as if the ioctl failed */ + i_ret = -1; #endif + return i_ret; } /***************************************************************************** - * dvd_ReadCopyright: - ***************************************************************************** - * + * ioctl_ReadKey: get the disc key *****************************************************************************/ -int dvd_ReadCopyright( int i_fd, int i_layer, int *pi_copyright ) +int ioctl_ReadKey( css_t *p_css, u8 *p_key ) { -#if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) int i_ret; - dvd_struct dvd; - dvd.type = DVD_STRUCT_COPYRIGHT; - dvd.copyright.layer_num = i_layer; +#if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) + dvd_struct dvd; - i_ret = ioctl( i_fd, DVD_READ_STRUCT, &dvd ); + dvd.type = DVD_STRUCT_DISCKEY; + dvd.disckey.agid = p_css->i_agid; - *pi_copyright = dvd.copyright.cpst; - return i_ret; + memset( dvd.disckey.value, 0, 2048 ); -#elif defined( SYS_BEOS ) - int i_ret; - u8 p_buf[8]; - struct cdrom_generic_command cgc; + i_ret = ioctl( p_css->i_fd, DVD_READ_STRUCT, &dvd ); - InitCommand( &cgc, p_buf, sizeof(p_buf), CGC_DATA_READ ); + if( i_ret < 0 ) + { + return i_ret; + } - cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE; + memcpy( p_key, dvd.disckey.value, 2048 ); - cgc.cmd[6] = i_layer; - cgc.cmd[7] = DVD_STRUCT_COPYRIGHT; - cgc.cmd[8] = cgc.buflen >> 8; - cgc.cmd[9] = cgc.buflen & 0xff; +#elif defined( SYS_BEOS ) + raw_device_command rdc; + u8 p_buffer[ 2048 + 4 ]; - i_ret = SendCommand( i_fd, &cgc ); + BeInitRDC( &rdc, p_buffer, 2048 + 4 ); - *pi_copyright = p_buf[4]; - return i_ret; + rdc.flags = B_RAW_DEVICE_DATA_IN; + rdc.command[ 0 ] = GPCMD_READ_DVD_STRUCTURE; + rdc.command[ 7 ] = DVD_STRUCT_DISCKEY; + rdc.command[ 10 ] = p_css->i_agid << 6; + + i_ret = ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); -#elif defined( SYS_DARWIN1_3 ) - intf_ErrMsg( "css error: DVD ioctls not fully functional yet" ); - intf_ErrMsg( "css error: assuming disc is unencrypted" ); + if( i_ret < 0 ) + { + return i_ret; + } - *pi_copyright = 0; - return 0; + memcpy( p_key, p_buffer + 4, 2048 ); #else - return -1; + /* DVD ioctls unavailable - do as if the ioctl failed */ + i_ret = -1; #endif + return i_ret; } /***************************************************************************** - * dvd_LUSendAgid: - ***************************************************************************** - * + * ioctl_LUSendAgid: get AGID from the drive *****************************************************************************/ -int dvd_LUSendAgid( css_t *p_css ) +int ioctl_LUSendAgid( css_t *p_css ) { -#if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) int i_ret; + +#if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) dvd_authinfo auth_info; auth_info.type = DVD_LU_SEND_AGID; @@ -188,256 +181,236 @@ int dvd_LUSendAgid( css_t *p_css ) i_ret = ioctl( p_css->i_fd, DVD_AUTH, &auth_info ); p_css->i_agid = auth_info.lsa.agid; - return i_ret; #elif defined( SYS_BEOS ) - u8 p_buf[8]; - int i_ret; - struct cdrom_generic_command cgc; - - //memset( p_buf, 0, sizeof( p_buf ) ); + raw_device_command rdc; + u8 p_buffer[ 8 ]; - InitCommand( &cgc, p_buf, 0, CGC_DATA_READ ); + BeInitRDC( &rdc, p_buffer, 8 ); - cgc.cmd[0] = GPCMD_REPORT_KEY; - cgc.cmd[10] = 0x00 | (p_css->i_agid << 6); - cgc.buflen = 8; - cgc.cmd[9] = cgc.buflen; - cgc.data_direction = CGC_DATA_READ; + rdc.flags = B_RAW_DEVICE_DATA_IN; + rdc.command[ 0 ] = GPCMD_REPORT_KEY; + rdc.command[ 10 ] = 0x00 | (p_css->i_agid << 6); - i_ret = SendCommand( p_css->i_fd, &cgc ); + i_ret = ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); - p_css->i_agid = p_buf[7] >> 6; - return i_ret; + p_css->i_agid = p_buffer[ 7 ] >> 6; #else - return -1; + /* DVD ioctls unavailable - do as if the ioctl failed */ + i_ret = -1; #endif + return i_ret; } /***************************************************************************** - * dvd_InvalidateAgid: - ***************************************************************************** - * + * ioctl_LUSendChallenge: get challenge from the drive *****************************************************************************/ -int dvd_InvalidateAgid( css_t *p_css ) +int ioctl_LUSendChallenge( css_t *p_css, u8 *p_challenge ) { -#if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) int i_ret; + +#if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) dvd_authinfo auth_info; - auth_info.type = DVD_INVALIDATE_AGID; - auth_info.lsa.agid = p_css->i_agid; + auth_info.type = DVD_LU_SEND_CHALLENGE; i_ret = ioctl( p_css->i_fd, DVD_AUTH, &auth_info ); - p_css->i_agid = auth_info.lsa.agid; - return i_ret; + memcpy( p_challenge, auth_info.lsc.chal, sizeof(dvd_challenge) ); #elif defined( SYS_BEOS ) - u8 p_buf[0]; - struct cdrom_generic_command cgc; + raw_device_command rdc; + u8 p_buffer[ 16 ]; - //memset( p_buf, 0, sizeof( p_buf ) ); + BeInitRDC( &rdc, p_buffer, 16 ); - InitCommand( &cgc, p_buf, 0, CGC_DATA_READ ); + rdc.flags = B_RAW_DEVICE_DATA_IN; + rdc.command[ 0 ] = GPCMD_REPORT_KEY; + rdc.command[ 10 ] = 0x01 | (p_css->i_agid << 6); - cgc.cmd[0] = GPCMD_REPORT_KEY; - cgc.cmd[10] = 0x3f | (p_css->i_agid << 6); - cgc.cmd[9] = cgc.buflen = 0; - cgc.data_direction = CGC_DATA_READ; + i_ret = ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); - return SendCommand( p_css->i_fd, &cgc ); + memcpy( p_challenge, p_buffer + 4, sizeof(dvd_challenge) ); #else - return -1; + /* DVD ioctls unavailable - do as if the ioctl failed */ + i_ret = -1; #endif + return i_ret; } /***************************************************************************** - * dvd_HostSendChallenge: - ***************************************************************************** - * + * ioctl_LUSendASF: get ASF from the drive *****************************************************************************/ -int dvd_HostSendChallenge( css_t *p_css, u8 *p_challenge ) +int ioctl_LUSendASF( css_t *p_css, int *pi_asf ) { + int i_ret; + #if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) dvd_authinfo auth_info; - auth_info.type = DVD_HOST_SEND_CHALLENGE; + auth_info.type = DVD_LU_SEND_ASF; + auth_info.lsasf.agid = p_css->i_agid; + auth_info.lsasf.asf = *pi_asf; - memcpy( auth_info.hsc.chal, p_challenge, sizeof(dvd_challenge) ); + i_ret = ioctl( p_css->i_fd, DVD_AUTH, &auth_info ); - return ioctl( p_css->i_fd, DVD_AUTH, &auth_info ); + *pi_asf = auth_info.lsasf.asf; #elif defined( SYS_BEOS ) - u8 p_buf[16]; - struct cdrom_generic_command cgc; + raw_device_command rdc; + u8 p_buffer[ 8 ]; - //memset( p_buf, 0, sizeof( p_buf ) ); + BeInitRDC( &rdc, p_buffer, 8 ); - InitCommand( &cgc, p_buf, 0, CGC_DATA_READ ); + rdc.flags = B_RAW_DEVICE_DATA_IN; + rdc.command[ 0 ] = GPCMD_REPORT_KEY; + rdc.command[ 10 ] = 0x05 | (p_css->i_agid << 6); - cgc.cmd[0] = GPCMD_SEND_KEY; - cgc.cmd[10] = 0x01 | (p_css->i_agid << 6); - cgc.buflen = 16; - cgc.cmd[9] = cgc.buflen; - cgc.data_direction = CGC_DATA_WRITE; + i_ret = ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); + + *pi_asf = p_buffer[ 7 ] & 1; + +#elif defined( SYS_DARWIN1_3 ) + dvdioctl_data_t data; + u8 p_buffer[ 8 ]; - p_buf[1] = 0xe; - memcpy( p_buf + 4, p_challenge, sizeof(dvd_challenge) ); + data.p_buffer = p_buffer; + data.i_lba = 0; + data.i_agid = p_css->i_agid; + data.i_keyclass = kCSS_CSS2_CPRM; + data.i_keyformat = kASF; - return SendCommand( p_css->i_fd, &cgc ); + i_ret = ioctl( p_css->i_fd, IODVD_REPORT_KEY, &data ); + + *pi_asf = p_buffer[ 7 ] & 1; #else - return -1; + /* DVD ioctls unavailable - do as if the ioctl failed */ + i_ret = -1; #endif + return i_ret; } /***************************************************************************** - * dvd_LUSendASF: - ***************************************************************************** - * + * ioctl_LUSendKey1: get the first key from the drive *****************************************************************************/ -int dvd_LUSendASF( css_t *p_css, int *pi_asf ) +int ioctl_LUSendKey1( css_t *p_css, u8 *p_key ) { -#if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) int i_ret; + +#if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) dvd_authinfo auth_info; - auth_info.type = DVD_LU_SEND_ASF; - auth_info.lsasf.agid = p_css->i_agid; - auth_info.lsasf.asf = *pi_asf; + auth_info.type = DVD_LU_SEND_KEY1; + auth_info.lsk.agid = p_css->i_agid; i_ret = ioctl( p_css->i_fd, DVD_AUTH, &auth_info ); - *pi_asf = auth_info.lsasf.asf; - return i_ret; + memcpy( p_key, auth_info.lsk.key, sizeof(dvd_key) ); #elif defined( SYS_BEOS ) - int i_ret; - u8 p_buf[8]; - struct cdrom_generic_command cgc; - - //memset( p_buf, 0, sizeof( p_buf ) ); + raw_device_command rdc; + u8 p_buffer[ 12 ]; - InitCommand( &cgc, p_buf, 0, CGC_DATA_READ ); + BeInitRDC( &rdc, p_buffer, 12 ); - cgc.cmd[0] = GPCMD_REPORT_KEY; - cgc.cmd[10] = 0x05 | (p_css->i_agid << 6); - cgc.buflen = 8; - cgc.cmd[9] = cgc.buflen; - cgc.data_direction = CGC_DATA_READ; + rdc.flags = B_RAW_DEVICE_DATA_IN; + rdc.command[ 0 ] = GPCMD_REPORT_KEY; + rdc.command[ 10 ] = 0x02 | (p_css->i_agid << 6); - i_ret = SendCommand( p_css->i_fd, &cgc ); + i_ret = ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); - *pi_asf = p_buf[7] & 1; - return i_ret; + memcpy( p_key, p_buffer + 4, sizeof(dvd_key) ); #else - return -1; + /* DVD ioctls unavailable - do as if the ioctl failed */ + i_ret = -1; #endif + return i_ret; } /***************************************************************************** - * dvd_LUSendChallenge: - ***************************************************************************** - * + * ioctl_InvalidateAgid: invalidate the current AGID *****************************************************************************/ -int dvd_LUSendChallenge( css_t *p_css, u8 *p_challenge ) +int ioctl_InvalidateAgid( css_t *p_css ) { -#if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) int i_ret; + +#if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) dvd_authinfo auth_info; - auth_info.type = DVD_LU_SEND_CHALLENGE; + auth_info.type = DVD_INVALIDATE_AGID; + auth_info.lsa.agid = p_css->i_agid; i_ret = ioctl( p_css->i_fd, DVD_AUTH, &auth_info ); - memcpy( p_challenge, auth_info.lsc.chal, sizeof(dvd_challenge) ); - return i_ret; + p_css->i_agid = auth_info.lsa.agid; #elif defined( SYS_BEOS ) - int i_ret; - u8 p_buf[16]; - struct cdrom_generic_command cgc; - - //memset( p_buf, 0, sizeof( p_buf ) ); - - InitCommand( &cgc, p_buf, 0, CGC_DATA_READ ); + raw_device_command rdc; + u8 p_buffer[ 0 ]; - cgc.cmd[0] = GPCMD_REPORT_KEY; - cgc.cmd[10] = 0x01 | (p_css->i_agid << 6); - cgc.buflen = 16; - cgc.cmd[9] = cgc.buflen; - cgc.data_direction = CGC_DATA_READ; + BeInitRDC( &rdc, p_buffer, 0 ); - i_ret = SendCommand( p_css->i_fd, &cgc ); + rdc.flags = B_RAW_DEVICE_DATA_IN; + rdc.command[ 0 ] = GPCMD_REPORT_KEY; + rdc.command[ 10 ] = 0x3f | (p_css->i_agid << 6); - memcpy( p_challenge, p_buf + 4, sizeof(dvd_challenge) ); - return i_ret; + i_ret = ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); #else - return -1; + /* DVD ioctls unavailable - do as if the ioctl failed */ + i_ret = -1; #endif + return i_ret; } /***************************************************************************** - * dvd_LUSendKey1: - ***************************************************************************** - * + * ioctl_HostSendChallenge: send challenge to the drive *****************************************************************************/ -int dvd_LUSendKey1( css_t *p_css, u8 *p_key ) +int ioctl_HostSendChallenge( css_t *p_css, u8 *p_challenge ) { #if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) - int i_ret; dvd_authinfo auth_info; - auth_info.type = DVD_LU_SEND_KEY1; - auth_info.lsk.agid = p_css->i_agid; + auth_info.type = DVD_HOST_SEND_CHALLENGE; - i_ret = ioctl( p_css->i_fd, DVD_AUTH, &auth_info ); + memcpy( auth_info.hsc.chal, p_challenge, sizeof(dvd_challenge) ); - memcpy( p_key, auth_info.lsk.key, sizeof(dvd_key) ); - return i_ret; + return ioctl( p_css->i_fd, DVD_AUTH, &auth_info ); #elif defined( SYS_BEOS ) - int i_ret; - u8 p_buf[12]; - struct cdrom_generic_command cgc; + raw_device_command rdc; + u8 p_buffer[ 16 ]; - //memset( p_buf, 0, sizeof( p_buf ) ); + BeInitRDC( &rdc, p_buffer, 16 ); - InitCommand( &cgc, p_buf, 0, CGC_DATA_READ ); + rdc.command[ 0 ] = GPCMD_SEND_KEY; + rdc.command[ 10 ] = 0x01 | (p_css->i_agid << 6); - cgc.cmd[0] = GPCMD_REPORT_KEY; - cgc.cmd[10] = 0x02 | (p_css->i_agid << 6); - cgc.buflen = 12; - cgc.cmd[9] = cgc.buflen; - cgc.data_direction = CGC_DATA_READ; + p_buffer[ 1 ] = 0xe; + memcpy( p_buffer + 4, p_challenge, sizeof(dvd_challenge) ); - i_ret = SendCommand( p_css->i_fd, &cgc ); - - memcpy( p_key, p_buf + 4, sizeof(dvd_key) ); - return i_ret; + return ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); #else + /* DVD ioctls unavailable - do as if the ioctl failed */ return -1; #endif } /***************************************************************************** - * dvd_HostSendKey2: - ***************************************************************************** - * + * ioctl_HostSendKey2: send the second key to the drive *****************************************************************************/ -int dvd_HostSendKey2( css_t *p_css, u8 *p_key ) +int ioctl_HostSendKey2( css_t *p_css, u8 *p_key ) { #if defined( HAVE_SYS_DVDIO_H ) || defined( LINUX_DVD ) dvd_authinfo auth_info; @@ -450,25 +423,21 @@ int dvd_HostSendKey2( css_t *p_css, u8 *p_key ) return ioctl( p_css->i_fd, DVD_AUTH, &auth_info ); #elif defined( SYS_BEOS ) - u8 p_buf[12]; - struct cdrom_generic_command cgc; - - //memset( p_buf, 0, sizeof( p_buf ) ); + raw_device_command rdc; + u8 p_buffer[ 12 ]; - InitCommand( &cgc, p_buf, 0, CGC_DATA_READ ); + BeInitRDC( &rdc, p_buffer, 12 ); - cgc.cmd[0] = GPCMD_SEND_KEY; - cgc.cmd[10] = 0x3 | (p_css->i_agid << 6); - cgc.buflen = 12; - cgc.cmd[9] = cgc.buflen; - cgc.data_direction = CGC_DATA_WRITE; + rdc.command[ 0 ] = GPCMD_REPORT_KEY; + rdc.command[ 10 ] = 0x3 | (p_css->i_agid << 6); - p_buf[1] = 0xa; - memcpy( p_buf + 4, p_key, sizeof(dvd_key) ); + p_buffer[ 1 ] = 0xa; + memcpy( p_buffer + 4, p_key, sizeof(dvd_key) ); - return SendCommand( p_css->i_fd, &cgc ); + return ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); #else + /* DVD ioctls unavailable - do as if the ioctl failed */ return -1; #endif @@ -478,62 +447,28 @@ int dvd_HostSendKey2( css_t *p_css, u8 *p_key ) #if defined( SYS_BEOS ) /***************************************************************************** - * InitCommand: initialize a CGC structure - ***************************************************************************** - * This function initializes a CDRom Generic Command structure for - * future use, either a read command or a write command. - *****************************************************************************/ -static void InitCommand( struct cdrom_generic_command *p_cgc, - void *p_buf, int i_len, int i_type ) -{ - memset( p_cgc, 0, sizeof( struct cdrom_generic_command ) ); - - if( p_buf != NULL ) - { - memset( p_buf, 0, i_len ); - } - - p_cgc->buffer = ( char * )p_buf; - p_cgc->buflen = i_len; - p_cgc->data_direction = i_type; - p_cgc->timeout = 255; -} - -/***************************************************************************** - * SendCommand: send a raw device command to the DVD drive. + * BeInitRDC: initialize a RDC structure for the BeOS kernel ***************************************************************************** - * This is the most important part of the ioctl emulation, the place where - * data is really sent to the DVD. + * This function initializes a BeOS raw device command structure for future + * use, either a read command or a write command. *****************************************************************************/ -static int SendCommand( int i_fd, struct cdrom_generic_command *p_cgc ) +static void BeInitRDC( raw_device_command *p_rdc, void *p_buffer, int i_len ) { - int i; + memset( p_rdc, 0, sizeof( raw_device_command ) ); + memset( p_buffer, 0, i_len ); - raw_device_command rdc; - memset( &rdc, 0, sizeof( rdc ) ); + p_rdc->command[ 8 ] = (i_len >> 8) & 0xff; + p_rdc->command[ 9 ] = i_len & 0xff; + p_rdc->command_length = 12; - /* fill out our raw device command data */ - rdc.data = p_cgc->buffer; - rdc.data_length = p_cgc->buflen; - rdc.sense_data = p_cgc->sense; - rdc.sense_data_length = 0; - rdc.timeout = 1000000; + p_rdc->data = (char *)p_buffer; + p_rdc->data_length = i_len; - if( p_cgc->data_direction == CGC_DATA_READ ) - { - intf_WarnMsg( 2, "css: data_direction == CGC_DATA_READ" ); - rdc.flags = B_RAW_DEVICE_DATA_IN; - } + p_rdc->sense_data = NULL; + p_rdc->sense_data_length = 0; - rdc.command_length = 12; - - /* FIXME: check if this _really_ should go up to [12] */ - for( i = 0 ; i < 13 ; i++ ) - { - rdc.command[i] = p_cgc->cmd[i]; - } - - return ioctl( i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); + p_rdc->timeout = 1000000; } + #endif diff --git a/plugins/dvd/dvd_ioctl.h b/plugins/dvd/dvd_ioctl.h index a6263f3d2db9d3f597814af833716e19683bedf1..77ce9ec203641c6f96014019d16e49d38500e1e5 100644 --- a/plugins/dvd/dvd_ioctl.h +++ b/plugins/dvd/dvd_ioctl.h @@ -2,13 +2,9 @@ * dvd_ioctl.h: DVD ioctl replacement function ***************************************************************************** * Copyright (C) 1999-2001 VideoLAN - * $Id: dvd_ioctl.h,v 1.4 2001/04/02 23:30:41 sam Exp $ + * $Id: dvd_ioctl.h,v 1.5 2001/04/04 02:49:18 sam Exp $ * - * Authors: David Giller - * Eberhard Moenkeberg - * David van Leeuwen - * Erik Andersen - * Jens Axboe + * Authors: Samuel Hocevar * * 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 @@ -25,753 +21,28 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. *****************************************************************************/ -int dvd_ReadCopyright ( int i_fd, int i_layer, int *pi_copyright ); +int ioctl_ReadCopyright ( int, int, int * ); +int ioctl_ReadKey ( css_t *, u8 * ); -int dvd_ReadKey ( css_t *p_css, u8 *p_key ); -int dvd_LUSendAgid ( css_t *p_css ); -int dvd_LUSendChallenge ( css_t *p_css, u8 *p_challenge ); -int dvd_LUSendKey1 ( css_t *p_css, u8 *p_key ); -int dvd_LUSendASF ( css_t *p_css, int *pi_asf ); -int dvd_InvalidateAgid ( css_t *p_css ); -int dvd_HostSendChallenge ( css_t *p_css, u8 *p_challenge ); -int dvd_HostSendKey2 ( css_t *p_css, u8 *p_key ); - -int dvd_ioctl( int i_fd, unsigned long i_op, void *p_arg ); - -/***************************************************************************** - * This is the Linux kernel's , almost verbatim. - *****************************************************************************/ - -/* - * -- - * General header file for linux CD-ROM drivers - * Copyright (C) 1992 David Giller, rafetmad@oxy.edu - * 1994, 1995 Eberhard Moenkeberg, emoenke@gwdg.de - * 1996 David van Leeuwen, david@tm.tno.nl - * 1997, 1998 Erik Andersen, andersee@debian.org - * 1998-2000 Jens Axboe, axboe@suse.de - */ - -#ifndef _LINUX_CDROM_H -#define _LINUX_CDROM_H +int ioctl_LUSendAgid ( css_t * ); +int ioctl_LUSendChallenge ( css_t *, u8 * ); +int ioctl_LUSendKey1 ( css_t *, u8 * ); +int ioctl_LUSendASF ( css_t *, int * ); +int ioctl_InvalidateAgid ( css_t * ); +int ioctl_HostSendChallenge ( css_t *, u8 * ); +int ioctl_HostSendKey2 ( css_t *, u8 * ); #ifdef SYS_BEOS -# include -#elif defined(SYS_LINUX) -# include -#endif - -/******************************************************* - * As of Linux 2.1.x, all Linux CD-ROM application programs will use this - * (and only this) include file. It is my hope to provide Linux with - * a uniform interface between software accessing CD-ROMs and the various - * device drivers that actually talk to the drives. There may still be - * 23 different kinds of strange CD-ROM drives, but at least there will - * now be one, and only one, Linux CD-ROM interface. - * - * Additionally, as of Linux 2.1.x, all Linux application programs - * should use the O_NONBLOCK option when opening a CD-ROM device - * for subsequent ioctl commands. This allows for neat system errors - * like "No medium found" or "Wrong medium type" upon attempting to - * mount or play an empty slot, mount an audio disc, or play a data disc. - * Generally, changing an application program to support O_NONBLOCK - * is as easy as the following: - * - drive = open("/dev/cdrom", O_RDONLY); - * + drive = open("/dev/cdrom", O_RDONLY | O_NONBLOCK); - * It is worth the small change. - * - * Patches for many common CD programs (provided by David A. van Leeuwen) - * can be found at: ftp://ftp.gwdg.de/pub/linux/cdrom/drivers/cm206/ - * - *******************************************************/ - -/* When a driver supports a certain function, but the cdrom drive we are - * using doesn't, we will return the error EDRIVE_CANT_DO_THIS. We will - * borrow the "Operation not supported" error from the network folks to - * accomplish this. Maybe someday we will get a more targeted error code, - * but this will do for now... */ -#define EDRIVE_CANT_DO_THIS EOPNOTSUPP - -/******************************************************* - * The CD-ROM IOCTL commands -- these should be supported by - * all the various cdrom drivers. For the CD-ROM ioctls, we - * will commandeer byte 0x53, or 'S'. - *******************************************************/ -#define CDROMPAUSE 0x5301 /* Pause Audio Operation */ -#define CDROMRESUME 0x5302 /* Resume paused Audio Operation */ -#define CDROMPLAYMSF 0x5303 /* Play Audio MSF (struct cdrom_msf) */ -#define CDROMPLAYTRKIND 0x5304 /* Play Audio Track/index - (struct cdrom_ti) */ -#define CDROMREADTOCHDR 0x5305 /* Read TOC header - (struct cdrom_tochdr) */ -#define CDROMREADTOCENTRY 0x5306 /* Read TOC entry - (struct cdrom_tocentry) */ -#define CDROMSTOP 0x5307 /* Stop the cdrom drive */ -#define CDROMSTART 0x5308 /* Start the cdrom drive */ -#define CDROMEJECT 0x5309 /* Ejects the cdrom media */ -#define CDROMVOLCTRL 0x530a /* Control output volume - (struct cdrom_volctrl) */ -#define CDROMSUBCHNL 0x530b /* Read subchannel data - (struct cdrom_subchnl) */ -#define CDROMREADMODE2 0x530c /* Read CDROM mode 2 data (2336 Bytes) - (struct cdrom_read) */ -#define CDROMREADMODE1 0x530d /* Read CDROM mode 1 data (2048 Bytes) - (struct cdrom_read) */ -#define CDROMREADAUDIO 0x530e /* (struct cdrom_read_audio) */ -#define CDROMEJECT_SW 0x530f /* enable(1)/disable(0) auto-ejecting */ -#define CDROMMULTISESSION 0x5310 /* Obtain the start-of-last-session - address of multi session disks - (struct cdrom_multisession) */ -#define CDROM_GET_MCN 0x5311 /* Obtain the "Universal Product Code" - if available (struct cdrom_mcn) */ -#define CDROM_GET_UPC CDROM_GET_MCN /* This one is depricated, - but here anyway for compatability */ -#define CDROMRESET 0x5312 /* hard-reset the drive */ -#define CDROMVOLREAD 0x5313 /* Get the drive's volume setting - (struct cdrom_volctrl) */ -#define CDROMREADRAW 0x5314 /* read data in raw mode (2352 Bytes) - (struct cdrom_read) */ -/* - * These ioctls are used only used in aztcd.c and optcd.c - */ -#define CDROMREADCOOKED 0x5315 /* read data in cooked mode */ -#define CDROMSEEK 0x5316 /* seek msf address */ - -/* - * This ioctl is only used by the scsi-cd driver. - It is for playing audio in logical block addressing mode. - */ -#define CDROMPLAYBLK 0x5317 /* (struct cdrom_blk) */ - -/* - * These ioctls are only used in optcd.c - */ -#define CDROMREADALL 0x5318 /* read all 2646 bytes */ - -/* - * These ioctls are (now) only in ide-cd.c for controlling - * drive spindown time. They should be implemented in the - * Uniform driver, via generic packet commands, GPCMD_MODE_SELECT_10, - * GPCMD_MODE_SENSE_10 and the GPMODE_POWER_PAGE... - * -Erik - */ -#define CDROMGETSPINDOWN 0x531d -#define CDROMSETSPINDOWN 0x531e - -/* - * These ioctls are implemented through the uniform CD-ROM driver - * They _will_ be adopted by all CD-ROM drivers, when all the CD-ROM - * drivers are eventually ported to the uniform CD-ROM driver interface. - */ -#define CDROMCLOSETRAY 0x5319 /* pendant of CDROMEJECT */ -#define CDROM_SET_OPTIONS 0x5320 /* Set behavior options */ -#define CDROM_CLEAR_OPTIONS 0x5321 /* Clear behavior options */ -#define CDROM_SELECT_SPEED 0x5322 /* Set the CD-ROM speed */ -#define CDROM_SELECT_DISC 0x5323 /* Select disc (for juke-boxes) */ -#define CDROM_MEDIA_CHANGED 0x5325 /* Check is media changed */ -#define CDROM_DRIVE_STATUS 0x5326 /* Get tray position, etc. */ -#define CDROM_DISC_STATUS 0x5327 /* Get disc type, etc. */ -#define CDROM_CHANGER_NSLOTS 0x5328 /* Get number of slots */ -#define CDROM_LOCKDOOR 0x5329 /* lock or unlock door */ -#define CDROM_DEBUG 0x5330 /* Turn debug messages on/off */ -#define CDROM_GET_CAPABILITY 0x5331 /* get capabilities */ - -/* This ioctl is only used by sbpcd at the moment */ -#define CDROMAUDIOBUFSIZ 0x5382 /* set the audio buffer size */ - -/* DVD-ROM Specific ioctls */ -#define DVD_READ_STRUCT 0x5390 /* Read structure */ -#define DVD_WRITE_STRUCT 0x5391 /* Write structure */ -#define DVD_AUTH 0x5392 /* Authentication */ - -#define CDROM_SEND_PACKET 0x5393 /* send a packet to the drive */ -#define CDROM_NEXT_WRITABLE 0x5394 /* get next writable block */ -#define CDROM_LAST_WRITTEN 0x5395 /* get last block written on disc */ - -/******************************************************* - * CDROM IOCTL structures - *******************************************************/ - -/* Address in MSF format */ -struct cdrom_msf0 -{ - unsigned char minute; - unsigned char second; - unsigned char frame; -}; - -/* Address in either MSF or logical format */ -union cdrom_addr -{ - struct cdrom_msf0 msf; - int lba; -}; - -/* This struct is used by the CDROMPLAYMSF ioctl */ -struct cdrom_msf -{ - unsigned char cdmsf_min0; /* start minute */ - unsigned char cdmsf_sec0; /* start second */ - unsigned char cdmsf_frame0; /* start frame */ - unsigned char cdmsf_min1; /* end minute */ - unsigned char cdmsf_sec1; /* end second */ - unsigned char cdmsf_frame1; /* end frame */ -}; - -/* This struct is used by the CDROMPLAYTRKIND ioctl */ -struct cdrom_ti -{ - unsigned char cdti_trk0; /* start track */ - unsigned char cdti_ind0; /* start index */ - unsigned char cdti_trk1; /* end track */ - unsigned char cdti_ind1; /* end index */ -}; - -/* This struct is used by the CDROMREADTOCHDR ioctl */ -struct cdrom_tochdr -{ - unsigned char cdth_trk0; /* start track */ - unsigned char cdth_trk1; /* end track */ -}; - -/* This struct is used by the CDROMVOLCTRL and CDROMVOLREAD ioctls */ -struct cdrom_volctrl -{ - unsigned char channel0; - unsigned char channel1; - unsigned char channel2; - unsigned char channel3; -}; - -/* This struct is used by the CDROMSUBCHNL ioctl */ -struct cdrom_subchnl -{ - unsigned char cdsc_format; - unsigned char cdsc_audiostatus; - unsigned char cdsc_adr: 4; - unsigned char cdsc_ctrl: 4; - unsigned char cdsc_trk; - unsigned char cdsc_ind; - union cdrom_addr cdsc_absaddr; - union cdrom_addr cdsc_reladdr; -}; - - -/* This struct is used by the CDROMREADTOCENTRY ioctl */ -struct cdrom_tocentry -{ - unsigned char cdte_track; - unsigned char cdte_adr :4; - unsigned char cdte_ctrl :4; - unsigned char cdte_format; - union cdrom_addr cdte_addr; - unsigned char cdte_datamode; -}; - -/* This struct is used by the CDROMREADMODE1, and CDROMREADMODE2 ioctls */ -struct cdrom_read -{ - int cdread_lba; - char *cdread_bufaddr; - int cdread_buflen; -}; - -/* This struct is used by the CDROMREADAUDIO ioctl */ -struct cdrom_read_audio -{ - union cdrom_addr addr; /* frame address */ - unsigned char addr_format; /* CDROM_LBA or CDROM_MSF */ - int nframes; /* number of 2352-byte-frames to read at once */ - unsigned char *buf; /* frame buffer (size: nframes*2352 bytes) */ -}; - -/* This struct is used with the CDROMMULTISESSION ioctl */ -struct cdrom_multisession -{ - union cdrom_addr addr; /* frame address: start-of-last-session - (not the new "frame 16"!). Only valid - if the "xa_flag" is true. */ - unsigned char xa_flag; /* 1: "is XA disk" */ - unsigned char addr_format; /* CDROM_LBA or CDROM_MSF */ -}; - -/* This struct is used with the CDROM_GET_MCN ioctl. - * Very few audio discs actually have Universal Product Code information, - * which should just be the Medium Catalog Number on the box. Also note - * that the way the codeis written on CD is _not_ uniform across all discs! - */ -struct cdrom_mcn -{ - unsigned char medium_catalog_number[14]; /* 13 ASCII digits, null-terminated */ -}; - -/* This is used by the CDROMPLAYBLK ioctl */ -struct cdrom_blk -{ - unsigned from; - unsigned short len; -}; - -#define CDROM_PACKET_SIZE 12 - -#define CGC_DATA_UNKNOWN 0 -#define CGC_DATA_WRITE 1 -#define CGC_DATA_READ 2 -#define CGC_DATA_NONE 3 - -/* for CDROM_PACKET_COMMAND ioctl */ -struct cdrom_generic_command -{ - unsigned char cmd[CDROM_PACKET_SIZE]; - unsigned char *buffer; - unsigned int buflen; - int stat; - struct request_sense *sense; - unsigned char data_direction; - int quiet; - int timeout; - void *reserved[1]; -}; - - -/* - * A CD-ROM physical sector size is 2048, 2052, 2056, 2324, 2332, 2336, - * 2340, or 2352 bytes long. - -* Sector types of the standard CD-ROM data formats: - * - * format sector type user data size (bytes) - * ----------------------------------------------------------------------------- - * 1 (Red Book) CD-DA 2352 (CD_FRAMESIZE_RAW) - * 2 (Yellow Book) Mode1 Form1 2048 (CD_FRAMESIZE) - * 3 (Yellow Book) Mode1 Form2 2336 (CD_FRAMESIZE_RAW0) - * 4 (Green Book) Mode2 Form1 2048 (CD_FRAMESIZE) - * 5 (Green Book) Mode2 Form2 2328 (2324+4 spare bytes) - * - * - * The layout of the standard CD-ROM data formats: - * ----------------------------------------------------------------------------- - * - audio (red): | audio_sample_bytes | - * | 2352 | - * - * - data (yellow, mode1): | sync - head - data - EDC - zero - ECC | - * | 12 - 4 - 2048 - 4 - 8 - 276 | - * - * - data (yellow, mode2): | sync - head - data | - * | 12 - 4 - 2336 | - * - * - XA data (green, mode2 form1): | sync - head - sub - data - EDC - ECC | - * | 12 - 4 - 8 - 2048 - 4 - 276 | - * - * - XA data (green, mode2 form2): | sync - head - sub - data - Spare | - * | 12 - 4 - 8 - 2324 - 4 | - * - */ - -/* Some generally useful CD-ROM information -- mostly based on the above */ -#define CD_MINS 74 /* max. minutes per CD, not really a limit */ -#define CD_SECS 60 /* seconds per minute */ -#define CD_FRAMES 75 /* frames per second */ -#define CD_SYNC_SIZE 12 /* 12 sync bytes per raw data frame */ -#define CD_MSF_OFFSET 150 /* MSF numbering offset of first frame */ -#define CD_CHUNK_SIZE 24 /* lowest-level "data bytes piece" */ -#define CD_NUM_OF_CHUNKS 98 /* chunks per frame */ -#define CD_FRAMESIZE_SUB 96 /* subchannel data "frame" size */ -#define CD_HEAD_SIZE 4 /* header (address) bytes per raw data frame */ -#define CD_SUBHEAD_SIZE 8 /* subheader bytes per raw XA data frame */ -#define CD_EDC_SIZE 4 /* bytes EDC per most raw data frame types */ -#define CD_ZERO_SIZE 8 /* bytes zero per yellow book mode 1 frame */ -#define CD_ECC_SIZE 276 /* bytes ECC per most raw data frame types */ -#define CD_FRAMESIZE 2048 /* bytes per frame, "cooked" mode */ -#define CD_FRAMESIZE_RAW 2352 /* bytes per frame, "raw" mode */ -#define CD_FRAMESIZE_RAWER 2646 /* The maximum possible returned bytes */ -/* most drives don't deliver everything: */ -#define CD_FRAMESIZE_RAW1 (CD_FRAMESIZE_RAW-CD_SYNC_SIZE) /*2340*/ -#define CD_FRAMESIZE_RAW0 (CD_FRAMESIZE_RAW-CD_SYNC_SIZE-CD_HEAD_SIZE) /*2336*/ - -#define CD_XA_HEAD (CD_HEAD_SIZE+CD_SUBHEAD_SIZE) /* "before data" part of raw XA frame */ -#define CD_XA_TAIL (CD_EDC_SIZE+CD_ECC_SIZE) /* "after data" part of raw XA frame */ -#define CD_XA_SYNC_HEAD (CD_SYNC_SIZE+CD_XA_HEAD) /* sync bytes + header of XA frame */ - -/* CD-ROM address types (cdrom_tocentry.cdte_format) */ -#define CDROM_LBA 0x01 /* "logical block": first frame is #0 */ -#define CDROM_MSF 0x02 /* "minute-second-frame": binary, not bcd here! */ - -/* bit to tell whether track is data or audio (cdrom_tocentry.cdte_ctrl) */ -#define CDROM_DATA_TRACK 0x04 -/* The leadout track is always 0xAA, regardless of # of tracks on disc */ -#define CDROM_LEADOUT 0xAA - -/* audio states (from SCSI-2, but seen with other drives, too) */ -#define CDROM_AUDIO_INVALID 0x00 /* audio status not supported */ -#define CDROM_AUDIO_PLAY 0x11 /* audio play operation in progress */ -#define CDROM_AUDIO_PAUSED 0x12 /* audio play operation paused */ -#define CDROM_AUDIO_COMPLETED 0x13 /* audio play successfully completed */ -#define CDROM_AUDIO_ERROR 0x14 /* audio play stopped due to error */ -#define CDROM_AUDIO_NO_STATUS 0x15 /* no current audio status to return */ - -/* capability flags used with the uniform CD-ROM driver */ -#define CDC_CLOSE_TRAY 0x1 /* caddy systems _can't_ close */ -#define CDC_OPEN_TRAY 0x2 /* but _can_ eject. */ -#define CDC_LOCK 0x4 /* disable manual eject */ -#define CDC_SELECT_SPEED 0x8 /* programmable speed */ -#define CDC_SELECT_DISC 0x10 /* select disc from juke-box */ -#define CDC_MULTI_SESSION 0x20 /* read sessions>1 */ -#define CDC_MCN 0x40 /* Medium Catalog Number */ -#define CDC_MEDIA_CHANGED 0x80 /* media changed */ -#define CDC_PLAY_AUDIO 0x100 /* audio functions */ -#define CDC_RESET 0x200 /* hard reset device */ -#define CDC_IOCTLS 0x400 /* driver has non-standard ioctls */ -#define CDC_DRIVE_STATUS 0x800 /* driver implements drive status */ -#define CDC_GENERIC_PACKET 0x1000 /* driver implements generic packets */ -#define CDC_CD_R 0x2000 /* drive is a CD-R */ -#define CDC_CD_RW 0x4000 /* drive is a CD-RW */ -#define CDC_DVD 0x8000 /* drive is a DVD */ -#define CDC_DVD_R 0x10000 /* drive can write DVD-R */ -#define CDC_DVD_RAM 0x20000 /* drive can write DVD-RAM */ - -/* drive status possibilities returned by CDROM_DRIVE_STATUS ioctl */ -#define CDS_NO_INFO 0 /* if not implemented */ -#define CDS_NO_DISC 1 -#define CDS_TRAY_OPEN 2 -#define CDS_DRIVE_NOT_READY 3 -#define CDS_DISC_OK 4 - -/* return values for the CDROM_DISC_STATUS ioctl */ -/* can also return CDS_NO_[INFO|DISC], from above */ -#define CDS_AUDIO 100 -#define CDS_DATA_1 101 -#define CDS_DATA_2 102 -#define CDS_XA_2_1 103 -#define CDS_XA_2_2 104 -#define CDS_MIXED 105 - -/* User-configurable behavior options for the uniform CD-ROM driver */ -#define CDO_AUTO_CLOSE 0x1 /* close tray on first open() */ -#define CDO_AUTO_EJECT 0x2 /* open tray on last release() */ -#define CDO_USE_FFLAGS 0x4 /* use O_NONBLOCK information on open */ -#define CDO_LOCK 0x8 /* lock tray on open files */ -#define CDO_CHECK_TYPE 0x10 /* check type on open for data */ - -/* Special codes used when specifying changer slots. */ -#define CDSL_NONE ((int) (~0U>>1)-1) -#define CDSL_CURRENT ((int) (~0U>>1)) - -/* For partition based multisession access. IDE can handle 64 partitions - * per drive - SCSI CD-ROM's use minors to differentiate between the - * various drives, so we can't do multisessions the same way there. - * Use the -o session=x option to mount on them. - */ -#define CD_PART_MAX 64 -#define CD_PART_MASK (CD_PART_MAX - 1) - -/********************************************************************* - * Generic Packet commands, MMC commands, and such - *********************************************************************/ - - /* The generic packet command opcodes for CD/DVD Logical Units, +/* The generic packet command opcodes for CD/DVD Logical Units, * From Table 57 of the SFF8090 Ver. 3 (Mt. Fuji) draft standard. */ -#define GPCMD_BLANK 0xa1 -#define GPCMD_CLOSE_TRACK 0x5b -#define GPCMD_FLUSH_CACHE 0x35 -#define GPCMD_FORMAT_UNIT 0x04 -#define GPCMD_GET_CONFIGURATION 0x46 -#define GPCMD_GET_EVENT_STATUS_NOTIFICATION 0x4a -#define GPCMD_GET_PERFORMANCE 0xac -#define GPCMD_INQUIRY 0x12 -#define GPCMD_LOAD_UNLOAD 0xa6 -#define GPCMD_MECHANISM_STATUS 0xbd -#define GPCMD_MODE_SELECT_10 0x55 -#define GPCMD_MODE_SENSE_10 0x5a -#define GPCMD_PAUSE_RESUME 0x4b -#define GPCMD_PLAY_AUDIO_10 0x45 -#define GPCMD_PLAY_AUDIO_MSF 0x47 -#define GPCMD_PLAY_AUDIO_TI 0x48 -#define GPCMD_PLAY_CD 0xbc -#define GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1e -#define GPCMD_READ_10 0x28 -#define GPCMD_READ_12 0xa8 -#define GPCMD_READ_CDVD_CAPACITY 0x25 -#define GPCMD_READ_CD 0xbe -#define GPCMD_READ_CD_MSF 0xb9 -#define GPCMD_READ_DISC_INFO 0x51 -#define GPCMD_READ_DVD_STRUCTURE 0xad -#define GPCMD_READ_FORMAT_CAPACITIES 0x23 -#define GPCMD_READ_HEADER 0x44 -#define GPCMD_READ_TRACK_RZONE_INFO 0x52 -#define GPCMD_READ_SUBCHANNEL 0x42 -#define GPCMD_READ_TOC_PMA_ATIP 0x43 -#define GPCMD_REPAIR_RZONE_TRACK 0x58 -#define GPCMD_REPORT_KEY 0xa4 -#define GPCMD_REQUEST_SENSE 0x03 -#define GPCMD_RESERVE_RZONE_TRACK 0x53 -#define GPCMD_SCAN 0xba -#define GPCMD_SEEK 0x2b -#define GPCMD_SEND_DVD_STRUCTURE 0xad -#define GPCMD_SEND_EVENT 0xa2 -#define GPCMD_SEND_KEY 0xa3 -#define GPCMD_SEND_OPC 0x54 -#define GPCMD_SET_READ_AHEAD 0xa7 -#define GPCMD_SET_STREAMING 0xb6 -#define GPCMD_START_STOP_UNIT 0x1b -#define GPCMD_STOP_PLAY_SCAN 0x4e -#define GPCMD_TEST_UNIT_READY 0x00 -#define GPCMD_VERIFY_10 0x2f -#define GPCMD_WRITE_10 0x2a -#define GPCMD_WRITE_AND_VERIFY_10 0x2e -/* This is listed as optional in ATAPI 2.6, but is (curiously) - * missing from Mt. Fuji, Table 57. It _is_ mentioned in Mt. Fuji - * Table 377 as an MMC command for SCSi devices though... Most ATAPI - * drives support it. */ -#define GPCMD_SET_SPEED 0xbb -/* This seems to be a SCSI specific CD-ROM opcode - * to play data at track/index */ -#define GPCMD_PLAYAUDIO_TI 0x48 -/* - * From MS Media Status Notification Support Specification. For - * older drives only. - */ -#define GPCMD_GET_MEDIA_STATUS 0xda - -/* Mode page codes for mode sense/set */ -#define GPMODE_R_W_ERROR_PAGE 0x01 -#define GPMODE_WRITE_PARMS_PAGE 0x05 -#define GPMODE_AUDIO_CTL_PAGE 0x0e -#define GPMODE_POWER_PAGE 0x1a -#define GPMODE_FAULT_FAIL_PAGE 0x1c -#define GPMODE_TO_PROTECT_PAGE 0x1d -#define GPMODE_CAPABILITIES_PAGE 0x2a -#define GPMODE_ALL_PAGES 0x3f -/* Not in Mt. Fuji, but in ATAPI 2.6 -- depricated now in favor - * of MODE_SENSE_POWER_PAGE */ -#define GPMODE_CDROM_PAGE 0x0d - - +#define GPCMD_READ_DVD_STRUCTURE 0xad +#define GPCMD_REPORT_KEY 0xa4 +#define GPCMD_SEND_KEY 0xa3 /* DVD struct types */ -#define DVD_STRUCT_PHYSICAL 0x00 -#define DVD_STRUCT_COPYRIGHT 0x01 -#define DVD_STRUCT_DISCKEY 0x02 -#define DVD_STRUCT_BCA 0x03 -#define DVD_STRUCT_MANUFACT 0x04 - -struct dvd_layer { - unsigned char book_version : 4; - unsigned char book_type : 4; - unsigned char min_rate : 4; - unsigned char disc_size : 4; - unsigned char layer_type : 4; - unsigned char track_path : 1; - unsigned char nlayers : 2; - unsigned char track_density : 4; - unsigned char linear_density : 4; - unsigned char bca : 1; - u32 start_sector; - u32 end_sector; - u32 end_sector_l0; -}; - -struct dvd_physical { - unsigned char type; - unsigned char layer_num; - struct dvd_layer layer[4]; -}; - -struct dvd_copyright { - unsigned char type; - - unsigned char layer_num; - unsigned char cpst; - unsigned char rmi; -}; - -struct dvd_disckey { - unsigned char type; - - unsigned agid : 2; - unsigned char value[2048]; -}; - -struct dvd_bca { - unsigned char type; - - int len; - unsigned char value[188]; -}; - -struct dvd_manufact { - unsigned char type; - - unsigned char layer_num; - int len; - unsigned char value[2048]; -}; - -typedef union { - unsigned char type; - - struct dvd_physical physical; - struct dvd_copyright copyright; - struct dvd_disckey disckey; - struct dvd_bca bca; - struct dvd_manufact manufact; -} dvd_struct; - -/* - * DVD authentication ioctl - */ - -/* Authentication states */ -#define DVD_LU_SEND_AGID 0 -#define DVD_HOST_SEND_CHALLENGE 1 -#define DVD_LU_SEND_KEY1 2 -#define DVD_LU_SEND_CHALLENGE 3 -#define DVD_HOST_SEND_KEY2 4 +#define DVD_STRUCT_COPYRIGHT 0x01 +#define DVD_STRUCT_DISCKEY 0x02 -/* Termination states */ -#define DVD_AUTH_ESTABLISHED 5 -#define DVD_AUTH_FAILURE 6 - -/* Other functions */ -#define DVD_LU_SEND_TITLE_KEY 7 -#define DVD_LU_SEND_ASF 8 -#define DVD_INVALIDATE_AGID 9 -#define DVD_LU_SEND_RPC_STATE 10 -#define DVD_HOST_SEND_RPC_STATE 11 - -/* State data */ -typedef unsigned char dvd_key[5]; /* 40-bit value, MSB is first elem. */ -typedef unsigned char dvd_challenge[10]; /* 80-bit value, MSB is first elem. */ - -struct dvd_lu_send_agid { - unsigned char type; - unsigned agid : 2; -}; - -struct dvd_host_send_challenge { - unsigned char type; - unsigned agid : 2; - - dvd_challenge chal; -}; - -struct dvd_send_key { - unsigned char type; - unsigned agid : 2; - - dvd_key key; -}; - -struct dvd_lu_send_challenge { - unsigned char type; - unsigned agid : 2; - - dvd_challenge chal; -}; - -#define DVD_CPM_NO_COPYRIGHT 0 -#define DVD_CPM_COPYRIGHTED 1 - -#define DVD_CP_SEC_NONE 0 -#define DVD_CP_SEC_EXIST 1 - -#define DVD_CGMS_UNRESTRICTED 0 -#define DVD_CGMS_SINGLE 2 -#define DVD_CGMS_RESTRICTED 3 - -struct dvd_lu_send_title_key { - unsigned char type; - unsigned agid : 2; - - dvd_key title_key; - int lba; - unsigned cpm : 1; - unsigned cp_sec : 1; - unsigned cgms : 2; -}; - -struct dvd_lu_send_asf { - unsigned char type; - unsigned agid : 2; - - unsigned asf : 1; -}; - -struct dvd_host_send_rpcstate { - unsigned char type; - unsigned char pdrc; -}; - -struct dvd_lu_send_rpcstate { - unsigned char type : 2; - unsigned char vra : 3; - unsigned char ucca : 3; - unsigned char region_mask; - unsigned char rpc_scheme; -}; - -typedef union { - unsigned char type; - - struct dvd_lu_send_agid lsa; - struct dvd_host_send_challenge hsc; - struct dvd_send_key lsk; - struct dvd_lu_send_challenge lsc; - struct dvd_send_key hsk; - struct dvd_lu_send_title_key lstk; - struct dvd_lu_send_asf lsasf; - struct dvd_host_send_rpcstate hrpcs; - struct dvd_lu_send_rpcstate lrpcs; -} dvd_authinfo; - -struct request_sense { -#if defined(__BIG_ENDIAN_BITFIELD) - unsigned char valid : 1; - unsigned char error_code : 7; -#elif defined(__LITTLE_ENDIAN_BITFIELD) - unsigned char error_code : 7; - unsigned char valid : 1; -#endif - unsigned char segment_number; -#if defined(__BIG_ENDIAN_BITFIELD) - unsigned char reserved1 : 2; - unsigned char ili : 1; - unsigned char reserved2 : 1; - unsigned char sense_key : 4; -#elif defined(__LITTLE_ENDIAN_BITFIELD) - unsigned char sense_key : 4; - unsigned char reserved2 : 1; - unsigned char ili : 1; - unsigned char reserved1 : 2; #endif - unsigned char information[4]; - unsigned char add_sense_len; - unsigned char command_info[4]; - unsigned char asc; - unsigned char ascq; - unsigned char fruc; - unsigned char sks[3]; - unsigned char asb[46]; -}; - -typedef struct { - u16 report_key_length; - unsigned char reserved1; - unsigned char reserved2; -#if defined(__BIG_ENDIAN_BITFIELD) - unsigned char type_code : 2; - unsigned char vra : 3; - unsigned char ucca : 3; -#elif defined(__LITTLE_ENDIAN_BITFIELD) - unsigned char ucca : 3; - unsigned char vra : 3; - unsigned char type_code : 2; -#endif - unsigned char region_mask; - unsigned char rpc_scheme; - unsigned char reserved3; -} rpc_state_t; - -#endif /* _LINUX_CDROM_H */