mmc.h

Go to the documentation of this file.

/*
    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012
                  2016, 2019 Rocky Bernstein <rocky@gnu.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 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef CDIO_MMC_H_
#define CDIO_MMC_H_

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

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

/* On GNU/Linux see <linux/byteorder/big_endian.h> and
   <linux/byteorder/little_endian.h>
*/
#ifdef WORDS_BIGENDIAN
#  if !defined(__LITTLE_ENDIAN_BITFIELD) && !defined(__BIG_ENDIAN_BITFIELD)
#  define __MMC_BIG_ENDIAN_BITFIELD
#  endif
#else
#  if !defined(__LITTLE_ENDIAN_BITFIELD) && !defined(__BIG_ENDIAN_BITFIELD)
#  define __MMC_LITTLE_ENDIAN_BITFIELD
#  endif
#endif

    typedef struct cdio_mmc_request_sense {
#if defined(__MMC_BIG_ENDIAN_BITFIELD)
        uint8_t valid           : 1;  
        uint8_t error_code      : 7;
#else
        uint8_t error_code      : 7;
        uint8_t valid           : 1;  
#endif
        uint8_t segment_number;
#if defined(__MMC_BIG_ENDIAN_BITFIELD)
        uint8_t filemark        : 1; 
        uint8_t eom             : 1; 
        uint8_t ili             : 1; 
        uint8_t reserved1       : 1;
        uint8_t sense_key       : 4;
#else
        uint8_t sense_key       : 4;
        uint8_t reserved1       : 1;
        uint8_t ili             : 1; 
        uint8_t eom             : 1; 
        uint8_t filemark        : 1; 
#endif
        uint8_t information[4];
        uint8_t additional_sense_len; 
        uint8_t command_info[4];      
        uint8_t asc;                  
        uint8_t ascq;                 
        uint8_t fruc;                 
        uint8_t sks[3];               
        uint8_t asb[46];              
    } cdio_mmc_request_sense_t;


    typedef enum {
        CDIO_MMC_SENSE_KEY_NO_SENSE        =  0,
        CDIO_MMC_SENSE_KEY_RECOVERED_ERROR =  1,
        CDIO_MMC_SENSE_KEY_NOT_READY       =  2,
        CDIO_MMC_SENSE_KEY_MEDIUM_ERROR    =  3,
        CDIO_MMC_SENSE_KEY_HARDWARE_ERROR  =  4,
        CDIO_MMC_SENSE_KEY_ILLEGAL_REQUEST =  5,
        CDIO_MMC_SENSE_KEY_UNIT_ATTENTION  =  6,
        CDIO_MMC_SENSE_KEY_DATA_PROTECT    =  7,
        CDIO_MMC_SENSE_KEY_BLANK_CHECK     =  8,
        CDIO_MMC_SENSE_KEY_VENDOR_SPECIFIC =  9,
        CDIO_MMC_SENSE_KEY_COPY_ABORTED    = 10,
        CDIO_MMC_SENSE_KEY_ABORTED_COMMAND = 11,
        CDIO_MMC_SENSE_KEY_OBSOLETE        = 12,
    } cdio_mmc_sense_key_t;

    typedef enum {
  CDIO_MMC_GPCMD_TEST_UNIT_READY        = 0x00, 
  CDIO_MMC_GPCMD_REQUEST_SENSE          = 0x03,
  CDIO_MMC_GPCMD_FORMAT_UNIT            = 0x04,
  CDIO_MMC_GPCMD_INQUIRY                = 0x12, 
  CDIO_MMC_GPCMD_MODE_SELECT_6          = 0x15, 
  CDIO_MMC_GPCMD_MODE_SENSE_6           = 0x1a, 
  CDIO_MMC_GPCMD_START_STOP_UNIT        = 0x1b, 
  CDIO_MMC_GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL
                                        = 0x1e, 
  CDIO_MMC_GPCMD_READ_FORMAT_CAPACITIES = 0x23, 
  CDIO_MMC_GPCMD_READ_CAPACITIY         = 0x25, 
  CDIO_MMC_GPCMD_READ_10                = 0x28, 
  CDIO_MMC_GPCMD_WRITE_10               = 0x2a,
  CDIO_MMC_GPCMD_SEEK_10                = 0x2b,
  CDIO_MMC_GPCMD_ERASE_10               = 0x2c, 
  CDIO_MMC_GPCMD_WRITE_AND_VERIFY_10    = 0x2e,
  CDIO_MMC_GPCMD_VERIFY_10              = 0x2f,
  CDIO_MMC_GPCMD_SYNCHRONIZE_CACHE      = 0x35,
  CDIO_MMC_GPCMD_WRITE_BUFFER           = 0x3b,
  CDIO_MMC_GPCMD_READ_BUFFER            = 0x3c,
  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_INFORMATION  = 0x51, 
  CDIO_MMC_GPCMD_READ_TRACK_INFORMATION = 0x52, 
  CDIO_MMC_GPCMD_RESERVE_TRACK          = 0x53,
  CDIO_MMC_GPCMD_SEND_OPC_INFORMATION   = 0x54,
  CDIO_MMC_GPCMD_MODE_SELECT_10         = 0x55, 
  CDIO_MMC_GPCMD_REPAIR_TRACK           = 0x58,
  CDIO_MMC_GPCMD_MODE_SENSE_10          = 0x5a, 
  CDIO_MMC_GPCMD_CLOSE_TRACK_SESSION    = 0x5b,
  CDIO_MMC_GPCMD_READ_BUFFER_CAPACITY   = 0x5c,
  CDIO_MMC_GPCMD_SEND_CUE_SHEET         = 0x5d,

  CDIO_MMC_GPCMD_REPORT_LUNS            = 0xa0,
  CDIO_MMC_GPCMD_BLANK                  = 0xa1,
  CDIO_MMC_GPCMD_SECURITY_PROTOCOL_IN   = 0xa2,
  CDIO_MMC_GPCMD_SEND_KEY               = 0xa3,
  CDIO_MMC_GPCMD_REPORT_KEY             = 0xa4,
  CDIO_MMC_GPCMD_PLAY_AUDIO_12          = 0xa5, 
  CDIO_MMC_GPCMD_LOAD_UNLOAD            = 0xa6, 
  CDIO_MMC_GPCMD_SET_READ_AHEAD         = 0xa7,
  CDIO_MMC_GPCMD_READ_12                = 0xa8, 
  CDIO_MMC_GPCMD_PLAY_TRACK_REL_12      = 0xa9, 
  CDIO_MMC_GPCMD_WRITE_12               = 0xaa,
  CDIO_MMC_GPCMD_READ_MEDIA_SERIAL_12   = 0xab, 
  CDIO_MMC_GPCMD_GET_PERFORMANCE        = 0xac,
  CDIO_MMC_GPCMD_READ_DVD_STRUCTURE     = 0xad, 
  CDIO_MMC_GPCMD_SECURITY_PROTOCOL_OUT  = 0xb5,
  CDIO_MMC_GPCMD_SET_STREAMING          = 0xb6,
  CDIO_MMC_GPCMD_READ_MSF               = 0xb9, 
  CDIO_MMC_GPCMD_SET_SPEED              = 0xbb, 
  CDIO_MMC_GPCMD_MECHANISM_STATUS       = 0xbd,
  CDIO_MMC_GPCMD_READ_CD                = 0xbe, 
  CDIO_MMC_GPCMD_SEND_DISC_STRUCTURE    = 0xbf,
  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;

  typedef enum {
      CDIO_MMC_READ_DISC_INFO_STANDARD   = 0x0,
      CDIO_MMC_READ_DISC_INFO_TRACK      = 0x1,
      CDIO_MMC_READ_DISC_INFO_POW        = 0x2,
  } cdio_mmc_read_disc_info_datatype_t;

/* For backward compatibility. */
#define CDIO_MMC_GPCMD_READ_DISC_INFO CDIO_MMC_GPCMD_READ_DISC_INFORMATION
#define CDIO_MMC_GPCMD_READ_DISC_STRUCTURE CDIO_MMC_GPMD_READ_DVD_STRUCTURE


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_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,
    SCSI_MMC_DATA_NONE
  } cdio_mmc_direction_t;
#define SCSI_MMC_HAS_DIR_NONE 1

  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_get_volume (CdIo_t *p_cdio,  /*out*/
                                           mmc_audio_volume_t *p_volume);

    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 );

  int mmc_get_blocksize ( CdIo_t *p_cdio );

  uint8_t mmc_get_cmd_len(uint8_t mmc_cmd);

  lsn_t mmc_get_disc_last_lsn( const CdIo_t *p_cdio );

  discmode_t mmc_get_discmode( const CdIo_t *p_cdio );


  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_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);

  char * mmc_get_track_isrc(const CdIo_t *p_cdio, track_t i_track);

  uint8_t * mmc_read_cdtext (const CdIo_t *p_cdio);

  bool_3way_t mmc_have_interface(CdIo_t *p_cdio,
                                 cdio_mmc_feature_interface_t e_interface );


  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);

  driver_return_code_t
  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_run_cmd_len( const CdIo_t *p_cdio, unsigned int i_timeout_ms,
                   const mmc_cdb_t *p_cdb, unsigned int i_cdb,
                   cdio_mmc_direction_t e_direction, unsigned int i_buf,
                   /*in/out*/ void *p_buf );

  int mmc_last_cmd_sense ( const CdIo_t *p_cdio,
                           cdio_mmc_request_sense_t **pp_sense);

  driver_return_code_t mmc_set_blocksize ( const CdIo_t *p_cdio,
                                           uint16_t i_blocksize);

  const char *mmc_cmd2str(uint8_t command);



#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;

#ifndef DO_NOT_WANT_OLD_MMC_COMPATIBILITY
#define CDIO_MMC_GPCMD_START_STOP CDIO_MMC_GPCMD_START_STOP_UNIT
#define CDIO_MMC_GPCMD_ALLOW_MEDIUM_REMOVAL  \
    CDIO_MMC_GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL
#endif /*DO_NOT_WANT_PARANOIA_COMPATIBILITY*/

#endif /* CDIO_MMC_H_ */

/*
 * Local variables:
 *  c-file-style: "ruby"
 *  tab-width: 8
 *  indent-tabs-mode: nil
 * End:
 */