sdmmc-core 0.5.0

//! Card-Specific Data (`CSD`) register.

use crate::Crc7;
use crate::result::{Error, Result};

mod bl_len;
mod ccc;
mod copied;
mod dsr_imp;
mod erase_blk_en;
mod file_format;
mod file_format_grp;
pub mod mmc;
mod nsac;
mod perm_write_protect;
mod r2w_factor;
mod read_bl_partial;
mod read_blk_misalign;
mod sector_size;
mod structure;
mod tmp_write_protect;
mod tran_speed;
pub mod v1;
pub mod v2;
pub mod v3;
mod vdd_curr;
mod wp_grp_enable;
mod wp_grp_size;
mod wp_upc;
mod write_bl_len;
mod write_bl_partial;
mod write_blk_misalign;

pub use bl_len::*;
pub use ccc::*;
pub use copied::Copied;
pub use dsr_imp::DsrImplemented;
pub use erase_blk_en::EraseBlockEnable;
pub use file_format::*;
pub use file_format_grp::FileFormatGroup;
pub use mmc::{ContentProtectionApp, CsdMmc, CsdStructure as MmcCsdStructure, Ecc};
pub use nsac::*;
pub use perm_write_protect::PermanentWriteProtect;
pub use r2w_factor::WriteSpeedFactor;
pub use read_bl_partial::ReadBlockPartial;
pub use read_blk_misalign::ReadBlockMisalign;
pub use sector_size::SectorSize;
pub use structure::CsdStructure as SdCsdStructure;
pub use tmp_write_protect::TemporaryWriteProtect;
pub use tran_speed::*;
pub use v1::CsdV1;
pub use v2::CsdV2;
pub use v3::CsdV3;
pub use vdd_curr::*;
pub use wp_grp_enable::WriteProtectGroupEnable;
pub use wp_grp_size::WriteProtectGroupSize;
pub use wp_upc::WriteProtectUntilPowerCycle;
pub use write_bl_len::*;
pub use write_bl_partial::WriteBlockPartial;
pub use write_blk_misalign::WriteBlockMisalign;

/// Represents the byte length of the `CSD` register.
pub const CSD_LEN: usize = 16;

/// Represents the `CSD_STRUCTURE` field of the [Csd] register.
pub enum CsdStructure {
    /// Represents the `CSD_STRUCTURE` field in the SD Card protocol specification.
    Sd(SdCsdStructure),
    /// Represents the `CSD_STRUCTURE` field in the MMC protocol specification.
    Mmc(MmcCsdStructure),
}

impl CsdStructure {
    /// Attempts to convert the [CsdStructure] into its inner representation.
    pub const fn into_sd(self) -> Result<SdCsdStructure> {
        match self {
            Self::Sd(csd) => Ok(csd),
            _ => Err(Error::Invalid),
        }
    }

    /// Attempts to convert the [CsdStructure] into its inner representation.
    pub const fn into_mmc(self) -> Result<MmcCsdStructure> {
        match self {
            Self::Mmc(csd) => Ok(csd),
            _ => Err(Error::Invalid),
        }
    }
}

/// Represents the `TAAC` field of the [Csd] register.
pub enum Taac {
    /// Represents the `TAAC` field in the SD Card V1 protocol specification.
    V1(v1::TimeAsyncAccessCycles),
    /// Represents the `TAAC` field in the SD Card V2 protocol specification.
    V2(v2::TimeAsyncAccessCycles),
    /// Represents the `TAAC` field in the SD Card V3 protocol specification.
    V3(v3::TimeAsyncAccessCycles),
    /// Represents the `TAAC` field in the MMC protocol specification.
    Mmc(mmc::TimeAsyncAccessCycles),
}

impl Taac {
    /// Attempts to convert the [Taac] into its inner representation.
    pub const fn into_v1(self) -> Result<v1::TimeAsyncAccessCycles> {
        match self {
            Self::V1(taac) => Ok(taac),
            _ => Err(Error::Invalid),
        }
    }

    /// Attempts to convert the [Taac] into its inner representation.
    pub const fn into_v2(self) -> Result<v2::TimeAsyncAccessCycles> {
        match self {
            Self::V2(taac) => Ok(taac),
            _ => Err(Error::Invalid),
        }
    }

    /// Attempts to convert the [Taac] into its inner representation.
    pub const fn into_v3(self) -> Result<v3::TimeAsyncAccessCycles> {
        match self {
            Self::V3(taac) => Ok(taac),
            _ => Err(Error::Invalid),
        }
    }

    /// Attempts to convert the [Taac] into its inner representation.
    pub const fn into_mmc(self) -> Result<mmc::TimeAsyncAccessCycles> {
        match self {
            Self::Mmc(taac) => Ok(taac),
            _ => Err(Error::Invalid),
        }
    }
}

/// Represents the Card-Specific Data (CSD) register value returned in a `R2` response in SD mode.
#[repr(C)]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Csd {
    V1(CsdV1),
    V2(CsdV2),
    V3(CsdV3),
    Mmc(CsdMmc),
}

impl Csd {
    /// Represents the byte length of the `CSD` register.
    pub const LEN: usize = CSD_LEN;

    /// Creates a new [Csd].
    pub const fn new() -> Self {
        Self::V1(CsdV1::new())
    }

    /// Gets the byte length of the [Csd].
    pub const fn len(&self) -> usize {
        Self::LEN
    }

    /// Gets whether the [Csd] is empty: always false.
    pub const fn is_empty(&self) -> bool {
        false
    }

    /// Parses the byte slice into a [CsdV1] register variant.
    pub const fn parse_v1(val: &[u8]) -> Result<Self> {
        match CsdV1::try_from_bytes(val) {
            Ok(v) => Ok(Self::V1(v)),
            Err(err) => Err(err),
        }
    }

    /// Parses the byte slice into a [CsdV2] register variant.
    pub const fn parse_v2(val: &[u8]) -> Result<Self> {
        match CsdV2::try_from_bytes(val) {
            Ok(v) => Ok(Self::V2(v)),
            Err(err) => Err(err),
        }
    }

    /// Parses the byte slice into a [CsdV3] register variant.
    pub const fn parse_v3(val: &[u8]) -> Result<Self> {
        match CsdV3::try_from_bytes(val) {
            Ok(v) => Ok(Self::V3(v)),
            Err(err) => Err(err),
        }
    }

    /// Parses the byte slice into a [CsdMmc] register variant.
    pub const fn parse_mmc(val: &[u8]) -> Result<Self> {
        match CsdMmc::try_from_bytes(val) {
            Ok(v) => Ok(Self::Mmc(v)),
            Err(err) => Err(err),
        }
    }

    /// Attempts to convert a byte slice into a [Csd].
    pub const fn try_from_bytes(val: &[u8]) -> Result<Self> {
        match val.len() {
            len if len < Self::LEN => Err(Error::invalid_length(len, Self::LEN)),
            _ => {
                let is_mmc = matches!(
                    mmc::SpecificationVersion::try_from_inner((val[0] >> 2) & 0xf),
                    Ok(mmc::SpecificationVersion::Version4x5x),
                );

                match SdCsdStructure::from_raw(val[0]) {
                    Ok(SdCsdStructure::V1) if !is_mmc => Self::parse_v1(val),
                    Ok(SdCsdStructure::V2) if !is_mmc => Self::parse_v2(val),
                    Ok(SdCsdStructure::V3) if !is_mmc => Self::parse_v3(val),
                    _ if is_mmc => Self::parse_mmc(val),
                    _ => Err(Error::Invalid),
                }
            }
        }
    }

    /// Converts the [Csd] into a byte array.
    pub const fn bytes(&self) -> [u8; Self::LEN] {
        match self {
            Self::V1(csd) => csd.into_inner(),
            Self::V2(csd) => csd.into_inner(),
            Self::V3(csd) => csd.into_inner(),
            Self::Mmc(csd) => csd.into_inner(),
        }
    }

    /// Gets the `CSD_STRUCTURE` field of the [Csd] register.
    pub const fn csd_structure(&self) -> Result<CsdStructure> {
        match self {
            Self::V1(csd) => match csd.csd_structure() {
                Ok(c) => Ok(CsdStructure::Sd(c)),
                Err(err) => Err(err),
            },
            Self::V2(csd) => match csd.csd_structure() {
                Ok(c) => Ok(CsdStructure::Sd(c)),
                Err(err) => Err(err),
            },
            Self::V3(csd) => match csd.csd_structure() {
                Ok(c) => Ok(CsdStructure::Sd(c)),
                Err(err) => Err(err),
            },
            Self::Mmc(csd) => Ok(CsdStructure::Mmc(csd.csd_structure())),
        }
    }

    /// Gets the `TAAC` field of the [Csd] register.
    pub const fn taac(&self) -> Result<Taac> {
        match self {
            Self::V1(csd) => match csd.taac() {
                Ok(taac) => Ok(Taac::V1(taac)),
                Err(err) => Err(err),
            },
            Self::V2(csd) => match csd.taac() {
                Ok(taac) => Ok(Taac::V2(taac)),
                Err(err) => Err(err),
            },
            Self::V3(csd) => match csd.taac() {
                Ok(taac) => Ok(Taac::V3(taac)),
                Err(err) => Err(err),
            },
            Self::Mmc(csd) => match csd.taac() {
                Ok(taac) => Ok(Taac::Mmc(taac)),
                Err(err) => Err(err),
            },
        }
    }

    /// Gets the `NSAC` field of the [Csd] register.
    pub const fn nsac(&self) -> Result<NsAccessCycles> {
        match self {
            Self::V1(csd) => Ok(csd.nsac()),
            Self::V2(csd) => csd.nsac(),
            Self::V3(csd) => csd.nsac(),
            Self::Mmc(csd) => Ok(csd.nsac()),
        }
    }

    /// Gets the `TRAN_SPEED` field of the [Csd] register.
    pub const fn tran_speed(&self) -> Result<TransferSpeed> {
        match self {
            Self::V1(csd) => csd.tran_speed(),
            Self::V2(csd) => csd.tran_speed(),
            Self::V3(csd) => csd.tran_speed(),
            Self::Mmc(csd) => csd.tran_speed(),
        }
    }

    /// Gets the `CCC` field of the [Csd] register.
    pub const fn ccc(&self) -> CardCommandClass {
        match self {
            Self::V1(csd) => csd.ccc(),
            Self::V2(csd) => csd.ccc(),
            Self::V3(csd) => csd.ccc(),
            Self::Mmc(csd) => csd.ccc(),
        }
    }

    /// Gets the effective value of the `C_SIZE` field of the [Csd] register.
    ///
    /// # Note
    ///
    /// The effective size is calculated with the algorithm:
    ///
    /// ```no_build,no_run
    /// size = C_SIZE + 1
    /// ```
    pub const fn c_size(&self) -> usize {
        match self {
            Self::V1(csd) => csd.c_size().size(),
            Self::V2(csd) => csd.c_size().size(),
            Self::V3(csd) => csd.c_size().size(),
            Self::Mmc(csd) => csd.c_size().size(),
        }
    }

    /// Gets the effective value of the `C_SIZE_MULT` field of the [Csd] register.
    ///
    /// # Note
    ///
    /// The effective size is calculated with the algorithm:
    ///
    /// ```no_build,no_run
    /// mult = C_SIZE_MULT + 2
    /// ```
    ///
    /// For [CsdV2] and [CsdV3], `C_SIZE_MULT` is always `1`.
    pub const fn c_size_mult(&self) -> usize {
        match self {
            Self::V1(csd) => csd.c_size_mult().mult(),
            Self::V2(csd) => 1,
            Self::V3(csd) => 1,
            Self::Mmc(csd) => csd.c_size_mult().mult(),
        }
    }

    /// Gets the capacity of device indicated by the [Csd] register.
    pub const fn capacity(&self) -> Result<u64> {
        match self {
            Self::V1(csd) => match csd.capacity() {
                Ok(c) => Ok(c as u64),
                Err(err) => Err(err),
            },
            Self::V2(csd) => Ok(csd.capacity()),
            Self::V3(csd) => Ok(csd.capacity()),
            Self::Mmc(csd) => match csd.capacity() {
                Ok(c) => Ok(c as u64),
                Err(err) => Err(err),
            },
        }
    }

    /// Gets the `ERASE_SIZE` field of the [Csd] register.
    pub const fn erase_size(&self) -> u32 {
        match self {
            Self::V1(_) => 1,
            Self::V2(_) => 1,
            Self::V3(_) => 1,
            Self::Mmc(csd) => csd.erase_size() as u32,
        }
    }

    /// Attempts to get the `READ_BL_LEN` field for the [Csd].
    pub const fn read_bl_len(&self) -> Result<BlockLength> {
        match self {
            Self::V1(csd) => csd.read_bl_len(),
            Self::V2(csd) => csd.read_bl_len(),
            Self::V3(csd) => csd.read_bl_len(),
            Self::Mmc(csd) => csd.read_bl_len(),
        }
    }

    /// Gets the `READ_BL_PARTIAL` field for the [Csd] register.
    pub const fn read_bl_partial(&self) -> ReadBlockPartial {
        match self {
            Self::V1(csd) => csd.read_bl_partial(),
            Self::V2(csd) => csd.read_bl_partial(),
            Self::V3(csd) => csd.read_bl_partial(),
            Self::Mmc(csd) => csd.read_bl_partial(),
        }
    }

    /// Gets the `READ_BLK_MISALIGN` field for the [Csd] register.
    pub const fn read_blk_misalign(&self) -> ReadBlockMisalign {
        match self {
            Self::V1(csd) => csd.read_blk_misalign(),
            Self::V2(csd) => csd.read_blk_misalign(),
            Self::V3(csd) => csd.read_blk_misalign(),
            Self::Mmc(csd) => csd.read_blk_misalign(),
        }
    }

    /// Attempts to get the `WRITE_BL_LEN` field for the [Csd].
    pub const fn write_bl_len(&self) -> Result<BlockLength> {
        match self {
            Self::V1(csd) => csd.write_bl_len(),
            Self::V2(csd) => csd.write_bl_len(),
            Self::V3(csd) => csd.write_bl_len(),
            Self::Mmc(csd) => csd.write_bl_len(),
        }
    }

    /// Gets the `WRITE_BL_PARTIAL` field for the [Csd] register.
    pub const fn write_bl_partial(&self) -> WriteBlockPartial {
        match self {
            Self::V1(csd) => csd.write_bl_partial(),
            Self::V2(csd) => csd.write_bl_partial(),
            Self::V3(csd) => csd.write_bl_partial(),
            Self::Mmc(csd) => csd.write_bl_partial(),
        }
    }

    /// Gets the `WRITE_BLK_MISALIGN` field for the [Csd] register.
    pub const fn write_blk_misalign(&self) -> WriteBlockMisalign {
        match self {
            Self::V1(csd) => csd.write_blk_misalign(),
            Self::V2(csd) => csd.write_blk_misalign(),
            Self::V3(csd) => csd.write_blk_misalign(),
            Self::Mmc(csd) => csd.write_blk_misalign(),
        }
    }

    /// Gets the `DSR_IMP` field for the [Csd] register.
    pub const fn dsr_imp(&self) -> DsrImplemented {
        match self {
            Self::V1(csd) => csd.dsr_imp(),
            Self::V2(csd) => csd.dsr_imp(),
            Self::V3(csd) => csd.dsr_imp(),
            Self::Mmc(csd) => csd.dsr_imp(),
        }
    }

    /// Gets the `VDD_R_CURR_MIN` field for the [Csd] register.
    pub const fn vdd_r_curr_min(&self) -> Result<VddCurrentMin> {
        match self {
            Self::V1(csd) => csd.vdd_r_curr_min(),
            Self::V2(csd) => Err(Error::unimplemented()),
            Self::V3(csd) => Err(Error::unimplemented()),
            Self::Mmc(csd) => csd.vdd_r_curr_min(),
        }
    }

    /// Gets the `VDD_R_CURR_MAX` field for the [Csd] register.
    pub const fn vdd_r_curr_max(&self) -> Result<VddCurrentMax> {
        match self {
            Self::V1(csd) => csd.vdd_r_curr_max(),
            Self::V2(csd) => Err(Error::unimplemented()),
            Self::V3(csd) => Err(Error::unimplemented()),
            Self::Mmc(csd) => csd.vdd_r_curr_max(),
        }
    }

    /// Gets the `VDD_W_CURR_MIN` field for the [Csd] register.
    pub const fn vdd_w_curr_min(&self) -> Result<VddCurrentMin> {
        match self {
            Self::V1(csd) => csd.vdd_w_curr_min(),
            Self::V2(csd) => Err(Error::unimplemented()),
            Self::V3(csd) => Err(Error::unimplemented()),
            Self::Mmc(csd) => csd.vdd_w_curr_min(),
        }
    }

    /// Gets the `VDD_W_CURR_MAX` field for the [Csd] register.
    pub const fn vdd_w_curr_max(&self) -> Result<VddCurrentMax> {
        match self {
            Self::V1(csd) => csd.vdd_w_curr_max(),
            Self::V2(csd) => Err(Error::unimplemented()),
            Self::V3(csd) => Err(Error::unimplemented()),
            Self::Mmc(csd) => csd.vdd_w_curr_max(),
        }
    }

    /// Gets the `ERASE_BLK_EN` field for the [Csd] register.
    pub const fn erase_blk_en(&self) -> Result<EraseBlockEnable> {
        match self {
            Self::V1(csd) => Ok(csd.erase_blk_en()),
            Self::V2(csd) => Ok(csd.erase_blk_en()),
            Self::V3(csd) => Ok(csd.erase_blk_en()),
            Self::Mmc(csd) => Err(Error::unimplemented()),
        }
    }

    /// Gets the `SECTOR_SIZE` field for the [Csd] register.
    pub const fn sector_size(&self) -> Result<SectorSize> {
        match self {
            Self::V1(csd) => Ok(csd.sector_size()),
            Self::V2(csd) => csd.sector_size(),
            Self::V3(csd) => csd.sector_size(),
            Self::Mmc(csd) => Err(Error::unimplemented()),
        }
    }

    /// Gets the `WP_GRP_SIZE` field of the [Csd] register.
    pub const fn wp_grp_size(&self) -> usize {
        match self {
            Self::V1(csd) => csd.wp_grp_size().size(),
            Self::V2(csd) => csd.wp_grp_size().size(),
            Self::V3(csd) => csd.wp_grp_size().size(),
            Self::Mmc(csd) => csd.wp_grp_size().size(),
        }
    }

    /// Gets the `WP_GRP_ENABLE` field of the [Csd] register.
    pub const fn wp_grp_enable(&self) -> WriteProtectGroupEnable {
        match self {
            Self::V1(csd) => csd.wp_grp_enable(),
            Self::V2(csd) => csd.wp_grp_enable(),
            Self::V3(csd) => csd.wp_grp_enable(),
            Self::Mmc(csd) => csd.wp_grp_enable(),
        }
    }

    /// Gets the `DEFAULT_ECC` field of the [Csd] register.
    pub const fn default_ecc(&self) -> Result<Ecc> {
        match self {
            Self::V1(csd) => Err(Error::unimplemented()),
            Self::V2(csd) => Err(Error::unimplemented()),
            Self::V3(csd) => Err(Error::unimplemented()),
            Self::Mmc(csd) => csd.default_ecc(),
        }
    }

    /// Gets the `R2W_FACTOR` field of the [Csd] register.
    pub const fn r2w_factor(&self) -> Result<WriteSpeedFactor> {
        match self {
            Self::V1(csd) => csd.r2w_factor(),
            Self::V2(csd) => csd.r2w_factor(),
            Self::V3(csd) => csd.r2w_factor(),
            Self::Mmc(csd) => csd.r2w_factor(),
        }
    }

    /// Gets the `CONTENT_PROT_APP` field of the [Csd] register.
    pub const fn content_prot_app(&self) -> Result<ContentProtectionApp> {
        match self {
            Self::V1(csd) => Err(Error::unimplemented()),
            Self::V2(csd) => Err(Error::unimplemented()),
            Self::V3(csd) => Err(Error::unimplemented()),
            Self::Mmc(csd) => Ok(csd.content_prot_app()),
        }
    }

    /// Gets the `FILE_FORMAT_GRP` field of the [Csd] register.
    pub const fn file_format_grp(&self) -> FileFormatGroup {
        match self {
            Self::V1(csd) => csd.file_format_grp(),
            Self::V2(csd) => csd.file_format_grp(),
            Self::V3(csd) => csd.file_format_grp(),
            Self::Mmc(csd) => csd.file_format_grp(),
        }
    }

    /// Gets the `COPY` field of the [Csd] register.
    pub const fn copy(&self) -> Copied {
        match self {
            Self::V1(csd) => csd.copy(),
            Self::V2(csd) => csd.copy(),
            Self::V3(csd) => csd.copy(),
            Self::Mmc(csd) => csd.copy(),
        }
    }

    /// Gets the `PERM_WRITE_PROTECT` field of the [Csd] register.
    pub const fn perm_write_protect(&self) -> PermanentWriteProtect {
        match self {
            Self::V1(csd) => csd.perm_write_protect(),
            Self::V2(csd) => csd.perm_write_protect(),
            Self::V3(csd) => csd.perm_write_protect(),
            Self::Mmc(csd) => csd.perm_write_protect(),
        }
    }

    /// Gets the `TMP_WRITE_PROTECT` field of the [Csd] register.
    pub const fn tmp_write_protect(&self) -> TemporaryWriteProtect {
        match self {
            Self::V1(csd) => csd.tmp_write_protect(),
            Self::V2(csd) => csd.tmp_write_protect(),
            Self::V3(csd) => csd.tmp_write_protect(),
            Self::Mmc(csd) => csd.tmp_write_protect(),
        }
    }

    /// Gets the `WP_UPC` field of the [Csd] register.
    pub const fn wp_upc(&self) -> Result<WriteProtectUntilPowerCycle> {
        match self {
            Self::V1(csd) => Ok(csd.wp_upc()),
            Self::V2(csd) => Ok(csd.wp_upc()),
            Self::V3(csd) => Ok(csd.wp_upc()),
            Self::Mmc(csd) => Err(Error::unimplemented()),
        }
    }

    /// Gets the `FILE_FORMAT` field of the [Csd] register.
    pub const fn file_format(&self) -> Result<FileFormat> {
        match self {
            Self::V1(csd) => csd.file_format(),
            Self::V2(csd) => csd.file_format(),
            Self::V3(csd) => csd.file_format(),
            Self::Mmc(csd) => csd.file_format(),
        }
    }

    /// Gets the `ECC` field of the [Csd] register.
    pub const fn ecc(&self) -> Result<Ecc> {
        match self {
            Self::V1(csd) => Err(Error::unimplemented()),
            Self::V2(csd) => Err(Error::unimplemented()),
            Self::V3(csd) => Err(Error::unimplemented()),
            Self::Mmc(csd) => csd.ecc(),
        }
    }

    /// Gets the `CRC` field of the [Csd] register.
    pub const fn crc(&self) -> Crc7 {
        match self {
            Self::V1(csd) => csd.crc(),
            Self::V2(csd) => csd.crc(),
            Self::V3(csd) => csd.crc(),
            Self::Mmc(csd) => csd.crc(),
        }
    }
}

impl Default for Csd {
    fn default() -> Self {
        Self::new()
    }
}

impl TryFrom<&[u8]> for Csd {
    type Error = Error;

    fn try_from(val: &[u8]) -> Result<Csd> {
        Csd::try_from_bytes(val)
    }
}

impl From<Csd> for [u8; Csd::LEN] {
    fn from(val: Csd) -> Self {
        val.bytes()
    }
}