mmc.h

Go to the documentation of this file.

/*
    $Id: mmc_8h-source.html,v 1.6 2006/10/27 11:16:41 rocky Exp $

    Copyright (C) 2003, 2004, 2005, 2006 Rocky Bernstein <rocky@cpan.org>

    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
*/

#ifndef __CDIO_MMC_H__
#define __CDIO_MMC_H__

#include <cdio/cdio.h>
#include <cdio/types.h>
#include <cdio/dvd.h>
#include <cdio/audio.h>

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

  extern uint32_t mmc_timeout_ms; 

#define MMC_TIMEOUT_DEFAULT 6000

  extern uint32_t mmc_read_timeout_ms;

#define MMC_READ_TIMEOUT_DEFAULT 3*60*1000


  typedef enum {
  CDIO_MMC_GPCMD_INQUIRY                = 0x12, 
  CDIO_MMC_GPCMD_MODE_SELECT_6          = 0x15, 
  CDIO_MMC_GPCMD_MODE_SENSE_6           = 0x1a, 
  CDIO_MMC_GPCMD_START_STOP             = 0x1b, 
  CDIO_MMC_GPCMD_ALLOW_MEDIUM_REMOVAL   = 0x1e, 
  CDIO_MMC_GPCMD_READ_10                = 0x28, 
  CDIO_MMC_GPCMD_READ_SUBCHANNEL        = 0x42, 
  CDIO_MMC_GPCMD_READ_TOC               = 0x43, 
  CDIO_MMC_GPCMD_READ_HEADER            = 0x44,
  CDIO_MMC_GPCMD_PLAY_AUDIO_10          = 0x45, 
  CDIO_MMC_GPCMD_GET_CONFIGURATION      = 0x46, 
  CDIO_MMC_GPCMD_PLAY_AUDIO_MSF         = 0x47, 
  CDIO_MMC_GPCMD_PLAY_AUDIO_TI          = 0x48,
  CDIO_MMC_GPCMD_PLAY_TRACK_REL_10      = 0x49, 
  CDIO_MMC_GPCMD_GET_EVENT_STATUS       = 0x4a, 
  CDIO_MMC_GPCMD_PAUSE_RESUME           = 0x4b, 
  CDIO_MMC_GPCMD_READ_DISC_INFO         = 0x51, 
  CDIO_MMC_GPCMD_MODE_SELECT_10         = 0x55, 
  CDIO_MMC_GPCMD_MODE_SENSE_10          = 0x5a, 
  CDIO_MMC_GPCMD_PLAY_AUDIO_12          = 0xa5, 
  CDIO_MMC_GPCMD_LOAD_UNLOAD            = 0xa6, 
  CDIO_MMC_GPCMD_READ_12                = 0xa8, 
  CDIO_MMC_GPCMD_PLAY_TRACK_REL_12      = 0xa9, 
  CDIO_MMC_GPCMD_READ_DVD_STRUCTURE     = 0xad, 
  CDIO_MMC_GPCMD_READ_MSF               = 0xb9, 
  CDIO_MMC_GPCMD_SET_SPEED              = 0xbb, 
  CDIO_MMC_GPCMD_READ_CD                = 0xbe, 
  CDIO_MMC_GPCMD_CD_PLAYBACK_STATUS  = 0xc4 ,
  CDIO_MMC_GPCMD_PLAYBACK_CONTROL    = 0xc9 ,
  CDIO_MMC_GPCMD_READ_CDDA           = 0xd8 ,
  CDIO_MMC_GPCMD_READ_CDXA           = 0xdb ,
  CDIO_MMC_GPCMD_READ_ALL_SUBCODES   = 0xdf 
  } cdio_mmc_gpcmd_t;


  typedef enum {
    CDIO_MMC_READ_SUB_ST_INVALID   = 0x00, 
    CDIO_MMC_READ_SUB_ST_PLAY      = 0x11, 
    CDIO_MMC_READ_SUB_ST_PAUSED    = 0x12, 
    CDIO_MMC_READ_SUB_ST_COMPLETED = 0x13, 
    CDIO_MMC_READ_SUB_ST_ERROR     = 0x14, 
    CDIO_MMC_READ_SUB_ST_NO_STATUS = 0x15, 
  } cdio_mmc_read_sub_state_t;

  typedef enum {
    CDIO_MMC_READ_TYPE_ANY  =  0,  
    CDIO_MMC_READ_TYPE_CDDA =  1,  
    CDIO_MMC_READ_TYPE_MODE1 = 2,  
    CDIO_MMC_READ_TYPE_MODE2 = 3,  
    CDIO_MMC_READ_TYPE_M2F1 =  4,  
    CDIO_MMC_READ_TYPE_M2F2 =  5   
  } cdio_mmc_read_cd_type_t;

  typedef enum {
    CDIO_MMC_READTOC_FMT_TOC     =  0,
    CDIO_MMC_READTOC_FMT_SESSION =  1,  
    CDIO_MMC_READTOC_FMT_FULTOC  =  2,
    CDIO_MMC_READTOC_FMT_PMA     =  3,  
    CDIO_MMC_READTOC_FMT_ATIP    =  4,  
    CDIO_MMC_READTOC_FMT_CDTEXT  =  5   
  } cdio_mmc_readtoc_t;
    
  typedef enum {
    CDIO_MMC_R_W_ERROR_PAGE     = 0x01,
    CDIO_MMC_WRITE_PARMS_PAGE   = 0x05,
    CDIO_MMC_CDR_PARMS_PAGE     = 0x0d,
    CDIO_MMC_AUDIO_CTL_PAGE     = 0x0e,
    CDIO_MMC_POWER_PAGE         = 0x1a,
    CDIO_MMC_FAULT_FAIL_PAGE    = 0x1c,
    CDIO_MMC_TO_PROTECT_PAGE    = 0x1d,
    CDIO_MMC_CAPABILITIES_PAGE  = 0x2a,
    CDIO_MMC_ALL_PAGES          = 0x3f,
  } cdio_mmc_mode_page_t;
    

PRAGMA_BEGIN_PACKED
  struct mmc_audio_volume_entry_s 
  {
    uint8_t  selection; /* Only the lower 4 bits are used. */
    uint8_t  volume;
  } GNUC_PACKED;

  typedef struct mmc_audio_volume_entry_s mmc_audio_volume_entry_t;
  
  struct mmc_audio_volume_s
  {
    mmc_audio_volume_entry_t port[4];
  } GNUC_PACKED;

  typedef struct mmc_audio_volume_s mmc_audio_volume_t;
  
PRAGMA_END_PACKED
  

typedef enum {
  CDIO_MMC_GET_CONF_ALL_FEATURES     = 0,  
  CDIO_MMC_GET_CONF_CURRENT_FEATURES = 1,  
  CDIO_MMC_GET_CONF_NAMED_FEATURE    = 2   
} cdio_mmc_get_conf_t;
  

typedef enum {
  CDIO_MMC_FEATURE_PROFILE_LIST     = 0x000, 
  CDIO_MMC_FEATURE_CORE             = 0x001, 
  CDIO_MMC_FEATURE_MORPHING         = 0x002, 
  CDIO_MMC_FEATURE_REMOVABLE_MEDIUM = 0x003, 
  CDIO_MMC_FEATURE_WRITE_PROTECT    = 0x004, 
  CDIO_MMC_FEATURE_RANDOM_READABLE  = 0x010, 
  CDIO_MMC_FEATURE_MULTI_READ       = 0x01D, 
  CDIO_MMC_FEATURE_CD_READ          = 0x01E, 
  CDIO_MMC_FEATURE_DVD_READ         = 0x01F, 
  CDIO_MMC_FEATURE_RANDOM_WRITABLE  = 0x020, 
  CDIO_MMC_FEATURE_INCR_WRITE       = 0x021, 
  CDIO_MMC_FEATURE_SECTOR_ERASE     = 0x022, 
  CDIO_MMC_FEATURE_FORMATABLE       = 0x023, 
  CDIO_MMC_FEATURE_DEFECT_MGMT      = 0x024, 
  CDIO_MMC_FEATURE_WRITE_ONCE       = 0x025, 
  CDIO_MMC_FEATURE_RESTRICT_OVERW   = 0x026, 
  CDIO_MMC_FEATURE_CD_RW_CAV        = 0x027, 
  CDIO_MMC_FEATURE_MRW              = 0x028, 
  CDIO_MMC_FEATURE_ENHANCED_DEFECT  = 0x029, 
  CDIO_MMC_FEATURE_DVD_PRW          = 0x02A, 
  CDIO_MMC_FEATURE_DVD_PR           = 0x02B, 
  CDIO_MMC_FEATURE_RIGID_RES_OVERW  = 0x02C, 
  CDIO_MMC_FEATURE_CD_TAO           = 0x02D, 
  CDIO_MMC_FEATURE_CD_SAO           = 0x02E, 
  CDIO_MMC_FEATURE_DVD_R_RW_WRITE   = 0x02F, 
  CDIO_MMC_FEATURE_CD_RW_MEDIA_WRITE= 0x037, 
  CDIO_MMC_FEATURE_DVD_PR_2_LAYER   = 0x03B, 
  CDIO_MMC_FEATURE_POWER_MGMT       = 0x100, 
  CDIO_MMC_FEATURE_CDDA_EXT_PLAY    = 0x103, 
  CDIO_MMC_FEATURE_MCODE_UPGRADE    = 0x104, /* Ability for the device to 
                                                accept  new microcode via
                                                the interface */
  CDIO_MMC_FEATURE_TIME_OUT         = 0x105, 
  CDIO_MMC_FEATURE_DVD_CSS          = 0x106, 
  CDIO_MMC_FEATURE_RT_STREAMING     = 0x107, 
  CDIO_MMC_FEATURE_LU_SN            = 0x108, 
  CDIO_MMC_FEATURE_FIRMWARE_DATE    = 0x1FF, 
} cdio_mmc_feature_t;
                                
typedef enum {
  CDIO_MMC_FEATURE_PROF_NON_REMOVABLE = 0x0001, 
  CDIO_MMC_FEATURE_PROF_REMOVABLE     = 0x0002, 
  CDIO_MMC_FEATURE_PROF_MO_ERASABLE   = 0x0003, 
  CDIO_MMC_FEATURE_PROF_MO_WRITE_ONCE = 0x0004, 
  CDIO_MMC_FEATURE_PROF_AS_MO         = 0x0005, 
  CDIO_MMC_FEATURE_PROF_CD_ROM        = 0x0008, 
  CDIO_MMC_FEATURE_PROF_CD_R          = 0x0009, 
  CDIO_MMC_FEATURE_PROF_CD_RW         = 0x000A, 
  CDIO_MMC_FEATURE_PROF_DVD_ROM       = 0x0010, 
  CDIO_MMC_FEATURE_PROF_DVD_R_SEQ     = 0x0011, 
  CDIO_MMC_FEATURE_PROF_DVD_RAM       = 0x0012, 
  CDIO_MMC_FEATURE_PROF_DVD_RW_RO     = 0x0013, 
  CDIO_MMC_FEATURE_PROF_DVD_RW_SEQ    = 0x0014, 
  CDIO_MMC_FEATURE_PROF_DVD_PRW       = 0x001A, 
  CDIO_MMC_FEATURE_PROF_DVD_PR        = 0x001B, 
  CDIO_MMC_FEATURE_PROF_DDCD_ROM      = 0x0020, 
  CDIO_MMC_FEATURE_PROF_DDCD_R        = 0x0021, 
  CDIO_MMC_FEATURE_PROF_DDCD_RW       = 0x0022, 
  CDIO_MMC_FEATURE_PROF_DVD_PR2       = 0x002B, 
  CDIO_MMC_FEATURE_PROF_NON_CONFORM   = 0xFFFF, 
} cdio_mmc_feature_profile_t;
  
typedef enum {
  CDIO_MMC_FEATURE_INTERFACE_UNSPECIFIED = 0,
  CDIO_MMC_FEATURE_INTERFACE_SCSI        = 1,
  CDIO_MMC_FEATURE_INTERFACE_ATAPI       = 2,
  CDIO_MMC_FEATURE_INTERFACE_IEEE_1394   = 3,
  CDIO_MMC_FEATURE_INTERFACE_IEEE_1394A  = 4,
  CDIO_MMC_FEATURE_INTERFACE_FIBRE_CH    = 5
} cdio_mmc_feature_interface_t;
  

#define MAX_CDB_LEN 12

typedef struct mmc_cdb_s {
  uint8_t field[MAX_CDB_LEN];
} mmc_cdb_t;
  
  typedef struct mmc_feature_list_header_s {
    unsigned char length_msb;
    unsigned char length_1sb;
    unsigned char length_2sb;
    unsigned char length_lsb;
    unsigned char reserved1;
    unsigned char reserved2;
    unsigned char profile_msb;
    unsigned char profile_lsb;
  } cdio_mmc_feature_list_header_t;

  typedef enum mmc_direction_s {
    SCSI_MMC_DATA_READ,
    SCSI_MMC_DATA_WRITE
  } cdio_mmc_direction_t;
  
  typedef struct mmc_subchannel_s
  {
    uint8_t       reserved;
    uint8_t       audio_status;
    uint16_t      data_length; 
    uint8_t       format;
    uint8_t       address:      4;
    uint8_t       control:      4;
    uint8_t       track;
    uint8_t       index;
    uint8_t       abs_addr[4];
    uint8_t       rel_addr[4];
  } cdio_mmc_subchannel_t;
  
#define CDIO_MMC_SET_COMMAND(cdb, command)      \
  cdb[0] = command
  
#define CDIO_MMC_SET_READ_TYPE(cdb, sector_type) \
  cdb[1] = (sector_type << 2)
  
#define CDIO_MMC_GETPOS_LEN16(p, pos)           \
  (p[pos]<<8) + p[pos+1]
  
#define CDIO_MMC_GET_LEN16(p)                   \
  (p[0]<<8) + p[1]
  
#define CDIO_MMC_GET_LEN32(p) \
  (p[0] << 24) + (p[1] << 16) + (p[2] << 8) + p[3];
  
#define CDIO_MMC_SET_LEN16(cdb, pos, len)       \
  cdb[pos  ] = (len >>  8) & 0xff;              \
  cdb[pos+1] = (len      ) & 0xff

#define CDIO_MMC_SET_READ_LBA(cdb, lba)         \
  cdb[2] = (lba >> 24) & 0xff; \
  cdb[3] = (lba >> 16) & 0xff; \
  cdb[4] = (lba >>  8) & 0xff; \
  cdb[5] = (lba      ) & 0xff

#define CDIO_MMC_SET_START_TRACK(cdb, command) \
  cdb[6] = command

#define CDIO_MMC_SET_READ_LENGTH24(cdb, len) \
  cdb[6] = (len >> 16) & 0xff; \
  cdb[7] = (len >>  8) & 0xff; \
  cdb[8] = (len      ) & 0xff

#define CDIO_MMC_SET_READ_LENGTH16(cdb, len) \
  CDIO_MMC_SET_LEN16(cdb, 7, len)

#define CDIO_MMC_SET_READ_LENGTH8(cdb, len) \
  cdb[8] = (len      ) & 0xff

#define CDIO_MMC_MCSB_ALL_HEADERS 0xf

#define CDIO_MMC_SET_MAIN_CHANNEL_SELECTION_BITS(cdb, val) \
  cdb[9] = val << 3;

driver_return_code_t
mmc_audio_read_subchannel (CdIo_t *p_cdio, 
                           /*out*/ cdio_subchannel_t *p_subchannel);
  
  const char *mmc_audio_state2str( uint8_t i_audio_state );
  
  driver_return_code_t mmc_eject_media( const CdIo_t *p_cdio );
  
  const char *mmc_feature2str( int i_feature );
  
  const char *mmc_feature_profile2str( int i_feature_profile );
  
  uint8_t mmc_get_cmd_len(uint8_t mmc_cmd);
  
  int mmc_get_blocksize ( CdIo_t *p_cdio );
  
  driver_return_code_t mmc_close_tray( CdIo_t *p_cdio );
  
  lsn_t mmc_get_disc_last_lsn( const CdIo_t *p_cdio );
  
  discmode_t mmc_get_discmode( const CdIo_t *p_cdio );
  
  
  void mmc_get_drive_cap ( CdIo_t *p_cdio,
                           /*out*/ cdio_drive_read_cap_t  *p_read_cap,
                           /*out*/ cdio_drive_write_cap_t *p_write_cap,
                           /*out*/ cdio_drive_misc_cap_t  *p_misc_cap);
  
  typedef enum {
    CDIO_MMC_LEVEL_WEIRD,
    CDIO_MMC_LEVEL_1,
    CDIO_MMC_LEVEL_2,
    CDIO_MMC_LEVEL_3,
    CDIO_MMC_LEVEL_NONE
  } cdio_mmc_level_t;
  
  cdio_mmc_level_t mmc_get_drive_mmc_cap(CdIo_t *p_cdio);
  

  discmode_t mmc_get_dvd_struct_physical ( const CdIo_t *p_cdio, 
                                           cdio_dvd_struct_t *s);
  
  int mmc_get_event_status(const CdIo_t *p_cdio, uint8_t out_buf[2]);

  int mmc_get_tray_status ( const CdIo_t *p_cdio );

  bool mmc_get_hwinfo ( const CdIo_t *p_cdio, 
                        /* out*/ cdio_hwinfo_t *p_hw_info );
  
  
  int mmc_get_media_changed(const CdIo_t *p_cdio);
  
  char * mmc_get_mcn ( const CdIo_t *p_cdio );
  
  driver_return_code_t mmc_audio_get_volume (CdIo_t *p_cdio,  /*out*/
                                             mmc_audio_volume_t *p_volume);
  
  bool_3way_t mmc_have_interface( CdIo_t *p_cdio, 
                                  cdio_mmc_feature_interface_t e_interface );
  
  int mmc_mode_sense( CdIo_t *p_cdio, /*out*/ void *p_buf, int i_size, 
                      int page);
  
  
  int  mmc_mode_sense_10( CdIo_t *p_cdio, /*out*/ void *p_buf, int i_size, 
                          int page);
  
  int  mmc_mode_sense_6( CdIo_t *p_cdio, /*out*/ void *p_buf, int i_size, 
                         int page);
  
  driver_return_code_t
  mmc_read_cd ( const CdIo_t *p_cdio, void *p_buf, lsn_t i_lsn, 
                int expected_sector_type, bool b_digital_audio_play,
                bool b_sync, uint8_t header_codes, bool b_user_data, 
                bool b_edc_ecc, uint8_t c2_error_information, 
                uint8_t subchannel_selection, uint16_t i_blocksize, 
                uint32_t i_blocks );
  
  driver_return_code_t mmc_read_data_sectors ( CdIo_t *p_cdio, void *p_buf, 
                                               lsn_t i_lsn, 
                                               uint16_t i_blocksize,
                                               uint32_t i_blocks );
  
  driver_return_code_t mmc_read_sectors ( const CdIo_t *p_cdio, void *p_buf, 
                                          lsn_t i_lsn,  int read_sector_type, 
                                          uint32_t i_blocks);
  
  int mmc_run_cmd( const CdIo_t *p_cdio, unsigned int i_timeout_ms,
                   const mmc_cdb_t *p_cdb,
                   cdio_mmc_direction_t e_direction, unsigned int i_buf, 
                   /*in/out*/ void *p_buf );
  driver_return_code_t mmc_set_blocksize ( const CdIo_t *p_cdio, 
                                           uint16_t i_blocksize);
  
  driver_return_code_t mmc_set_drive_speed( const CdIo_t *p_cdio, 
                                            int i_drive_speed );
  
  driver_return_code_t mmc_set_speed( const CdIo_t *p_cdio, 
                                      int i_Kbs_speed );
  
  driver_return_code_t
  mmc_start_stop_media(const CdIo_t *p_cdio, bool b_eject, bool b_immediate,
                       uint8_t power_condition);

#ifdef __cplusplus
}
#endif /* __cplusplus */

extern cdio_mmc_feature_t           debug_cdio_mmc_feature;
extern cdio_mmc_feature_interface_t debug_cdio_mmc_feature_interface;
extern cdio_mmc_feature_profile_t   debug_cdio_mmc_feature_profile;
extern cdio_mmc_get_conf_t          debug_cdio_mmc_get_conf;
extern cdio_mmc_gpcmd_t             debug_cdio_mmc_gpcmd;
extern cdio_mmc_read_sub_state_t    debug_cdio_mmc_read_sub_state;
extern cdio_mmc_read_cd_type_t      debug_cdio_mmc_read_cd_type;
extern cdio_mmc_readtoc_t           debug_cdio_mmc_readtoc;
extern cdio_mmc_mode_page_t         debug_cdio_mmc_mode_page;
  
#endif /* __MMC_H__ */

/* 
 * Local variables:
 *  c-file-style: "gnu"
 *  tab-width: 8
 *  indent-tabs-mode: nil
 * End:
 */

---