Add MMC/SecureDigital device support. Not yet used because of

a bad implementation of SEND_CSD and SEND_CID commands (TODO).
This commit is contained in:
2016-10-22 22:58:01 +01:00
parent 8b9d678893
commit 0c9dfaa11f
24 changed files with 3607 additions and 3 deletions

View File

@@ -1,3 +1,19 @@
2016-10-22 Natalia Portillo <claunia@claunia.com>
* OCR.cs:
* CID.cs:
* CSD.cs:
* ExtendedCSD.cs:
* VendorString.cs:
* SCR.cs:
* CID.cs:
* CSD.cs:
* OCR.cs:
* DiscImageChef.Decoders.csproj:
* VendorString.cs: Add MMC/SecureDigital device support. Not
yet used because of a bad implementation of SEND_CSD and
SEND_CID commands (TODO).
2016-10-17 Natalia Portillo <claunia@claunia.com> 2016-10-17 Natalia Portillo <claunia@claunia.com>
* CIS.cs: * CIS.cs:

View File

@@ -97,6 +97,16 @@
<Compile Include="PCMCIA\Types.cs" /> <Compile Include="PCMCIA\Types.cs" />
<Compile Include="PCMCIA\CIS.cs" /> <Compile Include="PCMCIA\CIS.cs" />
<Compile Include="PCMCIA\VendorCode.cs" /> <Compile Include="PCMCIA\VendorCode.cs" />
<Compile Include="MMC\CSD.cs" />
<Compile Include="MMC\CID.cs" />
<Compile Include="MMC\ExtendedCSD.cs" />
<Compile Include="MMC\OCR.cs" />
<Compile Include="MMC\VendorString.cs" />
<Compile Include="SecureDigital\CID.cs" />
<Compile Include="SecureDigital\CSD.cs" />
<Compile Include="SecureDigital\SCR.cs" />
<Compile Include="SecureDigital\OCR.cs" />
<Compile Include="SecureDigital\VendorString.cs" />
</ItemGroup> </ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<ItemGroup> <ItemGroup>
@@ -120,6 +130,8 @@
<Folder Include="Xbox\" /> <Folder Include="Xbox\" />
<Folder Include="SCSI\SSC\" /> <Folder Include="SCSI\SSC\" />
<Folder Include="PCMCIA\" /> <Folder Include="PCMCIA\" />
<Folder Include="MMC\" />
<Folder Include="SecureDigital\" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<EmbeddedResource Include="..\LICENSE.LGPL"> <EmbeddedResource Include="..\LICENSE.LGPL">

View File

@@ -0,0 +1,193 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : CID.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Text;
namespace DiscImageChef.Decoders.MMC
{
public class CID
{
public byte Manufacturer;
public byte DeviceType;
public byte ApplicationID;
public string ProductName;
public byte ProductRevision;
public uint ProductSerialNumber;
public byte ManufacturingDate;
public byte CRC;
}
public partial class Decoders
{
public static CID DecodeCID(uint[] response)
{
if(response == null)
return null;
if(response.Length != 4)
return null;
byte[] data = new byte[16];
byte[] tmp = new byte[4];
tmp = BitConverter.GetBytes(response[0]);
Array.Copy(tmp, 0, data, 0, 4);
tmp = BitConverter.GetBytes(response[1]);
Array.Copy(tmp, 0, data, 4, 4);
tmp = BitConverter.GetBytes(response[2]);
Array.Copy(tmp, 0, data, 8, 4);
tmp = BitConverter.GetBytes(response[3]);
Array.Copy(tmp, 0, data, 12, 4);
return DecodeCID(data);
}
public static CID DecodeCID(byte[] response)
{
if(response == null)
return null;
if(response.Length != 16)
return null;
byte[] tmp;
CID cid = new CID();
cid.Manufacturer = response[0];
cid.DeviceType = (byte)(response[1] & 0x03);
tmp = new byte[6];
Array.Copy(response, 3, tmp, 0, 6);
cid.ProductName = StringHandlers.CToString(tmp);
cid.ProductRevision = response[9];
tmp = new byte[4];
cid.ProductSerialNumber = BitConverter.ToUInt32(response, 10);
cid.ManufacturingDate = response[14];
cid.CRC = (byte)((response[15] & 0xFE) >> 1);
return cid;
}
public static string PrettifyCID(CID cid)
{
if(cid == null)
return null;
StringBuilder sb = new StringBuilder();
sb.AppendLine("MultiMediaCard Device Identification Register:");
sb.AppendFormat("\tManufacturer: {0}", VendorString.Prettify(cid.Manufacturer)).AppendLine();
switch(cid.DeviceType)
{
case 0:
sb.AppendLine("\tRemovable device");
break;
case 1:
sb.AppendLine("\tBGA device");
break;
case 2:
sb.AppendLine("\tPOP device");
break;
}
sb.AppendFormat("\tApplication ID: {0}", cid.ApplicationID).AppendLine();
sb.AppendFormat("\tProduct name: {0}", cid.ProductName).AppendLine();
sb.AppendFormat("\tProduct revision: {0:X2}.{1:X2}", (cid.ProductRevision & 0xF0) >> 4, cid.ProductRevision & 0x0F).AppendLine();
sb.AppendFormat("\tProduct serial number: {0}", cid.ProductSerialNumber).AppendLine();
string year = "";
switch(cid.ManufacturingDate & 0x0F)
{
case 0:
year = "1997 or 2013";
break;
case 1:
year = "1998 or 2014";
break;
case 2:
year = "1999 or 2015";
break;
case 3:
year = "2000 or 2016";
break;
case 4:
year = "2001 or 2017";
break;
case 5:
year = "2002 or 2018";
break;
case 6:
year = "2003 or 2019";
break;
case 7:
year = "2004 or 2020";
break;
case 8:
year = "2005 or 2021";
break;
case 9:
year = "2006 or 2022";
break;
case 10:
year = "2007 or 2023";
break;
case 11:
year = "2008 or 2024";
break;
case 12:
year = "2009 or 2025";
break;
case 13:
year = "2010";
break;
case 14:
year = "2011";
break;
case 15:
year = "2012";
break;
}
sb.AppendFormat("\tDevice manufactured month {0} of {1}", (cid.ManufacturingDate & 0xF0) >> 4, year).AppendLine();
sb.AppendFormat("\tCID CRC: 0x{0:X2}", cid.CRC).AppendLine();
return sb.ToString();
}
public static string PrettifyCID(uint[] response)
{
return PrettifyCID(DecodeCID(response));
}
public static string PrettifyCID(byte[] response)
{
return PrettifyCID(DecodeCID(response));
}
}
}

View File

@@ -0,0 +1,592 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : CSD.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Text;
namespace DiscImageChef.Decoders.MMC
{
public class CSD
{
public byte Structure;
public byte Version;
public byte TAAC;
public byte NSAC;
public byte Speed;
public ushort Classes;
public byte ReadBlockLength;
public bool ReadsPartialBlocks;
public bool WriteMisalignment;
public bool ReadMisalignment;
public bool DSRImplemented;
public ushort Size;
public byte ReadCurrentAtVddMin;
public byte ReadCurrentAtVddMax;
public byte WriteCurrentAtVddMin;
public byte WriteCurrentAtVddMax;
public byte SizeMultiplier;
public byte EraseGroupSize;
public byte EraseGroupSizeMultiplier;
public byte WriteProtectGroupSize;
public bool WriteProtectGroupEnable;
public byte DefaultECC;
public byte WriteSpeedFactor;
public byte WriteBlockLength;
public bool WritesPartialBlocks;
public bool ContentProtection;
public bool FileFormatGroup;
public bool Copy;
public bool PermanentWriteProtect;
public bool TemporaryWriteProtect;
public byte FileFormat;
public byte ECC;
public byte CRC;
}
public partial class Decoders
{
public static CSD DecodeCSD(uint[] response)
{
if(response == null)
return null;
if(response.Length != 4)
return null;
byte[] data = new byte[16];
byte[] tmp = new byte[4];
tmp = BitConverter.GetBytes(response[0]);
Array.Copy(tmp, 0, data, 0, 4);
tmp = BitConverter.GetBytes(response[1]);
Array.Copy(tmp, 0, data, 4, 4);
tmp = BitConverter.GetBytes(response[2]);
Array.Copy(tmp, 0, data, 8, 4);
tmp = BitConverter.GetBytes(response[3]);
Array.Copy(tmp, 0, data, 12, 4);
return DecodeCSD(data);
}
public static CSD DecodeCSD(byte[] response)
{
if(response == null)
return null;
if(response.Length != 16)
return null;
CSD csd = new CSD();
csd.Structure = (byte)((response[0] & 0xC0) >> 6);
csd.Version = (byte)((response[0] & 0x3C) >> 2);
csd.TAAC = response[1];
csd.NSAC = response[2];
csd.Speed = response[3];
csd.Classes = (ushort)((response[4] << 4) + ((response[5] & 0xF0) >> 4));
csd.ReadBlockLength = (byte)(response[5] & 0x0F);
csd.ReadsPartialBlocks = (response[6] & 0x80) == 0x80;
csd.WriteMisalignment = (response[6] & 0x40) == 0x40;
csd.ReadMisalignment = (response[6] & 0x20) == 0x20;
csd.DSRImplemented = (response[6] & 0x10) == 0x10;
csd.Size = (ushort)(((response[6] & 0x03) << 10) + (response[7] << 2) + ((response[8] & 0xC0) >> 6));
csd.ReadCurrentAtVddMin = (byte)((response[8] & 0x38) >> 3);
csd.ReadCurrentAtVddMax = (byte)(response[8] & 0x07);
csd.WriteCurrentAtVddMin = (byte)((response[9] & 0xE0) >> 5);
csd.WriteCurrentAtVddMax = (byte)((response[9] & 0x1C) >> 2);
csd.SizeMultiplier = (byte)(((response[9] & 0x03) << 1) + ((response[10] & 0x80) >> 7));
csd.EraseGroupSize = (byte)((response[10] & 0x7C) >> 2);
csd.EraseGroupSizeMultiplier = (byte)(((response[10] & 0x03) << 3) + ((response[11] & 0xE0) >> 5));
csd.WriteProtectGroupSize = (byte)(response[11] & 0x1F);
csd.WriteProtectGroupEnable = (response[12] & 0x80) == 0x80;
csd.DefaultECC = (byte)((response[12] & 0x60) >> 5);
csd.WriteSpeedFactor = (byte)((response[12] & 0x1C) >> 2);
csd.WriteBlockLength = (byte)(((response[12] & 0x03) << 2) + ((response[13] & 0xC0) >> 6));
csd.WritesPartialBlocks = (response[13] & 0x20) == 0x20;
csd.ContentProtection = (response[13] & 0x01) == 0x01;
csd.FileFormatGroup = (response[14] & 0x80) == 0x80;
csd.Copy = (response[14] & 0x40) == 0x40;
csd.PermanentWriteProtect = (response[14] & 0x20) == 0x20;
csd.TemporaryWriteProtect = (response[14] & 0x10) == 0x10;
csd.FileFormat = (byte)((response[14] & 0x0C) >> 2);
csd.ECC = (byte)(response[14] & 0x03);
csd.CRC = (byte)((response[15] & 0xFE) >> 1);
return csd;
}
public static string PrettifyCSD(CSD csd)
{
if(csd == null)
return null;
double unitFactor = 0;
double multiplier = 0;
double result = 0;
string unit = "";
StringBuilder sb = new StringBuilder();
sb.AppendLine("MultiMediaCard Device Specific Data Register:");
switch(csd.Structure)
{
case 0:
sb.AppendLine("\tRegister version 1.0");
break;
case 1:
sb.AppendLine("\tRegister version 1.1");
break;
case 2:
sb.AppendLine("\tRegister version 1.2");
break;
case 3:
sb.AppendLine("\tRegister version is defined in Extended Device Specific Data Register");
break;
}
switch(csd.TAAC & 0x07)
{
case 0:
unit = "ns";
unitFactor = 1;
break;
case 1:
unit = "ns";
unitFactor = 10;
break;
case 2:
unit = "ns";
unitFactor = 100;
break;
case 3:
unit = "μs";
unitFactor = 1;
break;
case 4:
unit = "μs";
unitFactor = 10;
break;
case 5:
unit = "μs";
unitFactor = 100;
break;
case 6:
unit = "ms";
unitFactor = 1;
break;
case 7:
unit = "ms";
unitFactor = 10;
break;
}
switch((csd.TAAC & 0x78) >> 3)
{
case 0:
multiplier = 0;
break;
case 1:
multiplier = 1;
break;
case 2:
multiplier = 1.2;
break;
case 3:
multiplier = 1.3;
break;
case 4:
multiplier = 1.5;
break;
case 5:
multiplier = 2;
break;
case 6:
multiplier = 2.5;
break;
case 7:
multiplier = 3;
break;
case 8:
multiplier = 3.5;
break;
case 9:
multiplier = 4;
break;
case 10:
multiplier = 4.5;
break;
case 11:
multiplier = 5;
break;
case 12:
multiplier = 5.5;
break;
case 13:
multiplier = 6;
break;
case 14:
multiplier = 7;
break;
case 15:
multiplier = 8;
break;
}
result = unitFactor * multiplier;
sb.AppendFormat("\tAsynchronous data access time is {0}{1}", result, unit).AppendLine();
sb.AppendFormat("\tClock dependent part of data access is {0} clock cycles", csd.NSAC * 100).AppendLine();
unit = "MHz";
switch(csd.Speed & 0x07)
{
case 0:
unitFactor = 0.1;
break;
case 1:
unitFactor = 1;
break;
case 2:
unitFactor = 10;
break;
case 3:
unitFactor = 100;
break;
default:
unit = "unknown";
unitFactor = 0;
break;
}
switch((csd.Speed & 0x78) >> 3)
{
case 0:
multiplier = 0;
break;
case 1:
multiplier = 1;
break;
case 2:
multiplier = 1.2;
break;
case 3:
multiplier = 1.3;
break;
case 4:
multiplier = 1.5;
break;
case 5:
multiplier = 2;
break;
case 6:
multiplier = 2.6;
break;
case 7:
multiplier = 3;
break;
case 8:
multiplier = 3.5;
break;
case 9:
multiplier = 4;
break;
case 10:
multiplier = 4.5;
break;
case 11:
multiplier = 5.2;
break;
case 12:
multiplier = 5.5;
break;
case 13:
multiplier = 6;
break;
case 14:
multiplier = 7;
break;
case 15:
multiplier = 8;
break;
}
result = unitFactor * multiplier;
sb.AppendFormat("\tDevice's clock frequency: {0}{1}", result, unit).AppendLine();
unit = "";
for(int cl = 0, mask = 1; cl <= 11; cl++, mask <<= 1)
{
if((csd.Classes & mask) == mask)
unit += string.Format(" {0}", cl);
}
sb.AppendFormat("\tDevice support command classes {0}", unit).AppendLine();
if(csd.ReadBlockLength == 15)
sb.AppendLine("\tRead block length size is defined in extended CSD");
else
sb.AppendFormat("\tRead block length is {0} bytes", Math.Pow(2, csd.ReadBlockLength)).AppendLine();
if(csd.ReadsPartialBlocks)
sb.AppendLine("\tDevice allows reading partial blocks");
if(csd.WriteMisalignment)
sb.AppendLine("\tWrite commands can cross physical block boundaries");
if(csd.ReadMisalignment)
sb.AppendLine("\tRead commands can cross physical block boundaries");
if(csd.DSRImplemented)
sb.AppendLine("\tDevice implements configurable driver stage");
if(csd.Size == 0xFFF)
sb.AppendLine("\tDevice may be bigger than 2GiB and have its real size defined in the extended CSD");
result = (csd.Size + 1) * Math.Pow(2, csd.SizeMultiplier + 2);
sb.AppendFormat("\tDevice has {0} blocks", (int)result).AppendLine();
result = (csd.Size + 1) * Math.Pow(2, csd.SizeMultiplier + 2) * Math.Pow(2, csd.ReadBlockLength);
if(result > 1073741824)
sb.AppendFormat("\tDevice has {0} GiB", result/1073741824.0);
else if(result > 1048576)
sb.AppendFormat("\tDevice has {0} MiB", result / 1048576.0);
else if(result > 1024)
sb.AppendFormat("\tDevice has {0} KiB", result / 1024.0);
else
sb.AppendFormat("\tDevice has {0} bytes", result);
switch(csd.ReadCurrentAtVddMin & 0x07)
{
case 0:
sb.AppendLine("\tDevice uses a maximum of 0.5mA for reading at minimum voltage");
break;
case 1:
sb.AppendLine("\tDevice uses a maximum of 1mA for reading at minimum voltage");
break;
case 2:
sb.AppendLine("\tDevice uses a maximum of 5mA for reading at minimum voltage");
break;
case 3:
sb.AppendLine("\tDevice uses a maximum of 10mA for reading at minimum voltage");
break;
case 4:
sb.AppendLine("\tDevice uses a maximum of 25mA for reading at minimum voltage");
break;
case 5:
sb.AppendLine("\tDevice uses a maximum of 35mA for reading at minimum voltage");
break;
case 6:
sb.AppendLine("\tDevice uses a maximum of 60mA for reading at minimum voltage");
break;
case 7:
sb.AppendLine("\tDevice uses a maximum of 100mA for reading at minimum voltage");
break;
}
switch(csd.ReadCurrentAtVddMax & 0x07)
{
case 0:
sb.AppendLine("\tDevice uses a maximum of 1mA for reading at maximum voltage");
break;
case 1:
sb.AppendLine("\tDevice uses a maximum of 5mA for reading at maximum voltage");
break;
case 2:
sb.AppendLine("\tDevice uses a maximum of 10mA for reading at maximum voltage");
break;
case 3:
sb.AppendLine("\tDevice uses a maximum of 25mA for reading at maximum voltage");
break;
case 4:
sb.AppendLine("\tDevice uses a maximum of 35mA for reading at maximum voltage");
break;
case 5:
sb.AppendLine("\tDevice uses a maximum of 45mA for reading at maximum voltage");
break;
case 6:
sb.AppendLine("\tDevice uses a maximum of 80mA for reading at maximum voltage");
break;
case 7:
sb.AppendLine("\tDevice uses a maximum of 200mA for reading at maximum voltage");
break;
}
switch(csd.WriteCurrentAtVddMin & 0x07)
{
case 0:
sb.AppendLine("\tDevice uses a maximum of 0.5mA for writing at minimum voltage");
break;
case 1:
sb.AppendLine("\tDevice uses a maximum of 1mA for writing at minimum voltage");
break;
case 2:
sb.AppendLine("\tDevice uses a maximum of 5mA for writing at minimum voltage");
break;
case 3:
sb.AppendLine("\tDevice uses a maximum of 10mA for writing at minimum voltage");
break;
case 4:
sb.AppendLine("\tDevice uses a maximum of 25mA for writing at minimum voltage");
break;
case 5:
sb.AppendLine("\tDevice uses a maximum of 35mA for writing at minimum voltage");
break;
case 6:
sb.AppendLine("\tDevice uses a maximum of 60mA for writing at minimum voltage");
break;
case 7:
sb.AppendLine("\tDevice uses a maximum of 100mA for writing at minimum voltage");
break;
}
switch(csd.WriteCurrentAtVddMax & 0x07)
{
case 0:
sb.AppendLine("\tDevice uses a maximum of 1mA for writing at maximum voltage");
break;
case 1:
sb.AppendLine("\tDevice uses a maximum of 5mA for writing at maximum voltage");
break;
case 2:
sb.AppendLine("\tDevice uses a maximum of 10mA for writing at maximum voltage");
break;
case 3:
sb.AppendLine("\tDevice uses a maximum of 25mA for writing at maximum voltage");
break;
case 4:
sb.AppendLine("\tDevice uses a maximum of 35mA for writing at maximum voltage");
break;
case 5:
sb.AppendLine("\tDevice uses a maximum of 45mA for writing at maximum voltage");
break;
case 6:
sb.AppendLine("\tDevice uses a maximum of 80mA for writing at maximum voltage");
break;
case 7:
sb.AppendLine("\tDevice uses a maximum of 200mA for writing at maximum voltage");
break;
}
unitFactor = Convert.ToDouble(string.Format("{0:X}", csd.EraseGroupSize));
multiplier = Convert.ToDouble(string.Format("{0:X}", csd.EraseGroupSizeMultiplier));
result = (unitFactor + 1) * (multiplier + 1);
sb.AppendFormat("\tDevice can erase a minimum of {0} blocks at a time", (int)result).AppendLine();
if(csd.WriteProtectGroupEnable)
{
sb.AppendLine("\tDevice can write protect regions");
unitFactor = Convert.ToDouble(string.Format("{0:X}", csd.WriteProtectGroupSize));
sb.AppendFormat("\tDevice can write protect a minimum of {0} blocks at a time", (int)(result + 1)).AppendLine();
}
else
sb.AppendLine("\tDevice can't write protect regions");
switch(csd.DefaultECC)
{
case 0:
sb.AppendLine("\tDevice uses no ECC by default");
break;
case 1:
sb.AppendLine("\tDevice uses BCH(542, 512) ECC by default");
break;
case 2:
sb.AppendFormat("\tDevice uses unknown ECC code {0} by default", csd.DefaultECC).AppendLine();
break;
}
sb.AppendFormat("\tWriting is {0} times slower than reading", Math.Pow(2, csd.WriteSpeedFactor)).AppendLine();
if(csd.WriteBlockLength == 15)
sb.AppendLine("\tWrite block length size is defined in extended CSD");
else
sb.AppendFormat("\tWrite block length is {0} bytes", Math.Pow(2, csd.WriteBlockLength)).AppendLine();
if(csd.WritesPartialBlocks)
sb.AppendLine("\tDevice allows writing partial blocks");
if(csd.ContentProtection)
sb.AppendLine("\tDevice supports content protection");
if(!csd.Copy)
sb.AppendLine("\tDevice contents are original");
if(csd.PermanentWriteProtect)
sb.AppendLine("\tDevice is permanently write protected");
if(csd.TemporaryWriteProtect)
sb.AppendLine("\tDevice is temporarily write protected");
if(!csd.FileFormatGroup)
{
switch(csd.FileFormat)
{
case 0:
sb.AppendLine("\tDevice is formatted like a hard disk");
break;
case 1:
sb.AppendLine("\tDevice is formatted like a floppy disk using Microsoft FAT");
break;
case 2:
sb.AppendLine("\tDevice uses Universal File Format");
break;
default:
sb.AppendFormat("\tDevice uses unknown file format code {0}", csd.FileFormat).AppendLine();
break;
}
}
else
sb.AppendFormat("\tDevice uses unknown file format code {0} and file format group 1", csd.FileFormat).AppendLine();
switch(csd.ECC)
{
case 0:
sb.AppendLine("\tDevice currently uses no ECC");
break;
case 1:
sb.AppendLine("\tDevice currently uses BCH(542, 512) ECC by default");
break;
case 2:
sb.AppendFormat("\tDevice currently uses unknown ECC code {0}", csd.DefaultECC).AppendLine();
break;
}
sb.AppendFormat("\tCSD CRC: 0x{0:X2}", csd.CRC).AppendLine();
return sb.ToString();
}
public static string PrettifyCSD(uint[] response)
{
return PrettifyCSD(DecodeCSD(response));
}
public static string PrettifyCSD(byte[] response)
{
return PrettifyCSD(DecodeCSD(response));
}
}
}

View File

@@ -0,0 +1,704 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : ExtendedCSD.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Runtime.InteropServices;
using System.Text;
namespace DiscImageChef.Decoders.MMC
{
[StructLayout(LayoutKind.Sequential)]
public class ExtendedCSD
{
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
public byte[] Reserved0;
public byte ExtendedSecurityCommandsError;
public byte SupportedCommandSets;
public byte HPIFeatures;
public byte BackgroundOperationsSupport;
public byte MaxPackedReadCommands;
public byte MaxPackedWriteCommands;
public byte DataTagSupport;
public byte TagUnitSize;
public byte TagResourcesSize;
public byte ContextManagementCaps;
public byte LargeUnitSize;
public byte ExtendedPartitionsSupport;
public byte SupportedModes;
public byte FFUFeatures;
public byte OperationCodesTimeout;
public uint FFUArgument;
public byte BarrierSupport;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 177)]
public byte[] Reserved1;
public byte CMDQueuingSupport;
public byte CMDQueuingDepth;
public uint NumberofFWSectorsCorrectlyProgrammed;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
public byte[] VendorHealthReport;
public byte DeviceLifeEstimationTypeB;
public byte DeviceLifeEstimationTypeA;
public byte PreEOLInformation;
public byte OptimalReadSize;
public byte OptimalWriteSize;
public byte OptimalTrimUnitSize;
public ushort DeviceVersion;
public ulong FirmwareVersion;
public byte PowerClassDDR200;
public uint CacheSize;
public byte GenericCMD6Timeout;
public byte PowerOffNotificationTimeout;
public byte BackgroundOperationsStatus;
public uint CorrectlyProgrammedSectors;
public byte InitializationTimeAfterPartition;
public byte CacheFlushingPolicy;
public byte PowerClassDDR52;
public byte PowerClassDDR52_195;
public byte PowerClassDDR200_195;
public byte PowerClassDDR200_130;
public byte MinimumWritePerformanceDDR52;
public byte MinimumReadPerformanceDDR52;
public byte Reserved2;
public byte TRIMMultiplier;
public byte SecureFeatureSupport;
public byte SecureEraseMultiplier;
public byte SecureTRIMMultiplier;
public byte BootInformation;
public byte Reserved3;
public byte BootPartitionSize;
public byte AccessSize;
public byte HighCapacityEraseUnitSize;
public byte HighCapacityEraseTimeout;
public byte ReliableWriteSectorCount;
public byte HighCapacityWriteProtectGroupSize;
public byte SleepCurrentVcc;
public byte SleepCurrentVccq;
public byte ProductionStateAwarenessTimeout;
public byte SleepAwakeTimeout;
public byte SleepNotificationTimeout;
public uint SectorCount;
public byte SecureWriteProtectInformation;
public byte MinimumWritePerformance52;
public byte MinimumReadPerformance52;
public byte MinimumWritePerformance26;
public byte MinimumReadPerformance26;
public byte MinimumWritePerformance26_4;
public byte MinimumReadPerformance26_4;
public byte Reserved4;
public byte PowerClass26;
public byte PowerClass52;
public byte PowerClass26_195;
public byte PowerClass52_195;
public byte PartitionSwitchingTime;
public byte OutOfInterruptBusyTiming;
public byte DriverStrength;
public byte DeviceType;
public byte Reserved5;
public byte Structure;
public byte Reserved6;
public byte Revision;
public byte CommandSet;
public byte Reserved7;
public byte CommandSetRevision;
public byte Reserved8;
public byte PowerClass;
public byte Reserved9;
public byte HighSpeedInterfaceTiming;
public byte StrobeSupport;
public byte BusWidth;
public byte Reserved10;
public byte ErasedMemoryContent;
public byte Reserved11;
public byte PartitionConfiguration;
public byte BootConfigProtection;
public byte BootBusConditions;
public byte Reserved12;
public byte HighDensityEraseGroupDefinition;
public byte BootWriteProtectionStatus;
public byte BootAreaWriteProtectionRegister;
public byte Reserved13;
public byte UserAreaWriteProtectionRegister;
public byte Reserved14;
public byte FirmwareConfiguration;
public byte RPMBSize;
public byte WriteReliabilitySettingRegister;
public byte WriteReliabilityParameterRegister;
public byte StartSanitizeOperation;
public byte ManuallyStartBackgroundOperations;
public byte EnableBackgroundOperationsHandshake;
public byte HWResetFunction;
public byte HPIManagement;
public byte PartitioningSupport;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] MaxEnhancedAreaSize;
public byte PartitionsAttribute;
public byte PartitioningSetting;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] GeneralPurposePartitionSize;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] EnhancedUserDataAreaSize;
public uint EnhancedUserDataStartAddress;
public byte Reserved15;
public byte BadBlockManagementMode;
public byte ProductionStateAwareness;
public byte PackageCaseTemperatureControl;
public byte PeriodicWakeUp;
public byte SupportsProgramCxDInDDR;
public ushort Reserved16;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
public byte[] VendorSpecific;
public byte NativeSectorSize;
public byte SectorSizeEmulation;
public byte SectorSize;
public byte InitializationTimeout;
public byte Class6CommandsControl;
public byte AddressedGroupToBeReleased;
public ushort ExceptionEventsControl;
public ushort ExceptionEventsStatus;
public ushort ExtendedPartitionsAttribute;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 15)]
public byte[] ContextConfiguration;
public byte PackedCommandStatus;
public byte PackedCommandFailureIndex;
public byte PowerOffNotification;
public byte CacheControl;
public byte CacheFlushing;
public byte BarrierControl;
public byte ModeConfig;
public byte ModeOperationCodes;
public ushort Reserved17;
public byte FFUStatus;
public uint PreLoadingDataSize;
public uint MaxPreLoadingDataSize;
public byte ProductStateAwarenessEnablement;
public byte SecureRemovalType;
public byte CommandQueueModeEnable;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 15)]
public byte[] Reserved18;
}
public partial class Decoders
{
public static ExtendedCSD DecodeExtendedCSD(byte[] response)
{
if(response == null)
return null;
if(response.Length != 512)
return null;
ExtendedCSD csd = new ExtendedCSD();
GCHandle handle = GCHandle.Alloc(response, GCHandleType.Pinned);
csd = (ExtendedCSD)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(ExtendedCSD));
handle.Free();
return csd;
}
public static string PrettifyExtendedCSD(ExtendedCSD csd)
{
if(csd == null)
return null;
StringBuilder sb = new StringBuilder();
sb.AppendLine("MultiMediaCard Extended Device Specific Data Register:");
double unit;
if((csd.HPIFeatures & 0x01) == 0x01)
{
if((csd.HPIFeatures & 0x02) == 0x02)
sb.AppendLine("\tDevice implements HPI using CMD12");
else
sb.AppendLine("\tDevice implements HPI using CMD13");
}
if((csd.BackgroundOperationsSupport & 0x01) == 0x01)
sb.AppendLine("\tDevice supports background operations");
sb.AppendFormat("\tDevice supports a maximum of {0} packed reads and {1} packed writes", csd.MaxPackedReadCommands, csd.MaxPackedWriteCommands).AppendLine();
if((csd.DataTagSupport & 0x01) == 0x01)
{
sb.AppendLine("\tDevice supports Data Tag");
sb.AppendFormat("\tTags must be in units of {0} sectors", Math.Pow(2, csd.TagUnitSize)).AppendLine();
}
if((csd.ExtendedPartitionsSupport & 0x01) == 0x01)
sb.AppendLine("\tDevice supports non-persistent extended partitions");
if((csd.ExtendedPartitionsSupport & 0x02) == 0x02)
sb.AppendLine("\tDevice supports system code extended partitions");
if((csd.SupportedModes & 0x01) == 0x01)
sb.AppendLine("\tDevice supports FFU");
if((csd.SupportedModes & 0x02) == 0x02)
sb.AppendLine("\tDevice supports Vendor Specific Mode");
if((csd.CMDQueuingSupport & 0x01) == 0x01)
sb.AppendFormat("\tDevice supports command queuing with a depth of {0}", csd.CMDQueuingDepth + 1).AppendLine();
sb.AppendFormat("\t{0} firmware sectors correctly programmed", csd.NumberofFWSectorsCorrectlyProgrammed).AppendLine();
switch(csd.DeviceLifeEstimationTypeB)
{
case 1:
sb.AppendLine("\tDevice used between 0% and 10% of its estimated life time");
break;
case 2:
sb.AppendLine("\tDevice used between 10% and 20% of its estimated life time");
break;
case 3:
sb.AppendLine("\tDevice used between 20% and 30% of its estimated life time");
break;
case 4:
sb.AppendLine("\tDevice used between 30% and 40% of its estimated life time");
break;
case 5:
sb.AppendLine("\tDevice used between 40% and 50% of its estimated life time");
break;
case 6:
sb.AppendLine("\tDevice used between 50% and 60% of its estimated life time");
break;
case 7:
sb.AppendLine("\tDevice used between 60% and 70% of its estimated life time");
break;
case 8:
sb.AppendLine("\tDevice used between 70% and 80% of its estimated life time");
break;
case 9:
sb.AppendLine("\tDevice used between 80% and 90% of its estimated life time");
break;
case 10:
sb.AppendLine("\tDevice used between 90% and 100% of its estimated life time");
break;
case 11:
sb.AppendLine("\tDevice exceeded its maximum estimated life time");
break;
}
switch(csd.DeviceLifeEstimationTypeA)
{
case 1:
sb.AppendLine("\tDevice used between 0% and 10% of its estimated life time");
break;
case 2:
sb.AppendLine("\tDevice used between 10% and 20% of its estimated life time");
break;
case 3:
sb.AppendLine("\tDevice used between 20% and 30% of its estimated life time");
break;
case 4:
sb.AppendLine("\tDevice used between 30% and 40% of its estimated life time");
break;
case 5:
sb.AppendLine("\tDevice used between 40% and 50% of its estimated life time");
break;
case 6:
sb.AppendLine("\tDevice used between 50% and 60% of its estimated life time");
break;
case 7:
sb.AppendLine("\tDevice used between 60% and 70% of its estimated life time");
break;
case 8:
sb.AppendLine("\tDevice used between 70% and 80% of its estimated life time");
break;
case 9:
sb.AppendLine("\tDevice used between 80% and 90% of its estimated life time");
break;
case 10:
sb.AppendLine("\tDevice used between 90% and 100% of its estimated life time");
break;
case 11:
sb.AppendLine("\tDevice exceeded its maximum estimated life time");
break;
}
switch(csd.PreEOLInformation)
{
case 1:
sb.AppendLine("\tDevice informs it's in good health");
break;
case 2:
sb.AppendLine("\tDevice informs it should be replaced soon");
break;
case 3:
sb.AppendLine("\tDevice informs it should be replace immediately");
break;
}
sb.AppendFormat("\tOptimal read size is {0} logical sectors", csd.OptimalReadSize).AppendLine();
sb.AppendFormat("\tOptimal write size is {0} logical sectors", csd.OptimalWriteSize).AppendLine();
sb.AppendFormat("\tOptimal trim size is {0} logical sectors", csd.OptimalTrimUnitSize).AppendLine();
sb.AppendFormat("\tDevice version: {0}", csd.DeviceVersion).AppendLine();
sb.AppendFormat("\tFirmware version: {0}", csd.FirmwareVersion).AppendLine();
if(csd.CacheSize == 0)
sb.AppendLine("\tDevice has no cache");
else
sb.AppendFormat("\tDevice has {0} KiB of cache", csd.CacheSize).AppendLine();
if(csd.GenericCMD6Timeout > 0)
sb.AppendFormat("\tDevice takes a maximum of {0} ms by default for a SWITCH command", csd.GenericCMD6Timeout * 10).AppendLine();
if(csd.PowerOffNotificationTimeout > 0)
sb.AppendFormat("\tDevice takes a maximum of {0} by default to power off from a SWITCH command notification", csd.PowerOffNotificationTimeout * 10).AppendLine();
switch(csd.BackgroundOperationsStatus & 0x03)
{
case 0:
sb.AppendLine("\tDevice has no pending background operations");
break;
case 1:
sb.AppendLine("\tDevice has non critical operations outstanding");
break;
case 2:
sb.AppendLine("\tDevice has performance impacted operations outstanding");
break;
case 3:
sb.AppendLine("\tDevice has critical operations outstanding");
break;
}
sb.AppendFormat("\tLast WRITE MULTIPLE command correctly programmed {0} sectors", csd.CorrectlyProgrammedSectors).AppendLine();
if(csd.InitializationTimeAfterPartition > 0)
sb.AppendFormat("\tDevice takes a maximum of {0} ms for initialization after partition", csd.InitializationTimeAfterPartition * 100).AppendLine();
if((csd.CacheFlushingPolicy & 0x01) == 0x01)
sb.AppendLine("\tDevice uses a FIFO policy for cache flushing");
if(csd.TRIMMultiplier > 0)
sb.AppendFormat("\tDevice takes a maximum of {0} ms for trimming a single erase group", csd.TRIMMultiplier * 300).AppendLine();
if((csd.SecureFeatureSupport & 0x40) == 0x40)
sb.AppendLine("\tDevice supports the sanitize operation");
if((csd.SecureFeatureSupport & 0x10) == 0x10)
sb.AppendLine("\tDevice supports supports the secure and insecure trim operations");
if((csd.SecureFeatureSupport & 0x04) == 0x04)
sb.AppendLine("\tDevice supports automatic erase on retired defective blocks");
if((csd.SecureFeatureSupport & 0x01) == 0x01)
sb.AppendLine("\tDevice supports secure purge operations");
if(csd.SecureEraseMultiplier > 0)
sb.AppendFormat("\tDevice takes a maximum of {0} ms for securely erasing a single erase group", csd.SecureEraseMultiplier * 300).AppendLine();
if(csd.SecureTRIMMultiplier > 0)
sb.AppendFormat("\tDevice takes a maximum of {0} ms for securely trimming a single erase group", csd.SecureTRIMMultiplier * 300).AppendLine();
if((csd.BootInformation & 0x04) == 0x04)
sb.AppendLine("\tDevice supports high speed timing on boot");
if((csd.BootInformation & 0x02) == 0x02)
sb.AppendLine("\tDevice supports dual data rate on boot");
if((csd.BootInformation & 0x01) == 0x01)
sb.AppendLine("\tDevice supports alternative boot method");
if(csd.BootPartitionSize > 0)
sb.AppendFormat("\tDevice has a {0} KiB boot partition", csd.BootPartitionSize * 128).AppendLine();
if((csd.AccessSize & 0x0F) > 0)
sb.AppendFormat("\tDevice has a page size of {0} KiB", (csd.AccessSize & 0x0F) * 512.0 / 1024.0).AppendLine();
if(csd.HighCapacityEraseUnitSize > 0)
sb.AppendFormat("\tDevice erase groups are {0} KiB", csd.HighCapacityEraseUnitSize * 512).AppendLine();
if(csd.HighCapacityEraseTimeout > 0)
sb.AppendFormat("\tDevice takes a maximum of {0} ms for erasing a single erase group", csd.HighCapacityEraseTimeout * 300).AppendLine();
if(csd.HighCapacityWriteProtectGroupSize > 0)
sb.AppendFormat("\tDevice smallest write protect group is made of {0} erase groups", csd.HighCapacityWriteProtectGroupSize).AppendLine();
if(csd.SleepCurrentVcc > 0)
{
unit = Math.Pow(2, csd.SleepCurrentVcc);
if(unit > 1000)
sb.AppendFormat("\tDevice uses {0} mA on Vcc when sleeping", unit / 1000).AppendLine();
else
sb.AppendFormat("\tDevice uses {0} μA on Vcc when sleeping", unit).AppendLine();
}
if(csd.SleepCurrentVccq > 0)
{
unit = Math.Pow(2, csd.SleepCurrentVccq);
if(unit > 1000)
sb.AppendFormat("\tDevice uses {0} mA on Vccq when sleeping", unit / 1000).AppendLine();
else
sb.AppendFormat("\tDevice uses {0} μA on Vccq when sleeping", unit).AppendLine();
}
if(csd.ProductionStateAwarenessTimeout > 0)
{
unit = Math.Pow(2, csd.ProductionStateAwareness) * 100;
if(unit > 1000000)
sb.AppendFormat("\tDevice takes a maximum of {0} s to switch production state awareness", unit / 1000000).AppendLine();
else if(unit > 1000)
sb.AppendFormat("\tDevice takes a maximum of {0} ms to switch production state awareness", unit / 1000).AppendLine();
else
sb.AppendFormat("\tDevice takes a maximum of {0} μs to switch production state awareness", unit).AppendLine();
}
if(csd.SleepAwakeTimeout > 0)
{
unit = Math.Pow(2, csd.SleepAwakeTimeout) * 100;
if(unit > 1000000)
sb.AppendFormat("\tDevice takes a maximum of {0} ms to transition between sleep and standby states", unit / 1000000).AppendLine();
else if(unit > 1000)
sb.AppendFormat("\tDevice takes a maximum of {0} μs to transition between sleep and standby states", unit / 1000).AppendLine();
else
sb.AppendFormat("\tDevice takes a maximum of {0} ns to transition between sleep and standby states", unit).AppendLine();
}
if(csd.SleepNotificationTimeout > 0)
{
unit = Math.Pow(2, csd.SleepNotificationTimeout) * 10;
if(unit > 1000000)
sb.AppendFormat("\tDevice takes a maximum of {0} s to move to sleep state", unit / 1000000).AppendLine();
else if(unit > 1000)
sb.AppendFormat("\tDevice takes a maximum of {0} ms to move to sleep state", unit / 1000).AppendLine();
else
sb.AppendFormat("\tDevice takes a maximum of {0} μs to move to sleep state", unit).AppendLine();
}
sb.AppendFormat("\tDevice has {0} sectors", csd.SectorCount).AppendLine();
if((csd.SecureWriteProtectInformation & 0x01) == 0x01)
{
sb.AppendLine("\tDevice supports secure write protection");
if((csd.SecureWriteProtectInformation & 0x02) == 0x02)
sb.AppendLine("\tDevice has secure write protection enabled");
}
unit = csd.MinimumReadPerformance26 * 150;
if(csd.MinimumReadPerformance26 == 0)
sb.AppendLine("\tDevice cannot achieve 2.4MB/s reading in SDR 26Mhz mode");
else
sb.AppendFormat("\tDevice can achieve a minimum of {0}MB/s reading in SDR 26Mhz mode", unit / 1000).AppendLine();
unit = csd.MinimumReadPerformance26_4 * 150;
if(csd.MinimumReadPerformance26_4 == 0)
sb.AppendLine("\tDevice cannot achieve 2.4MB/s reading in SDR 26Mhz 4-bit mode");
else
sb.AppendFormat("\tDevice can achieve a minimum of {0}MB/s reading in SDR 26Mhz 4-bit mode", unit / 1000).AppendLine();
unit = csd.MinimumReadPerformance52 * 150;
if(csd.MinimumReadPerformance52 == 0)
sb.AppendLine("\tDevice cannot achieve 2.4MB/s reading in SDR 52Mhz mode");
else
sb.AppendFormat("\tDevice can achieve a minimum of {0}MB/s reading in SDR 52Mhz mode", unit / 1000).AppendLine();
unit = csd.MinimumReadPerformanceDDR52 * 300;
if(csd.MinimumReadPerformanceDDR52 == 0)
sb.AppendLine("\tDevice cannot achieve 4.8MB/s reading in DDR 52Mhz mode");
else
sb.AppendFormat("\tDevice can achieve a minimum of {0}MB/s reading in DDR 52Mhz mode", unit / 1000).AppendLine();
unit = csd.MinimumWritePerformance26 * 150;
if(csd.MinimumWritePerformance26 == 0)
sb.AppendLine("\tDevice cannot achieve 2.4MB/s writing in SDR 26Mhz mode");
else
sb.AppendFormat("\tDevice can achieve a minimum of {0}MB/s writing in SDR 26Mhz mode", unit / 1000).AppendLine();
unit = csd.MinimumWritePerformance26_4 * 150;
if(csd.MinimumWritePerformance26_4 == 0)
sb.AppendLine("\tDevice cannot achieve 2.4MB/s writing in SDR 26Mhz 4-bit mode");
else
sb.AppendFormat("\tDevice can achieve a minimum of {0}MB/s writing in SDR 26Mhz 4-bit mode", unit / 1000).AppendLine();
unit = csd.MinimumWritePerformance52 * 150;
if(csd.MinimumWritePerformance52 == 0)
sb.AppendLine("\tDevice cannot achieve 2.4MB/s writing in SDR 52Mhz mode");
else
sb.AppendFormat("\tDevice can achieve a minimum of {0}MB/s writing in SDR 52Mhz mode", unit / 1000).AppendLine();
unit = csd.MinimumWritePerformanceDDR52 * 300;
if(csd.MinimumWritePerformanceDDR52 == 0)
sb.AppendLine("\tDevice cannot achieve 4.8MB/s writing in DDR 52Mhz mode");
else
sb.AppendFormat("\tDevice can achieve a minimum of {0}MB/s writing in DDR 52Mhz mode", unit / 1000).AppendLine();
if(csd.PartitionSwitchingTime > 0)
sb.AppendFormat("\tDevice can take a maximum of {0} ms when switching partitions", csd.PartitionSwitchingTime * 10).AppendLine();
if(csd.OutOfInterruptBusyTiming > 0)
sb.AppendFormat("\tDevice can take a maximum of {0} ms when releasing from an interrupt", csd.OutOfInterruptBusyTiming * 10).AppendLine();
if((csd.DeviceType & 0x01) == 0x01)
sb.AppendLine("\tDevice supports 26 Mhz mode");
if((csd.DeviceType & 0x02) == 0x02)
sb.AppendLine("\tDevice supports 52 Mhz mode");
if((csd.DeviceType & 0x04) == 0x04)
sb.AppendLine("\tDevice supports DDR 52 Mhz mode at 1.8V or 3V");
if((csd.DeviceType & 0x08) == 0x08)
sb.AppendLine("\tDevice supports DDR 52 Mhz mode 1.2V");
if((csd.DeviceType & 0x10) == 0x10)
sb.AppendLine("\tDevice supports HS-200 mode (SDR 200Mhz) at 1.8V");
if((csd.DeviceType & 0x20) == 0x20)
sb.AppendLine("\tDevice supports HS-200 mode (SDR 200Mhz) at 1.2V");
if((csd.DeviceType & 0x40) == 0x40)
sb.AppendLine("\tDevice supports HS-400 mode (DDR 200Mhz) at 1.8V");
if((csd.DeviceType & 0x80) == 0x80)
sb.AppendLine("\tDevice supports HS-400 mode (DDR 200Mhz) at 1.2V");
sb.AppendFormat("\tCSD version 1.{0} revision 1.{1}", csd.Structure, csd.Revision).AppendLine();
if((csd.StrobeSupport & 0x01) == 0x01)
{
sb.AppendLine("\tDevice supports enhanced strobe mode");
if((csd.BusWidth & 0x80) == 0x80)
sb.AppendLine("\tDevice uses strobe during Data Out, CRC and CMD responses");
else
sb.AppendLine("\tDevice uses strobe during Data Out and CRC responses");
}
switch(csd.BusWidth & 0x0F)
{
case 0:
sb.AppendLine("\tDevice is using 1-bit data bus");
break;
case 1:
sb.AppendLine("\tDevice is using 4-bit data bus");
break;
case 2:
sb.AppendLine("\tDevice is using 8-bit data bus");
break;
case 5:
sb.AppendLine("\tDevice is using 4-bit DDR data bus");
break;
case 6:
sb.AppendLine("\tDevice is using 8-bit DDR data bus");
break;
default:
sb.AppendFormat("\tDevice is using unknown data bus code {0}", csd.BusWidth & 0x0F).AppendLine();
break;
}
if((csd.PartitionConfiguration & 0x80) == 0x80)
sb.AppendLine("\tDevice sends boot acknowledge");
switch((csd.PartitionConfiguration & 0x38) >> 3)
{
case 0:
sb.AppendLine("\tDevice is not boot enabled");
break;
case 1:
sb.AppendLine("\tDevice boot partition 1 is enabled");
break;
case 2:
sb.AppendLine("\tDevice boot partition 2 is enabled");
break;
case 7:
sb.AppendLine("\tDevice user area is enable for boot");
break;
default:
sb.AppendFormat("\tUnknown enabled boot partition code {0}", (csd.PartitionConfiguration & 0x38) >> 3).AppendLine();
break;
}
switch(csd.PartitionConfiguration & 0x07)
{
case 0:
sb.AppendLine("\tThere is no access to boot partition");
break;
case 1:
sb.AppendLine("\tThere is read/write access to boot partition 1");
break;
case 2:
sb.AppendLine("\tThere is read/write access to boot partition 2");
break;
case 3:
sb.AppendLine("\tThere is read/write access to replay protected memory block");
break;
default:
sb.AppendFormat("\tThere is access to general purpose partition {0}", (csd.PartitionConfiguration & 0x07) - 3).AppendLine();
break;
}
if((csd.FirmwareConfiguration & 0x01) == 0x01)
sb.AppendLine("\tFirmware updates are permanently disabled");
if(csd.RPMBSize > 0)
sb.AppendFormat("\tDevice has a {0} KiB replay protected memory block", csd.RPMBSize * 128).AppendLine();
switch(csd.NativeSectorSize)
{
case 0:
sb.AppendLine("\tDevice natively uses 512 byte sectors");
break;
case 1:
sb.AppendLine("\tDevice natively uses 4096 byte sectors");
break;
default:
sb.AppendFormat("\tDevice natively uses unknown sector size indicated by code {0}", csd.NativeSectorSize).AppendLine();
break;
}
switch(csd.SectorSizeEmulation)
{
case 0:
sb.AppendLine("\tDevice is emulating 512 byte sectors");
break;
case 1:
sb.AppendLine("\tDevice is using natively sized sectors");
break;
default:
sb.AppendFormat("\tDevice emulates unknown sector size indicated by code {0}", csd.NativeSectorSize).AppendLine();
break;
}
switch(csd.SectorSize)
{
case 0:
sb.AppendLine("\tDevice currently addresses 512 byte sectors");
break;
case 1:
sb.AppendLine("\tDevice currently addresses 4096 byte sectors");
break;
default:
sb.AppendFormat("\tDevice currently addresses unknown sector size indicated by code {0}", csd.NativeSectorSize).AppendLine();
break;
}
if((csd.CacheControl & 0x01) == 0x01)
sb.AppendLine("\tDevice's cache is enabled");
if((csd.CommandQueueModeEnable & 0x01) == 0x01)
sb.AppendLine("\tDevice has enabled command queuing");
return sb.ToString();
}
public static string PrettifyExtendedCSD(byte[] response)
{
return PrettifyExtendedCSD(DecodeExtendedCSD(response));
}
}
}

View File

@@ -0,0 +1,168 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : OCR.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Text;
namespace DiscImageChef.Decoders.MMC
{
public class OCR
{
public bool PowerUp;
public byte AccessMode;
public bool ThreeFive;
public bool ThreeFour;
public bool ThreeThree;
public bool ThreeTwo;
public bool ThreeOne;
public bool ThreeZero;
public bool TwoNine;
public bool TwoEight;
public bool TwoSeven;
public bool TwoSix;
public bool TwoFive;
public bool TwoFour;
public bool TwoThree;
public bool TwoTwo;
public bool TwoOne;
public bool TwoZero;
public bool OneSix;
}
public partial class Decoders
{
public static OCR DecodeOCR(uint response)
{
OCR ocr = new OCR();
ocr.PowerUp = (response & 0x80000000) == 0x80000000;
ocr.AccessMode = (byte)((response & 0x60000000) >> 29);
ocr.ThreeFive = (response & 0x00800000) == 0x00800000;
ocr.ThreeFour = (response & 0x00400000) == 0x00400000;
ocr.ThreeThree = (response & 0x00200000) == 0x00200000;
ocr.ThreeTwo = (response & 0x00100000) == 0x00100000;
ocr.ThreeOne = (response & 0x00080000) == 0x00080000;
ocr.ThreeZero = (response & 0x00040000) == 0x00040000;
ocr.TwoNine = (response & 0x00020000) == 0x00020000;
ocr.TwoEight = (response & 0x00010000) == 0x00010000;
ocr.TwoSeven = (response & 0x00008000) == 0x00008000;
ocr.TwoSix = (response & 0x00004000) == 0x00004000;
ocr.TwoFive = (response & 0x00002000) == 0x00002000;
ocr.TwoFour = (response & 0x00001000) == 0x00001000;
ocr.TwoThree = (response & 0x00000800) == 0x00000800;
ocr.TwoTwo = (response & 0x00000400) == 0x00000400;
ocr.TwoOne = (response & 0x00000200) == 0x00000200;
ocr.TwoZero = (response & 0x00000100) == 0x00000100;
ocr.OneSix = (response & 0x00000080) == 0x00000080;
return ocr;
}
public static OCR DecodeOCR(byte[] response)
{
if(response == null)
return null;
if(response.Length != 4)
return null;
return DecodeOCR(BitConverter.ToUInt32(response, 0));
}
public static string PrettifyOCR(OCR ocr)
{
if(ocr == null)
return null;
StringBuilder sb = new StringBuilder();
sb.AppendLine("MultiMediaCard Operation Conditions Register:");
if(!ocr.PowerUp)
sb.AppendLine("\tDevice is powering up");
switch(ocr.AccessMode)
{
case 0:
sb.AppendLine("\tDevice is byte addressed");
break;
case 2:
sb.AppendLine("\tDevice is sector addressed");
break;
default:
sb.AppendFormat("\tUnknown device access mode {0}", ocr.AccessMode).AppendLine();
break;
}
if(ocr.ThreeFive)
sb.AppendLine("\tDevice can work with supply 3.5~3.6V");
if(ocr.ThreeFour)
sb.AppendLine("\tDevice can work with supply 3.4~3.5V");
if(ocr.ThreeThree)
sb.AppendLine("\tDevice can work with supply 3.3~3.4V");
if(ocr.ThreeTwo)
sb.AppendLine("\tDevice can work with supply 3.2~3.3V");
if(ocr.ThreeOne)
sb.AppendLine("\tDevice can work with supply 3.1~3.2V");
if(ocr.TwoNine)
sb.AppendLine("\tDevice can work with supply 2.9~3.0V");
if(ocr.TwoEight)
sb.AppendLine("\tDevice can work with supply 2.8~2.9V");
if(ocr.TwoSeven)
sb.AppendLine("\tDevice can work with supply 2.7~2.8V");
if(ocr.TwoSix)
sb.AppendLine("\tDevice can work with supply 2.6~2.7V");
if(ocr.TwoFive)
sb.AppendLine("\tDevice can work with supply 2.5~2.6V");
if(ocr.TwoFour)
sb.AppendLine("\tDevice can work with supply 2.4~2.5V");
if(ocr.TwoThree)
sb.AppendLine("\tDevice can work with supply 2.3~2.4V");
if(ocr.TwoTwo)
sb.AppendLine("\tDevice can work with supply 2.2~2.3V");
if(ocr.TwoOne)
sb.AppendLine("\tDevice can work with supply 2.1~2.2V");
if(ocr.TwoZero)
sb.AppendLine("\tDevice can work with supply 2.0~2.1V");
if(ocr.OneSix)
sb.AppendLine("\tDevice can work with supply 1.65~1.95V");
return sb.ToString();
}
public static string PrettifyOCR(byte[] response)
{
return PrettifyOCR(DecodeOCR(response));
}
public static string PrettifyOCR(uint response)
{
return PrettifyOCR(DecodeOCR(response));
}
}
}

View File

@@ -0,0 +1,48 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : VendorString.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
namespace DiscImageChef.Decoders.MMC
{
public static class VendorString
{
public static string Prettify(byte MMCVendorID)
{
switch(MMCVendorID)
{
case 0x15:
return "Samsung";
default:
return string.Format("Unknown manufacturer ID 0x{0:X2}", MMCVendorID);
}
}
}
}

View File

@@ -0,0 +1,129 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : CID.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Text;
namespace DiscImageChef.Decoders.SecureDigital
{
public class CID
{
public byte Manufacturer;
public string ApplicationID;
public string ProductName;
public byte ProductRevision;
public uint ProductSerialNumber;
public ushort ManufacturingDate;
public byte CRC;
}
public partial class Decoders
{
public static CID DecodeCID(uint[] response)
{
if(response == null)
return null;
if(response.Length != 4)
return null;
byte[] data = new byte[16];
byte[] tmp = new byte[4];
tmp = BitConverter.GetBytes(response[0]);
Array.Copy(tmp, 0, data, 0, 4);
tmp = BitConverter.GetBytes(response[1]);
Array.Copy(tmp, 0, data, 4, 4);
tmp = BitConverter.GetBytes(response[2]);
Array.Copy(tmp, 0, data, 8, 4);
tmp = BitConverter.GetBytes(response[3]);
Array.Copy(tmp, 0, data, 12, 4);
return DecodeCID(data);
}
public static CID DecodeCID(byte[] response)
{
if(response == null)
return null;
if(response.Length != 16)
return null;
byte[] tmp;
CID cid = new CID();
cid.Manufacturer = response[0];
tmp = new byte[2];
Array.Copy(response, 1, tmp, 0, 2);
cid.ApplicationID = StringHandlers.CToString(tmp);
tmp = new byte[5];
Array.Copy(response, 3, tmp, 0, 5);
cid.ProductName = StringHandlers.CToString(tmp);
cid.ProductRevision = response[8];
cid.ProductSerialNumber = BitConverter.ToUInt32(response, 9);
cid.ManufacturingDate = (ushort)(((response[13] & 0x0F) << 4) + response[14]);
cid.CRC = (byte)((response[15] & 0xFE) >> 1);
return cid;
}
public static string PrettifyCID(CID cid)
{
if(cid == null)
return null;
StringBuilder sb = new StringBuilder();
sb.AppendLine("SecureDigital Device Identification Register:");
sb.AppendFormat("\tManufacturer: {0}", VendorString.Prettify(cid.Manufacturer)).AppendLine();
sb.AppendFormat("\tApplication ID: {0}", cid.ApplicationID).AppendLine();
sb.AppendFormat("\tProduct name: {0}", cid.ProductName).AppendLine();
sb.AppendFormat("\tProduct revision: {0:X2}.{1:X2}", (cid.ProductRevision & 0xF0) >> 4, cid.ProductRevision & 0x0F).AppendLine();
sb.AppendFormat("\tProduct serial number: {0}", cid.ProductSerialNumber).AppendLine();
sb.AppendFormat("\tDevice manufactured month {0} of {1}", (cid.ManufacturingDate & 0xF00) >> 8, (cid.ManufacturingDate & 0xFF) + 2000).AppendLine();
sb.AppendFormat("\tCID CRC: 0x{0:X2}", cid.CRC).AppendLine();
return sb.ToString();
}
public static string PrettifyCID(uint[] response)
{
return PrettifyCID(DecodeCID(response));
}
public static string PrettifyCID(byte[] response)
{
return PrettifyCID(DecodeCID(response));
}
}
}

View File

@@ -0,0 +1,568 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : CSD.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Text;
namespace DiscImageChef.Decoders.SecureDigital
{
public class CSD
{
public byte Structure;
public byte TAAC;
public byte NSAC;
public byte Speed;
public ushort Classes;
public byte ReadBlockLength;
public bool ReadsPartialBlocks;
public bool WriteMisalignment;
public bool ReadMisalignment;
public bool DSRImplemented;
public uint Size;
public byte ReadCurrentAtVddMin;
public byte ReadCurrentAtVddMax;
public byte WriteCurrentAtVddMin;
public byte WriteCurrentAtVddMax;
public byte SizeMultiplier;
public bool EraseBlockEnable;
public byte EraseSectorSize;
public byte WriteProtectGroupSize;
public bool WriteProtectGroupEnable;
public byte WriteSpeedFactor;
public byte WriteBlockLength;
public bool WritesPartialBlocks;
public bool FileFormatGroup;
public bool Copy;
public bool PermanentWriteProtect;
public bool TemporaryWriteProtect;
public byte FileFormat;
public byte CRC;
}
public partial class Decoders
{
public static CSD DecodeCSD(uint[] response)
{
if(response == null)
return null;
if(response.Length != 4)
return null;
byte[] data = new byte[16];
byte[] tmp = new byte[4];
tmp = BitConverter.GetBytes(response[0]);
Array.Copy(tmp, 0, data, 0, 4);
tmp = BitConverter.GetBytes(response[1]);
Array.Copy(tmp, 0, data, 4, 4);
tmp = BitConverter.GetBytes(response[2]);
Array.Copy(tmp, 0, data, 8, 4);
tmp = BitConverter.GetBytes(response[3]);
Array.Copy(tmp, 0, data, 12, 4);
return DecodeCSD(data);
}
public static CSD DecodeCSD(byte[] response)
{
if(response == null)
return null;
if(response.Length != 16)
return null;
CSD csd = new CSD();
csd.Structure = (byte)((response[0] & 0xC0) >> 6);
csd.TAAC = response[1];
csd.NSAC = response[2];
csd.Speed = response[3];
csd.Classes = (ushort)((response[4] << 4) + ((response[5] & 0xF0) >> 4));
csd.ReadBlockLength = (byte)(response[5] & 0x0F);
csd.ReadsPartialBlocks = (response[6] & 0x80) == 0x80;
csd.WriteMisalignment = (response[6] & 0x40) == 0x40;
csd.ReadMisalignment = (response[6] & 0x20) == 0x20;
csd.DSRImplemented = (response[6] & 0x10) == 0x10;
if(csd.Structure == 0)
{
csd.Size = (ushort)(((response[6] & 0x03) << 10) + (response[7] << 2) + ((response[8] & 0xC0) >> 6));
csd.ReadCurrentAtVddMin = (byte)((response[8] & 0x38) >> 3);
csd.ReadCurrentAtVddMax = (byte)(response[8] & 0x07);
csd.WriteCurrentAtVddMin = (byte)((response[9] & 0xE0) >> 5);
csd.WriteCurrentAtVddMax = (byte)((response[9] & 0x1C) >> 2);
csd.SizeMultiplier = (byte)(((response[9] & 0x03) << 1) + ((response[10] & 0x80) >> 7));
}
else
csd.Size = (uint)(((response[7] & 0x3F) << 16) + (response[8] << 8) + response[9]);
csd.EraseBlockEnable = (response[10] & 0x40) == 0x40;
csd.EraseSectorSize = (byte)(((response[10] & 0x3F) << 1) + ((response[11] & 0x80) >> 7));
csd.WriteProtectGroupSize = ((byte)(response[11] & 0x7F));
csd.WriteProtectGroupEnable = (response[12] & 0x80) == 0x80;
csd.WriteSpeedFactor = (byte)((response[12] & 0x1C) >> 2);
csd.WriteBlockLength = (byte)(((response[12] & 0x03) << 2) + ((response[13] & 0xC0) >> 6));
csd.WritesPartialBlocks = (response[13] & 0x20) == 0x20;
csd.FileFormatGroup = (response[14] & 0x80) == 0x80;
csd.Copy = (response[14] & 0x40) == 0x40;
csd.PermanentWriteProtect = (response[14] & 0x20) == 0x20;
csd.TemporaryWriteProtect = (response[14] & 0x10) == 0x10;
csd.FileFormat = (byte)((response[14] & 0x0C) >> 2);
csd.CRC = (byte)((response[15] & 0xFE) >> 1);
return csd;
}
public static string PrettifyCSD(CSD csd)
{
if(csd == null)
return null;
double unitFactor = 0;
double multiplier = 0;
double result = 0;
string unit = "";
StringBuilder sb = new StringBuilder();
sb.AppendLine("SecureDigital Device Specific Data Register:");
switch(csd.Structure)
{
case 0:
sb.AppendLine("\tRegister version 1.0");
break;
case 1:
sb.AppendLine("\tRegister version 2.0");
break;
}
switch(csd.TAAC & 0x07)
{
case 0:
unit = "ns";
unitFactor = 1;
break;
case 1:
unit = "ns";
unitFactor = 10;
break;
case 2:
unit = "ns";
unitFactor = 100;
break;
case 3:
unit = "μs";
unitFactor = 1;
break;
case 4:
unit = "μs";
unitFactor = 10;
break;
case 5:
unit = "μs";
unitFactor = 100;
break;
case 6:
unit = "ms";
unitFactor = 1;
break;
case 7:
unit = "ms";
unitFactor = 10;
break;
}
switch((csd.TAAC & 0x78) >> 3)
{
case 0:
multiplier = 0;
break;
case 1:
multiplier = 1;
break;
case 2:
multiplier = 1.2;
break;
case 3:
multiplier = 1.3;
break;
case 4:
multiplier = 1.5;
break;
case 5:
multiplier = 2;
break;
case 6:
multiplier = 2.5;
break;
case 7:
multiplier = 3;
break;
case 8:
multiplier = 3.5;
break;
case 9:
multiplier = 4;
break;
case 10:
multiplier = 4.5;
break;
case 11:
multiplier = 5;
break;
case 12:
multiplier = 5.5;
break;
case 13:
multiplier = 6;
break;
case 14:
multiplier = 7;
break;
case 15:
multiplier = 8;
break;
}
result = unitFactor * multiplier;
sb.AppendFormat("\tAsynchronous data access time is {0}{1}", result, unit).AppendLine();
sb.AppendFormat("\tClock dependent part of data access is {0} clock cycles", csd.NSAC * 100).AppendLine();
unit = "MBit/s";
switch(csd.Speed & 0x07)
{
case 0:
unitFactor = 0.1;
break;
case 1:
unitFactor = 1;
break;
case 2:
unitFactor = 10;
break;
case 3:
unitFactor = 100;
break;
default:
unit = "unknown";
unitFactor = 0;
break;
}
switch((csd.Speed & 0x78) >> 3)
{
case 0:
multiplier = 0;
break;
case 1:
multiplier = 1;
break;
case 2:
multiplier = 1.2;
break;
case 3:
multiplier = 1.3;
break;
case 4:
multiplier = 1.5;
break;
case 5:
multiplier = 2;
break;
case 6:
multiplier = 2.6;
break;
case 7:
multiplier = 3;
break;
case 8:
multiplier = 3.5;
break;
case 9:
multiplier = 4;
break;
case 10:
multiplier = 4.5;
break;
case 11:
multiplier = 5.2;
break;
case 12:
multiplier = 5.5;
break;
case 13:
multiplier = 6;
break;
case 14:
multiplier = 7;
break;
case 15:
multiplier = 8;
break;
}
result = unitFactor * multiplier;
sb.AppendFormat("\tDevice's transfer speed: {0}{1}", result, unit).AppendLine();
unit = "";
for(int cl = 0, mask = 1; cl <= 11; cl++, mask <<= 1)
{
if((csd.Classes & mask) == mask)
unit += string.Format(" {0}", cl);
}
sb.AppendFormat("\tDevice support command classes {0}", unit).AppendLine();
sb.AppendFormat("\tRead block length is {0} bytes", Math.Pow(2, csd.ReadBlockLength)).AppendLine();
if(csd.ReadsPartialBlocks)
sb.AppendLine("\tDevice allows reading partial blocks");
if(csd.WriteMisalignment)
sb.AppendLine("\tWrite commands can cross physical block boundaries");
if(csd.ReadMisalignment)
sb.AppendLine("\tRead commands can cross physical block boundaries");
if(csd.DSRImplemented)
sb.AppendLine("\tDevice implements configurable driver stage");
if(csd.Structure == 0)
{
result = (csd.Size + 1) * Math.Pow(2, csd.SizeMultiplier + 2);
sb.AppendFormat("\tDevice has {0} blocks", (int)result).AppendLine();
result = (csd.Size + 1) * Math.Pow(2, csd.SizeMultiplier + 2) * Math.Pow(2, csd.ReadBlockLength);
if(result > 1073741824)
sb.AppendFormat("\tDevice has {0} GiB", result / 1073741824.0);
else if(result > 1048576)
sb.AppendFormat("\tDevice has {0} MiB", result / 1048576.0);
else if(result > 1024)
sb.AppendFormat("\tDevice has {0} KiB", result / 1024.0);
else
sb.AppendFormat("\tDevice has {0} bytes", result);
}
else
{
sb.AppendFormat("\tDevice has {0} blocks", (csd.Size + 1) * 1024);
result = (csd.Size + 1) * 1024 * 512;
if(result > 1099511627776)
sb.AppendFormat("\tDevice has {0} TiB", result / 1099511627776.0);
else if(result > 1073741824)
sb.AppendFormat("\tDevice has {0} GiB", result / 1073741824.0);
else if(result > 1048576)
sb.AppendFormat("\tDevice has {0} MiB", result / 1048576.0);
else if(result > 1024)
sb.AppendFormat("\tDevice has {0} KiB", result / 1024.0);
else
sb.AppendFormat("\tDevice has {0} bytes", result);
}
if(csd.Structure == 0)
{
switch(csd.ReadCurrentAtVddMin & 0x07)
{
case 0:
sb.AppendLine("\tDevice uses a maximum of 0.5mA for reading at minimum voltage");
break;
case 1:
sb.AppendLine("\tDevice uses a maximum of 1mA for reading at minimum voltage");
break;
case 2:
sb.AppendLine("\tDevice uses a maximum of 5mA for reading at minimum voltage");
break;
case 3:
sb.AppendLine("\tDevice uses a maximum of 10mA for reading at minimum voltage");
break;
case 4:
sb.AppendLine("\tDevice uses a maximum of 25mA for reading at minimum voltage");
break;
case 5:
sb.AppendLine("\tDevice uses a maximum of 35mA for reading at minimum voltage");
break;
case 6:
sb.AppendLine("\tDevice uses a maximum of 60mA for reading at minimum voltage");
break;
case 7:
sb.AppendLine("\tDevice uses a maximum of 100mA for reading at minimum voltage");
break;
}
switch(csd.ReadCurrentAtVddMax & 0x07)
{
case 0:
sb.AppendLine("\tDevice uses a maximum of 1mA for reading at maximum voltage");
break;
case 1:
sb.AppendLine("\tDevice uses a maximum of 5mA for reading at maximum voltage");
break;
case 2:
sb.AppendLine("\tDevice uses a maximum of 10mA for reading at maximum voltage");
break;
case 3:
sb.AppendLine("\tDevice uses a maximum of 25mA for reading at maximum voltage");
break;
case 4:
sb.AppendLine("\tDevice uses a maximum of 35mA for reading at maximum voltage");
break;
case 5:
sb.AppendLine("\tDevice uses a maximum of 45mA for reading at maximum voltage");
break;
case 6:
sb.AppendLine("\tDevice uses a maximum of 80mA for reading at maximum voltage");
break;
case 7:
sb.AppendLine("\tDevice uses a maximum of 200mA for reading at maximum voltage");
break;
}
switch(csd.WriteCurrentAtVddMin & 0x07)
{
case 0:
sb.AppendLine("\tDevice uses a maximum of 0.5mA for writing at minimum voltage");
break;
case 1:
sb.AppendLine("\tDevice uses a maximum of 1mA for writing at minimum voltage");
break;
case 2:
sb.AppendLine("\tDevice uses a maximum of 5mA for writing at minimum voltage");
break;
case 3:
sb.AppendLine("\tDevice uses a maximum of 10mA for writing at minimum voltage");
break;
case 4:
sb.AppendLine("\tDevice uses a maximum of 25mA for writing at minimum voltage");
break;
case 5:
sb.AppendLine("\tDevice uses a maximum of 35mA for writing at minimum voltage");
break;
case 6:
sb.AppendLine("\tDevice uses a maximum of 60mA for writing at minimum voltage");
break;
case 7:
sb.AppendLine("\tDevice uses a maximum of 100mA for writing at minimum voltage");
break;
}
switch(csd.WriteCurrentAtVddMax & 0x07)
{
case 0:
sb.AppendLine("\tDevice uses a maximum of 1mA for writing at maximum voltage");
break;
case 1:
sb.AppendLine("\tDevice uses a maximum of 5mA for writing at maximum voltage");
break;
case 2:
sb.AppendLine("\tDevice uses a maximum of 10mA for writing at maximum voltage");
break;
case 3:
sb.AppendLine("\tDevice uses a maximum of 25mA for writing at maximum voltage");
break;
case 4:
sb.AppendLine("\tDevice uses a maximum of 35mA for writing at maximum voltage");
break;
case 5:
sb.AppendLine("\tDevice uses a maximum of 45mA for writing at maximum voltage");
break;
case 6:
sb.AppendLine("\tDevice uses a maximum of 80mA for writing at maximum voltage");
break;
case 7:
sb.AppendLine("\tDevice uses a maximum of 200mA for writing at maximum voltage");
break;
}
if(csd.EraseBlockEnable)
sb.AppendLine("\tDevice can erase multiple blocks");
sb.AppendFormat("\tDevice must erase a minimum of {0} blocks at a time", Convert.ToUInt32(string.Format("{0:X}", csd.EraseSectorSize)) + 1).AppendLine();
if(csd.WriteProtectGroupEnable)
{
sb.AppendLine("\tDevice can write protect regions");
unitFactor = Convert.ToDouble(string.Format("{0:X}", csd.WriteProtectGroupSize));
sb.AppendFormat("\tDevice can write protect a minimum of {0} blocks at a time", (int)(result + 1)).AppendLine();
}
else
sb.AppendLine("\tDevice can't write protect regions");
}
sb.AppendFormat("\tWriting is {0} times slower than reading", Math.Pow(2, csd.WriteSpeedFactor)).AppendLine();
sb.AppendFormat("\tWrite block length is {0} bytes", Math.Pow(2, csd.WriteBlockLength)).AppendLine();
if(csd.WritesPartialBlocks)
sb.AppendLine("\tDevice allows writing partial blocks");
if(!csd.Copy)
sb.AppendLine("\tDevice contents are original");
if(csd.PermanentWriteProtect)
sb.AppendLine("\tDevice is permanently write protected");
if(csd.TemporaryWriteProtect)
sb.AppendLine("\tDevice is temporarily write protected");
if(!csd.FileFormatGroup)
{
switch(csd.FileFormat)
{
case 0:
sb.AppendLine("\tDevice is formatted like a hard disk");
break;
case 1:
sb.AppendLine("\tDevice is formatted like a floppy disk using Microsoft FAT");
break;
case 2:
sb.AppendLine("\tDevice uses Universal File Format");
break;
default:
sb.AppendFormat("\tDevice uses unknown file format code {0}", csd.FileFormat).AppendLine();
break;
}
}
else
sb.AppendFormat("\tDevice uses unknown file format code {0} and file format group 1", csd.FileFormat).AppendLine();
sb.AppendFormat("\tCSD CRC: 0x{0:X2}", csd.CRC).AppendLine();
return sb.ToString();
}
public static string PrettifyCSD(uint[] response)
{
return PrettifyCSD(DecodeCSD(response));
}
public static string PrettifyCSD(byte[] response)
{
return PrettifyCSD(DecodeCSD(response));
}
}
}

View File

@@ -0,0 +1,138 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : OCR.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Text;
namespace DiscImageChef.Decoders.SecureDigital
{
public class OCR
{
public bool PowerUp;
public bool CCS;
public bool UHS;
public bool OneEight;
public bool ThreeFive;
public bool ThreeFour;
public bool ThreeThree;
public bool ThreeTwo;
public bool ThreeOne;
public bool ThreeZero;
public bool TwoNine;
public bool TwoEight;
public bool TwoSeven;
public bool LowPower;
}
public partial class Decoders
{
public static OCR DecodeOCR(uint response)
{
OCR ocr = new OCR();
ocr.PowerUp = (response & 0x80000000) == 0x80000000;
ocr.CCS = (response & 0x40000000) == 0x40000000;
ocr.PowerUp = (response & 0x20000000) == 0x20000000;
ocr.OneEight = (response & 0x01000000) == 0x01000000;
ocr.ThreeFive = (response & 0x00800000) == 0x00800000;
ocr.ThreeFour = (response & 0x00400000) == 0x00400000;
ocr.ThreeThree = (response & 0x00200000) == 0x00200000;
ocr.ThreeTwo = (response & 0x00100000) == 0x00100000;
ocr.ThreeOne = (response & 0x00080000) == 0x00080000;
ocr.ThreeZero = (response & 0x00040000) == 0x00040000;
ocr.TwoNine = (response & 0x00020000) == 0x00020000;
ocr.TwoEight = (response & 0x00010000) == 0x00010000;
ocr.TwoSeven = (response & 0x00008000) == 0x00008000;
ocr.LowPower = (response & 0x00000080) == 0x00000080;
return ocr;
}
public static OCR DecodeOCR(byte[] response)
{
if(response == null)
return null;
if(response.Length != 4)
return null;
return DecodeOCR(BitConverter.ToUInt32(response, 0));
}
public static string PrettifyOCR(OCR ocr)
{
if(ocr == null)
return null;
StringBuilder sb = new StringBuilder();
sb.AppendLine("SecureDigital Operation Conditions Register:");
if(!ocr.PowerUp)
sb.AppendLine("\tDevice is powering up");
if(ocr.CCS)
sb.AppendLine("\tDevice is SDHC, SDXC or higher");
if(ocr.UHS)
sb.AppendLine("\tDevice is UHS-II or higher");
if(ocr.ThreeFive)
sb.AppendLine("\tDevice can work with supply 3.5~3.6V");
if(ocr.ThreeFour)
sb.AppendLine("\tDevice can work with supply 3.4~3.5V");
if(ocr.ThreeThree)
sb.AppendLine("\tDevice can work with supply 3.3~3.4V");
if(ocr.ThreeTwo)
sb.AppendLine("\tDevice can work with supply 3.2~3.3V");
if(ocr.ThreeOne)
sb.AppendLine("\tDevice can work with supply 3.1~3.2V");
if(ocr.TwoNine)
sb.AppendLine("\tDevice can work with supply 2.9~3.0V");
if(ocr.TwoEight)
sb.AppendLine("\tDevice can work with supply 2.8~2.9V");
if(ocr.TwoSeven)
sb.AppendLine("\tDevice can work with supply 2.7~2.8V");
if(ocr.OneEight)
sb.AppendLine("\tDevice can switch to work with 1.8V supply");
if(ocr.LowPower)
sb.AppendLine("\tDevice is in low power mode");
return sb.ToString();
}
public static string PrettifyOCR(byte[] response)
{
return PrettifyOCR(DecodeOCR(response));
}
public static string PrettifyOCR(uint response)
{
return PrettifyOCR(DecodeOCR(response));
}
}
}

View File

@@ -0,0 +1,176 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : SCR.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Text;
namespace DiscImageChef.Decoders.SecureDigital
{
public class SCR
{
public byte Structure;
public byte Spec;
public bool DataStatusAfterErase;
public byte Security;
public byte BusWidth;
public bool Spec3;
public byte ExtendedSecurity;
public bool Spec4;
public byte SpecX;
public byte CommandSupport;
public byte[] ManufacturerReserved;
}
public partial class Decoders
{
public static SCR DecodeSCR(uint[] response)
{
if(response == null)
return null;
if(response.Length != 2)
return null;
byte[] data = new byte[8];
byte[] tmp = new byte[4];
tmp = BitConverter.GetBytes(response[0]);
Array.Copy(tmp, 0, data, 0, 4);
tmp = BitConverter.GetBytes(response[1]);
Array.Copy(tmp, 0, data, 4, 4);
return DecodeSCR(data);
}
public static SCR DecodeSCR(byte[] response)
{
if(response == null)
return null;
if(response.Length != 8)
return null;
SCR scr = new SCR();
scr.Structure = (byte)((response[0] & 0xF0) >> 4);
scr.Spec = (byte)(response[0] & 0x0F);
scr.DataStatusAfterErase = (response[1] & 0x80) == 0x80;
scr.Security = (byte)((response[1] & 0x70) >> 4);
scr.BusWidth = (byte)(response[1] & 0x0F);
scr.Spec3 = (response[2] & 0x80) == 0x80;
scr.ExtendedSecurity = (byte)((response[2] & 0x78) >> 3);
scr.Spec4 = (response[2] & 0x04) == 0x04;
scr.SpecX = (byte)(((response[2] & 0x03) << 2) + ((response[3] & 0xC0) >> 6));
scr.CommandSupport = (byte)(response[3] & 0x0F);
scr.ManufacturerReserved = new byte[4];
Array.Copy(response, 4, scr.ManufacturerReserved, 0, 4);
return scr;
}
public static string PrettifySCR(SCR scr)
{
if(scr == null)
return null;
StringBuilder sb = new StringBuilder();
sb.AppendLine("SecureDigital Device Configuration Register:");
if(scr.Structure != 0)
sb.AppendFormat("\tUnknown register version {0}", scr.Structure).AppendLine();
if(scr.Spec == 0 && scr.Spec3 == false && scr.Spec4 == false && scr.SpecX == 0)
sb.AppendLine("\tDevice follows SecureDigital Physical Layer Specification version 1.0x");
else if(scr.Spec == 1 && scr.Spec3 == false && scr.Spec4 == false && scr.SpecX == 0)
sb.AppendLine("\tDevice follows SecureDigital Physical Layer Specification version 1.10");
else if(scr.Spec == 2 && scr.Spec3 == false && scr.Spec4 == false && scr.SpecX == 0)
sb.AppendLine("\tDevice follows SecureDigital Physical Layer Specification version 2.00");
else if(scr.Spec == 2 && scr.Spec3 == true && scr.Spec4 == false && scr.SpecX == 0)
sb.AppendLine("\tDevice follows SecureDigital Physical Layer Specification version 3.0x");
else if(scr.Spec == 2 && scr.Spec3 == true && scr.Spec4 == true && scr.SpecX == 0)
sb.AppendLine("\tDevice follows SecureDigital Physical Layer Specification version 4.xx");
else if(scr.Spec == 2 && scr.Spec3 == true && scr.SpecX == 1)
sb.AppendLine("\tDevice follows SecureDigital Physical Layer Specification version 5.xx");
else
sb.AppendFormat("\tDevice follows SecureDigital Physical Layer Specification with unknown version {0}.{1}.{2}.{3}",
scr.Spec, scr.Spec3, scr.Spec4, scr.SpecX).AppendLine();
switch(scr.Security)
{
case 0:
sb.AppendLine("\tDevice does not support CPRM");
break;
case 1:
sb.AppendLine("\tDevice does not use CPRM");
break;
case 2:
sb.AppendLine("\tDevice uses CPRM according to specification version 1.01");
break;
case 3:
sb.AppendLine("\tDevice uses CPRM according to specification version 2.00");
break;
case 4:
sb.AppendLine("\tDevice uses CPRM according to specification version 3.xx");
break;
default:
sb.AppendFormat("\tDevice uses unknown CPRM specification with code {0}", scr.Security).AppendLine();
break;
}
if((scr.BusWidth & 0x01) == 0x01)
sb.AppendLine("\tDevice supports 1-bit data bus");
if((scr.BusWidth & 0x04) == 0x04)
sb.AppendLine("\tDevice supports 4-bit data bus");
if(scr.ExtendedSecurity != 0)
sb.AppendLine("\tDevice supports extended security");
if((scr.CommandSupport & 0x08) == 0x08)
sb.AppendLine("\tDevice supports extension register multi-block commands");
if((scr.CommandSupport & 0x04) == 0x04)
sb.AppendLine("\tDevice supports extension register single-block commands");
if((scr.CommandSupport & 0x02) == 0x02)
sb.AppendLine("\tDevice supports set block count command");
if((scr.CommandSupport & 0x01) == 0x01)
sb.AppendLine("\tDevice supports speed class control command");
return sb.ToString();
}
public static string PrettifySCR(uint[] response)
{
return PrettifySCR(DecodeSCR(response));
}
public static string PrettifySCR(byte[] response)
{
return PrettifySCR(DecodeSCR(response));
}
}
}

View File

@@ -0,0 +1,46 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : VendorString.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
namespace DiscImageChef.Decoders.SecureDigital
{
public static class VendorString
{
public static string Prettify(byte SDVendorID)
{
switch(SDVendorID)
{
default:
return string.Format("Unknown manufacturer ID 0x{0:X2}", SDVendorID);
}
}
}
}

View File

@@ -1,3 +1,19 @@
2016-10-22 Natalia Portillo <claunia@claunia.com>
* Enums.cs:
* Command.cs:
* Enums.cs:
* Extern.cs:
* Command.cs:
* Structs.cs:
* Commands.cs:
* Constructor.cs:
* MMC.cs:
* DiscImageChef.Devices.csproj:
* SecureDigital.cs: Add MMC/SecureDigital device support. Not
yet used because of a bad implementation of SEND_CSD and
SEND_CID commands (TODO).
2016-10-17 Natalia Portillo <claunia@claunia.com> 2016-10-17 Natalia Portillo <claunia@claunia.com>
* Variables.cs: * Variables.cs:

View File

@@ -219,6 +219,34 @@ namespace DiscImageChef.Devices
throw new InvalidOperationException(string.Format("Platform {0} not yet supported.", ptID)); throw new InvalidOperationException(string.Format("Platform {0} not yet supported.", ptID));
} }
} }
public static int SendMmcCommand(object fd, MmcCommands command, bool write, bool isApplication,
MmcFlags flags, uint argument, uint blockSize, uint blocks,
ref byte[] buffer, out uint[] response, out double duration, out bool sense, uint timeout = 0)
{
Interop.PlatformID ptID = DetectOS.GetRealPlatformID();
return SendMmcCommand(ptID, (int)fd, command, write, isApplication, flags, argument, blockSize, blocks, ref buffer, out response, out duration, out sense, timeout);
}
public static int SendMmcCommand(Interop.PlatformID ptID, object fd, MmcCommands command, bool write, bool isApplication,
MmcFlags flags, uint argument, uint blockSize, uint blocks, ref byte[] buffer,
out uint[] response, out double duration, out bool sense, uint timeout = 0)
{
switch(ptID)
{
case Interop.PlatformID.Win32NT:
{
throw new NotImplementedException();
}
case Interop.PlatformID.Linux:
{
return Linux.Command.SendMmcCommand((int)fd, command, write, isApplication, flags, argument, blockSize, blocks, ref buffer, out response, out duration, out sense, timeout);
}
default:
throw new InvalidOperationException(string.Format("Platform {0} not yet supported.", ptID));
}
}
} }
} }

View File

@@ -114,6 +114,30 @@ namespace DiscImageChef.Devices
return Command.SendAtaCommand(platformID, fd, registers, out errorRegisters, protocol, transferRegister, return Command.SendAtaCommand(platformID, fd, registers, out errorRegisters, protocol, transferRegister,
ref buffer, timeout, transferBlocks, out duration, out sense); ref buffer, timeout, transferBlocks, out duration, out sense);
} }
/// <summary>
/// Sends a MMC/SD command to this device
/// </summary>
/// <returns>The result of the command.</returns>
/// <param name="command">MMC/SD opcode</param>
/// <param name="buffer">Buffer for MMC/SD command response</param>
/// <param name="timeout">Timeout in seconds</param>
/// <param name="duration">Time it took to execute the command in milliseconds</param>
/// <param name="sense"><c>True</c> if MMC/SD returned non-OK status</param>
/// <param name="write"><c>True</c> if data is sent from host to card</param>
/// <param name="isApplication"><c>True</c> if command should be preceded with CMD55</param>
/// <param name="flags">Flags indicating kind and place of response</param>
/// <param name="blocks">How many blocks to transfer</param>
/// <param name="argument">Command argument</param>
/// <param name="response">Response registers</param>
/// <param name="blockSize">Size of block in bytes</param>
public int SendMmcCommand(MmcCommands command, bool write, bool isApplication, MmcFlags flags,
uint argument, uint blockSize, uint blocks, ref byte[] buffer, out uint[] response,
out double duration, out bool sense, uint timeout = 0)
{
return Command.SendMmcCommand(platformID, fd, command, write, isApplication, flags, argument, blockSize, blocks,
ref buffer, out response, out duration, out sense, timeout);
}
} }
} }

View File

@@ -90,6 +90,41 @@ namespace DiscImageChef.Devices
type = DeviceType.Unknown; type = DeviceType.Unknown;
scsiType = Decoders.SCSI.PeripheralDeviceTypes.UnknownDevice; scsiType = Decoders.SCSI.PeripheralDeviceTypes.UnknownDevice;
// TODO: This is getting error -110 in Linux. Apparently I should set device to standby, request CID/CSD, put device to transition. However I can't get it right now.
/*
try
{
byte[] csdBuf;
byte[] scrBuf;
uint[] mmcResponse;
double mmcDuration;
bool mmcSense = ReadCID(out csdBuf, out mmcResponse, 0, out mmcDuration);
if(!mmcSense)
{
mmcSense = ReadSCR(out scrBuf, out mmcResponse, 0, out mmcDuration);
if(!mmcSense)
type = DeviceType.SecureDigital;
else
type = DeviceType.MMC;
manufacturer = "To be filled manufacturer";
model = "To be filled model";
revision = "To be filled revision";
serial = "To be filled serial";
scsiType = Decoders.SCSI.PeripheralDeviceTypes.DirectAccess;
removable = false;
return;
}
else
System.Console.WriteLine("Error {0}: {1}", error, lastError);
}
catch(NotImplementedException) { }
catch(InvalidOperationException) { }
*/
AtaErrorRegistersCHS errorRegisters; AtaErrorRegistersCHS errorRegisters;
byte[] ataBuf; byte[] ataBuf;
@@ -288,7 +323,6 @@ namespace DiscImageChef.Devices
pcmcia = false; pcmcia = false;
#endregion PCMCIA #endregion PCMCIA
if(!scsiSense) if(!scsiSense)
{ {
Decoders.SCSI.Inquiry.SCSIInquiry? Inquiry = Decoders.SCSI.Inquiry.Decode(inqBuf); Decoders.SCSI.Inquiry.SCSIInquiry? Inquiry = Decoders.SCSI.Inquiry.Decode(inqBuf);

View File

@@ -0,0 +1,151 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : MMC.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using DiscImageChef.Console;
namespace DiscImageChef.Devices
{
public partial class Device
{
public bool ReadCSD(out byte[] buffer, out uint[] response, uint timeout, out double duration)
{
buffer = new byte[16];
bool sense = false;
lastError = SendMmcCommand(MmcCommands.SendCSD, false, false, MmcFlags.ResponseSPI_R1 | MmcFlags.Response_R1 | MmcFlags.CommandADTC,
0, 16, 1, ref buffer, out response, out duration, out sense, timeout);
error = lastError != 0;
DicConsole.DebugWriteLine("MMC Device", "SEND_CSD took {0} ms.", duration);
return sense;
}
public bool ReadCID(out byte[] buffer, out uint[] response, uint timeout, out double duration)
{
buffer = new byte[16];
bool sense = false;
lastError = SendMmcCommand(MmcCommands.SendCID, false, false, MmcFlags.ResponseSPI_R1 | MmcFlags.Response_R1 | MmcFlags.CommandADTC,
0, 16, 1, ref buffer, out response, out duration, out sense, timeout);
error = lastError != 0;
DicConsole.DebugWriteLine("MMC Device", "SEND_CID took {0} ms.", duration);
return sense;
}
public bool ReadOCR(out byte[] buffer, out uint[] response, uint timeout, out double duration)
{
buffer = new byte[4];
bool sense = false;
lastError = SendMmcCommand(MmcCommands.SendOpCond, false, true, MmcFlags.ResponseSPI_R3 | MmcFlags.Response_R3 | MmcFlags.CommandBCR,
0, 4, 1, ref buffer, out response, out duration, out sense, timeout);
error = lastError != 0;
DicConsole.DebugWriteLine("SecureDigital Device", "SEND_OP_COND took {0} ms.", duration);
return sense;
}
public bool ReadExtendedCSD(out byte[] buffer, out uint[] response, uint timeout, out double duration)
{
buffer = new byte[512];
bool sense = false;
lastError = SendMmcCommand(MmcCommands.SendExtCSD, false, false, MmcFlags.ResponseSPI_R1 | MmcFlags.Response_R1 | MmcFlags.CommandADTC,
0, 512, 1, ref buffer, out response, out duration, out sense, timeout);
error = lastError != 0;
DicConsole.DebugWriteLine("MMC Device", "SEND_EXT_CSD took {0} ms.", duration);
return sense;
}
public bool SetBlockLength(uint length, out uint[] response, uint timeout, out double duration)
{
byte[] buffer = new byte[0];
bool sense = false;
lastError = SendMmcCommand(MmcCommands.SetBlocklen, false, false, MmcFlags.ResponseSPI_R1 | MmcFlags.Response_R1 | MmcFlags.CommandAC,
length, 0, 0, ref buffer, out response, out duration, out sense, timeout);
error = lastError != 0;
DicConsole.DebugWriteLine("MMC Device", "SET_BLOCKLEN took {0} ms.", duration);
return sense;
}
public bool Read(out byte[] buffer, out uint[] response, uint lba, uint blockSize, uint transferLength, bool byteAddressed, uint timeout, out double duration)
{
buffer = new byte[transferLength * blockSize];
bool sense = false;
uint address;
if(byteAddressed)
address = lba * blockSize;
else
address = lba;
MmcCommands command;
if(transferLength > 1)
command = MmcCommands.ReadMultipleBlock;
else
command = MmcCommands.ReadSingleBlock;
lastError = SendMmcCommand(command, false, false, MmcFlags.ResponseSPI_R1 | MmcFlags.Response_R1 | MmcFlags.CommandADTC,
address, blockSize, transferLength, ref buffer, out response, out duration, out sense, timeout);
error = lastError != 0;
if(transferLength > 1)
DicConsole.DebugWriteLine("MMC Device", "READ_MULTIPLE_BLOCK took {0} ms.", duration);
else
DicConsole.DebugWriteLine("MMC Device", "READ_SINGLE_BLOCK took {0} ms.", duration);
return sense;
}
public bool ReadStatus(out byte[] buffer, out uint[] response, uint timeout, out double duration)
{
buffer = new byte[4];
bool sense = false;
lastError = SendMmcCommand(MmcCommands.SendStatus, false, true, MmcFlags.ResponseSPI_R1 | MmcFlags.Response_R1 | MmcFlags.CommandADTC,
0, 4, 1, ref buffer, out response, out duration, out sense, timeout);
error = lastError != 0;
DicConsole.DebugWriteLine("SecureDigital Device", "SEND_STATUS took {0} ms.", duration);
return sense;
}
}
}

View File

@@ -0,0 +1,81 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : SecureDigital.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using DiscImageChef.Console;
namespace DiscImageChef.Devices
{
public partial class Device
{
public bool ReadSDStatus(out byte[] buffer, out uint[] response, uint timeout, out double duration)
{
buffer = new byte[64];
bool sense = false;
lastError = SendMmcCommand((MmcCommands)SecureDigitalCommands.SendStatus, false, true, MmcFlags.ResponseSPI_R1 | MmcFlags.Response_R1 | MmcFlags.CommandADTC,
0, 64, 1, ref buffer, out response, out duration, out sense, timeout);
error = lastError != 0;
DicConsole.DebugWriteLine("SecureDigital Device", "SD_STATUS took {0} ms.", duration);
return sense;
}
public bool ReadSDOCR(out byte[] buffer, out uint[] response, uint timeout, out double duration)
{
buffer = new byte[4];
bool sense = false;
lastError = SendMmcCommand((MmcCommands)SecureDigitalCommands.SendOperatingCondition, false, true, MmcFlags.ResponseSPI_R3 | MmcFlags.Response_R3 | MmcFlags.CommandBCR,
0, 4, 1, ref buffer, out response, out duration, out sense, timeout);
error = lastError != 0;
DicConsole.DebugWriteLine("SecureDigital Device", "SD_SEND_OP_COND took {0} ms.", duration);
return sense;
}
public bool ReadSCR(out byte[] buffer, out uint[] response, uint timeout, out double duration)
{
buffer = new byte[8];
bool sense = false;
lastError = SendMmcCommand((MmcCommands)SecureDigitalCommands.SendSCR, false, true, MmcFlags.ResponseSPI_R1 | MmcFlags.Response_R1 | MmcFlags.CommandADTC,
0, 8, 1, ref buffer, out response, out duration, out sense, timeout);
error = lastError != 0;
DicConsole.DebugWriteLine("SecureDigital Device", "SEND_SCR took {0} ms.", duration);
return sense;
}
}
}

View File

@@ -76,6 +76,8 @@
<Compile Include="FreeBSD\Enums.cs" /> <Compile Include="FreeBSD\Enums.cs" />
<Compile Include="FreeBSD\Extern.cs" /> <Compile Include="FreeBSD\Extern.cs" />
<Compile Include="FreeBSD\Structs.cs" /> <Compile Include="FreeBSD\Structs.cs" />
<Compile Include="Device\MmcCommands\MMC.cs" />
<Compile Include="Device\MmcCommands\SecureDigital.cs" />
</ItemGroup> </ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<ItemGroup> <ItemGroup>
@@ -85,6 +87,7 @@
<Folder Include="Device\ScsiCommands\" /> <Folder Include="Device\ScsiCommands\" />
<Folder Include="Device\AtaCommands\" /> <Folder Include="Device\AtaCommands\" />
<Folder Include="FreeBSD\" /> <Folder Include="FreeBSD\" />
<Folder Include="Device\MmcCommands\" />
</ItemGroup> </ItemGroup>
<ProjectExtensions> <ProjectExtensions>
<MonoDevelop> <MonoDevelop>
@@ -92,8 +95,8 @@
<Policies> <Policies>
<DotNetNamingPolicy DirectoryNamespaceAssociation="PrefixedHierarchical" ResourceNamePolicy="MSBuild" /> <DotNetNamingPolicy DirectoryNamespaceAssociation="PrefixedHierarchical" ResourceNamePolicy="MSBuild" />
<StandardHeader Text="/***************************************************************************&#xA;The Disc Image Chef&#xA;----------------------------------------------------------------------------&#xA; &#xA;Filename : ${FileName}&#xA;Author(s) : ${AuthorName} &lt;${AuthorEmail}&gt;&#xA;&#xA;Component : Component&#xA; &#xA;--[ Description ] ----------------------------------------------------------&#xA; &#xA; Description&#xA; &#xA;--[ License ] --------------------------------------------------------------&#xA; &#xA; This library is free software; you can redistribute it and/or modify&#xA; it under the terms of the GNU Lesser General Public License as&#xA; published by the Free Software Foundation; either version 2.1 of the&#xA; License, or (at your option) any later version.&#xA;&#xA; This library is distributed in the hope that it will be useful, but&#xA; WITHOUT ANY WARRANTY; without even the implied warranty of&#xA; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU&#xA; Lesser General Public License for more details.&#xA;&#xA; You should have received a copy of the GNU Lesser General Public&#xA; License along with this library; if not, see &lt;http://www.gnu.org/licenses/&gt;.&#xA;&#xA;----------------------------------------------------------------------------&#xA;Copyright © 2011-${Year} ${CopyrightHolder}&#xA;****************************************************************************/" IncludeInNewFiles="True" /> <StandardHeader Text="/***************************************************************************&#xA;The Disc Image Chef&#xA;----------------------------------------------------------------------------&#xA; &#xA;Filename : ${FileName}&#xA;Author(s) : ${AuthorName} &lt;${AuthorEmail}&gt;&#xA;&#xA;Component : Component&#xA; &#xA;--[ Description ] ----------------------------------------------------------&#xA; &#xA; Description&#xA; &#xA;--[ License ] --------------------------------------------------------------&#xA; &#xA; This library is free software; you can redistribute it and/or modify&#xA; it under the terms of the GNU Lesser General Public License as&#xA; published by the Free Software Foundation; either version 2.1 of the&#xA; License, or (at your option) any later version.&#xA;&#xA; This library is distributed in the hope that it will be useful, but&#xA; WITHOUT ANY WARRANTY; without even the implied warranty of&#xA; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU&#xA; Lesser General Public License for more details.&#xA;&#xA; You should have received a copy of the GNU Lesser General Public&#xA; License along with this library; if not, see &lt;http://www.gnu.org/licenses/&gt;.&#xA;&#xA;----------------------------------------------------------------------------&#xA;Copyright © 2011-${Year} ${CopyrightHolder}&#xA;****************************************************************************/" IncludeInNewFiles="True" />
<TextStylePolicy FileWidth="120" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/x-csharp" /> <TextStylePolicy TabWidth="4" TabsToSpaces="True" IndentWidth="4" RemoveTrailingWhitespace="True" NoTabsAfterNonTabs="False" EolMarker="Native" FileWidth="120" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/x-csharp" />
<CSharpFormattingPolicy IndentSwitchSection="True" NewLinesForBracesInProperties="True" NewLinesForBracesInAccessors="True" NewLinesForBracesInAnonymousMethods="True" NewLinesForBracesInControlBlocks="True" NewLinesForBracesInAnonymousTypes="True" NewLinesForBracesInObjectCollectionArrayInitializers="True" NewLinesForBracesInLambdaExpressionBody="True" NewLineForElse="True" NewLineForCatch="True" NewLineForFinally="True" NewLineForMembersInObjectInit="True" NewLineForMembersInAnonymousTypes="True" NewLineForClausesInQuery="True" SpacingAfterMethodDeclarationName="False" SpaceAfterMethodCallName="False" SpaceAfterControlFlowStatementKeyword="False" SpaceBeforeOpenSquareBracket="False" inheritsSet="Mono" inheritsScope="text/x-csharp" scope="text/x-csharp" /> <CSharpFormattingPolicy IndentBlock="True" IndentBraces="False" IndentSwitchCaseSection="True" LabelPositioning="OneLess" NewLinesForBracesInTypes="True" NewLinesForBracesInMethods="True" SpaceWithinMethodDeclarationParenthesis="False" SpaceBetweenEmptyMethodDeclarationParentheses="False" SpaceWithinMethodCallParentheses="False" SpaceBetweenEmptyMethodCallParentheses="False" SpaceWithinExpressionParentheses="False" SpaceWithinCastParentheses="False" SpaceWithinOtherParentheses="False" SpaceAfterCast="False" SpacesIgnoreAroundVariableDeclaration="False" SpaceBetweenEmptySquareBrackets="False" SpaceWithinSquareBrackets="False" SpaceAfterColonInBaseTypeDeclaration="True" SpaceAfterComma="True" SpaceAfterDot="False" SpaceAfterSemicolonsInForStatement="True" SpaceBeforeColonInBaseTypeDeclaration="True" SpaceBeforeComma="False" SpaceBeforeDot="False" SpaceBeforeSemicolonsInForStatement="False" SpacingAroundBinaryOperator="Single" WrappingPreserveSingleLine="True" WrappingKeepStatementsOnSingleLine="True" PlaceSystemDirectiveFirst="True" IndentSwitchSection="True" NewLinesForBracesInProperties="True" NewLinesForBracesInAccessors="True" NewLinesForBracesInAnonymousMethods="True" NewLinesForBracesInControlBlocks="True" NewLinesForBracesInAnonymousTypes="True" NewLinesForBracesInObjectCollectionArrayInitializers="True" NewLinesForBracesInLambdaExpressionBody="True" NewLineForElse="True" NewLineForCatch="True" NewLineForFinally="True" NewLineForMembersInObjectInit="True" NewLineForMembersInAnonymousTypes="True" NewLineForClausesInQuery="True" SpacingAfterMethodDeclarationName="False" SpaceAfterMethodCallName="False" SpaceAfterControlFlowStatementKeyword="False" SpaceBeforeOpenSquareBracket="False" inheritsSet="Mono" inheritsScope="text/x-csharp" scope="text/x-csharp" />
</Policies> </Policies>
</Properties> </Properties>
</MonoDevelop> </MonoDevelop>

View File

@@ -3455,5 +3455,355 @@ namespace DiscImageChef.Devices
Obsolete1 = 4, Obsolete1 = 4,
Obsolete2 = 5 Obsolete2 = 5
} }
/// <summary>
/// MMC / SecureDigital commands
/// </summary>
public enum MmcCommands : byte
{
#region Class 1 MMC Commands (Basic and read-stream)
/// <summary>
/// Resets device to idle (BC)
/// </summary>
GoIdle = 0,
/// <summary>
/// Resets the device to pre-idle (BC)
/// </summary>
GoPreIdleState = 0,
/// <summary>
/// Initiate alternative boot operation
/// </summary>
BootInitiation = 0,
/// <summary>
/// Asks device in idle state to send their operation conditions in response (BCR, R3)
/// </summary>
SendOpCond = 1,
/// <summary>
/// Asks device to send their CID numbers (BCR, R2)
/// </summary>
AllSendCID = 2,
/// <summary>
/// Assigns a relative address to the device (AC, R1)
/// </summary>
SetRelativeAddress = 3,
/// <summary>
/// Programs the DSR of the device (BC)
/// </summary>
SetDSR = 4,
/// <summary>
/// Toggles the device between sleep and standby (AC, R1b)
/// </summary>
SleepAwake = 5,
/// <summary>
/// Switches device mode of operation (AC, R1b)
/// </summary>
Switch = 6,
/// <summary>
/// Toggles a device between the stand-by and transfer stats or between the programming and disconnect states (AC, R1b)
/// </summary>
SelectCard = 7,
/// <summary>
/// Asks device to send its extended card-specific data (ExtCSD) (ADTC, R1)
/// </summary>
SendExtCSD = 8,
/// <summary>
/// Asks device to send its card-specific data (CSD) (AC, R2)
/// </summary>
SendCSD = 9,
/// <summary>
/// Asks device to send its card identification (CID) (AC, R2)
/// </summary>
SendCID = 10,
/// <summary>
/// Reads data stream from device, starting at given address, until a <see cref="StopTransmission"/> follows (ADTC, R1)
/// </summary>
[Obsolete]
ReadDatUntilStop = 11,
/// <summary>
/// Terminates a read/write stream/multiple block operation (AC, R1 / R1b)
/// </summary>
StopTransmission = 12,
/// <summary>
/// Asks device to send its status register (AC, R1)
/// </summary>
SendStatus = 13,
/// <summary>
/// The host reads the reversed bus testing data pattern from a device (ADTC, R1)
/// </summary>
BusTestRead = 14,
/// <summary>
/// Sets the card to inactive state (AC)
/// </summary>
GoInactiveState = 15,
/// <summary>
/// The host sends the bus testing data pattern to a device (ADTC, R1)
/// </summary>
BusTestWrite = 19,
SPIReadOCR = 58,
SPICRCOnOff = 59,
#endregion Class 1 MMC Commands (Basic and read-stream)
#region Class 2 MMC Commands (Block-oriented read)
/// <summary>
/// Sets the block length in bytes (AC, R1)
/// </summary>
SetBlocklen = 16,
/// <summary>
/// Reads a block (ADTC, R1)
/// </summary>
ReadSingleBlock = 17,
/// <summary>
/// Transfers data blocks from card to host until interrupted (ADTC, R1)
/// </summary>
ReadMultipleBlock = 18,
/// <summary>
/// 128 blocks of tuning pattern is sent for HS200 optimal sampling point detection (ADTC, R1)
/// </summary>
SendTuningBlockHS200 = 21,
#endregion Class 2 MMC Commands (Block-oriented read)
#region Class 3 MMC Commands (Stream write)
/// <summary>
/// Writes data stream from host until a <see cref="StopTransmission"/> follows (ADTC, R1)
/// </summary>
[Obsolete]
WriteDatUntilStop = 20,
#endregion Class 3 MMC Commands (Stream write)
#region Class 4 MMC Commands (Block-oriented write)
/// <summary>
/// Defines the number of blocks which are going to be transferred in the immediately succeeding multiple block command (AC, R1)
/// </summary>
SetBlockCount = 23,
/// <summary>
/// Writes a block (ADTC, R1)
/// </summary>
WriteBlock = 24,
/// <summary>
/// Continuosly writes blocks until interrupted (ADTC, R1)
/// </summary>
WriteMultipleBlock = 25,
/// <summary>
/// Programs the Card Information register (ADTC, R1)
/// </summary>
ProgramCID = 26,
/// <summary>
/// Programs the programmable bits of the CSD (ADTC, R1)
/// </summary>
ProgramCSD = 27,
/// <summary>
/// Sets the real time clock according to information in block (ADTC, R1)
/// </summary>
SetTime = 49,
#endregion Class 4 MMC Commands (Block-oriented write)
#region Class 5 MMC Commands (Erase)
/// <summary>
/// Sets the address of the first erase group (AC, R1)
/// </summary>
EraseGroupStart = 35,
/// <summary>
/// Sets the address of the last erase group (AC, R1)
/// </summary>
EraseGroupEnd = 36,
/// <summary>
/// Erases previously selected write blocks (AC, R1b)
/// </summary>
Erase = 38,
#endregion Class 5 MMC Commands (Erase)
#region Class 6 MMC Commands (Block-oriented write protection)
/// <summary>
/// Sets the write protection bit (AC, R1b)
/// </summary>
SetWriteProtect = 28,
/// <summary>
/// Clears the write protection bit (AC, R1b)
/// </summary>
ClearWriteProtect = 29,
/// <summary>
/// Asks the device to send the status of the write protection bit (ADTC, R1)
/// </summary>
SendWriteProtect = 30,
/// <summary>
/// Sends the type of write protection that is set for the different write protection groups (ADTC, R1)
/// </summary>
SentWriteProtectType = 31,
#endregion Class 6 MMC Commands (Block-oriented write protection)
#region Class 7 MMC Commands (Lock)
/// <summary>
/// Used to set/reset the password or lock/unlock the card (ADTC, R1b)
/// </summary>
LockUnlock = 42,
#endregion Class 7 MMC Commands (Lock)
#region Class 8 MMC Commands (Application-specific)
/// <summary>
/// Indicates the card that the next command is an application specific command (AC, R1)
/// </summary>
ApplicationCommand = 55,
/// <summary>
/// Transfers a data block to/from the card for general purpose / application specific commands (ADTC, R1b)
/// </summary>
GenericCommand = 56,
#endregion Class 8 MMC Commands (Application-specific)
#region Class 9 MMC Commands (I/O mode)
/// <summary>
/// Used to write and read 8 bit data field, used to access application dependent registers not defined in MMC standard (AC, R4)
/// </summary>
FastIO = 39,
/// <summary>
/// Sets the system into interrupt mode (BCR, R5)
/// </summary>
GoIRQState = 40,
#endregion Class 9 MMC Commands (I/O mode)
#region Class 10 MMC Commands (Security Protocols)
/// <summary>
/// Reads data blocks (ADTC, R1)
/// </summary>
ProtocolRead = 53,
/// <summary>
/// Writes data blocks (ADTC, R1)
/// </summary>
ProtocolWrite = 54,
#endregion Class 10 MMC Commands (Security Protocols)
#region Class 11 MMC Commands (Command Queue)
/// <summary>
/// Defines data direction, priority, task ID and block count of queued task (AC, R1)
/// </summary>
QueuedTaskParameters = 44,
/// <summary>
/// Defines the block address of queued task (AC, R1)
/// </summary>
QueuedTaskAddress = 45,
/// <summary>
/// Executes the task queue for reading (ADTC, R1)
/// </summary>
ExecuteTaskRead = 46,
/// <summary>
/// Executes the task queue for writing (ADTC, R1)
/// </summary>
ExecuteTaskWrite = 47,
/// <summary>
/// Manages queues and tasks (AC, R1b)
/// </summary>
CmdQTaskManagement = 48,
#endregion Class 11 MMC Commands (Command Queue)
#region Class 1 SecureDigital Commands (Basic)
/// <summary>
/// Sends SD interface condition (BCR, R7)
/// </summary>
SendInterfaceCondition = 8,
/// <summary>
/// Switch to 1.8V bus signaling level (AC, R1)
/// </summary>
VoltageSwitch = 11,
#endregion Class 1 SecureDigital Commands (Basic)
#region Class 2 SecureDigital Commands (Block-oriented read)
/// <summary>
/// 64 bytes of tuning pattern is sent for SDR50 and SDR104 optinal sampling point detection (ADTC, R1)
/// </summary>
SendTuningBlock = 19,
/// <summary>
/// Speed class control command (AC, R1b)
/// </summary>
SpeedClassControl = 20,
#endregion Class 2 SecureDigital Commands (Block-oriented read)
#region Class 11 SecureDigital Commands (Function Extension)
/// <summary>
/// Single block read type (ADTC, R1)
/// </summary>
ReadExtraSingle = 48,
/// <summary>
/// Single block write type (ADTC, R1)
/// </summary>
WriteExtraSingle = 49,
/// <summary>
/// Multiple block read type (ADTC, R1)
/// </summary>
ReadExtraMulti = 58,
/// <summary>
/// Multiple block write type (ADTC, R1)
/// </summary>
WriteExtraMulti = 59,
#endregion Class 11 SecureDigital Commands (Function Extension)
}
/// <summary>
/// SecureDigital application-specific commands
/// </summary>
public enum SecureDigitalCommands : byte
{
/// <summary>
/// Defines the data bus width to be used for data transfer (AC, R1)
/// </summary>
SetBusWidth = 6,
/// <summary>
/// Sends the SD status register (ADTC, R1)
/// </summary>
SendStatus = 13,
/// <summary>
/// Send the number of the written write blocks (ADTC, R1)
/// </summary>
SendNumWriteBlocks = 22,
/// <summary>
/// Set the number of write blocks to be pre-erased before writing (AC, R1)
/// </summary>
SetWriteBlockEraseCount = 23,
/// <summary>
/// Sends host capacity support information and asks the card to send its operating condition register (BCR, R3)
/// </summary>
SendOperatingCondition = 41,
/// <summary>
/// Connects/Disconnects the 50 kOhm pull-up resistor on CD/DAT3 pin of card (AC, R1)
/// </summary>
SetClearCardDetect = 42,
/// <summary>
/// Reads the SD Configuration Register SCR (ADTC, R1)
/// </summary>
SendSCR = 51,
}
[Flags]
public enum MmcFlags : uint
{
ResponsePresent = 1 << 0,
Response136 = 1 << 1,
ResponseCrc = 1 << 2,
ResponseBusy = 1 << 3,
ResponseOpcode = 1 << 4,
CommandMask = 3 << 5,
CommandAC = 0 << 5,
CommandADTC = 1 << 5,
CommandBC = 2 << 5,
CommandBCR = 3 << 5,
ResponseSPI_S1 = 1 << 7,
ResponseSPI_S2 = 1 << 8,
ResponseSPI_B4 = 1 << 9,
ResponseSPI_Busy = 1 << 10,
ResponseNone = 0,
Response_R1 = ResponsePresent | ResponseCrc | ResponseOpcode,
Response_R1b = ResponsePresent | ResponseCrc | ResponseOpcode | ResponseBusy,
Response_R2 = ResponsePresent | Response136 | ResponseCrc,
Response_R3 = ResponsePresent,
Response_R4 = ResponsePresent,
Response_R5 = ResponsePresent | ResponseCrc | ResponseOpcode,
Response_R6 = ResponsePresent | ResponseCrc | ResponseOpcode,
Response_R7 = ResponsePresent | ResponseCrc | ResponseOpcode,
ResponseSPI_R1 = ResponseSPI_S1,
ResponseSPI_R1b = ResponseSPI_S1 | ResponseSPI_Busy,
ResponseSPI_R2 = ResponseSPI_S1 | ResponseSPI_S2,
ResponseSPI_R3 = ResponseSPI_S1 | ResponseSPI_B4,
ResponseSPI_R4 = ResponseSPI_S1 | ResponseSPI_B4,
ResponseSPI_R5 = ResponseSPI_S1 | ResponseSPI_S2,
ResponseSPI_R7 = ResponseSPI_S1 | ResponseSPI_B4
}
} }

View File

@@ -328,6 +328,71 @@ namespace DiscImageChef.Devices.Linux
return error; return error;
} }
/// <summary>
/// Sends a MMC/SD command
/// </summary>
/// <returns>The result of the command.</returns>
/// <param name="fd">File handle</param>
/// <param name="command">MMC/SD opcode</param>
/// <param name="buffer">Buffer for MMC/SD command response</param>
/// <param name="timeout">Timeout in seconds</param>
/// <param name="duration">Time it took to execute the command in milliseconds</param>
/// <param name="sense"><c>True</c> if MMC/SD returned non-OK status</param>
/// <param name="write"><c>True</c> if data is sent from host to card</param>
/// <param name="isApplication"><c>True</c> if command should be preceded with CMD55</param>
/// <param name="flags">Flags indicating kind and place of response</param>
/// <param name="blocks">How many blocks to transfer</param>
/// <param name="argument">Command argument</param>
/// <param name="response">Response registers</param>
/// <param name="blockSize">Size of block in bytes</param>
internal static int SendMmcCommand(int fd, MmcCommands command, bool write, bool isApplication, MmcFlags flags, uint argument, uint blockSize, uint blocks, ref byte[] buffer, out uint[] response, out double duration, out bool sense, uint timeout = 0)
{
response = null;
duration = 0;
sense = false;
if(buffer == null)
return -1;
mmc_ioc_cmd io_cmd = new mmc_ioc_cmd();
IntPtr bufPtr = Marshal.AllocHGlobal(buffer.Length);
io_cmd.write_flag = write;
io_cmd.is_ascmd = isApplication;
io_cmd.opcode = (uint)command;
io_cmd.arg = argument;
io_cmd.flags = flags;
io_cmd.blksz = blockSize;
io_cmd.blksz = blocks;
if(timeout > 0)
{
io_cmd.data_timeout_ns = timeout * 1000000000;
io_cmd.cmd_timeout_ms = timeout * 1000;
}
io_cmd.data_ptr = (ulong)bufPtr;
Marshal.Copy(buffer, 0, bufPtr, buffer.Length);
DateTime start = DateTime.UtcNow;
int error = Extern.ioctlMmc(fd, LinuxIoctl.MMC_IOC_CMD, ref io_cmd);
DateTime end = DateTime.UtcNow;
sense |= error < 0;
if(error < 0)
error = Marshal.GetLastWin32Error();
Marshal.Copy(bufPtr, buffer, 0, buffer.Length);
response = io_cmd.response;
duration = (end - start).TotalMilliseconds;
Marshal.FreeHGlobal(bufPtr);
return error;
}
public static string ReadLink(string path) public static string ReadLink(string path)
{ {
IntPtr buf = Marshal.AllocHGlobal(4096); IntPtr buf = Marshal.AllocHGlobal(4096);

View File

@@ -145,6 +145,8 @@ namespace DiscImageChef.Devices.Linux
// SCSI IOCtls // SCSI IOCtls
SG_GET_VERSION_NUM = 0x2282, SG_GET_VERSION_NUM = 0x2282,
SG_IO = 0x2285, SG_IO = 0x2285,
// MMC IOCtl
MMC_IOC_CMD = 0xC048B300
} }
[Flags] [Flags]

View File

@@ -52,6 +52,9 @@ namespace DiscImageChef.Devices.Linux
[DllImport("libc", EntryPoint = "ioctl", SetLastError = true)] [DllImport("libc", EntryPoint = "ioctl", SetLastError = true)]
internal static extern int ioctlSg(int fd, LinuxIoctl request, ref sg_io_hdr_t value); internal static extern int ioctlSg(int fd, LinuxIoctl request, ref sg_io_hdr_t value);
[DllImport("libc", EntryPoint = "ioctl", SetLastError = true)]
internal static extern int ioctlMmc(int fd, LinuxIoctl request, ref mmc_ioc_cmd value);
[DllImport("libc", CharSet = CharSet.Ansi, SetLastError = true)] [DllImport("libc", CharSet = CharSet.Ansi, SetLastError = true)]
internal static extern int readlink(string path, System.IntPtr buf, int bufsize); internal static extern int readlink(string path, System.IntPtr buf, int bufsize);

View File

@@ -65,5 +65,62 @@ namespace DiscImageChef.Devices.Linux
public uint duration; /* [o] */ public uint duration; /* [o] */
public SgInfo info; /* [o] */ public SgInfo info; /* [o] */
} }
[StructLayout(LayoutKind.Sequential)]
struct mmc_ioc_cmd
{
/// <summary>
/// Implies direction of data. true = write, false = read
/// </summary>
public bool write_flag;
/// <summary>
/// Application-specific command. true = precede with CMD55
/// </summary>
public bool is_ascmd;
public uint opcode;
public uint arg;
/// <summary>
/// CMD response
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public uint[] response;
public MmcFlags flags;
public uint blksz;
public uint blocks;
/// <summary>
/// Sleep at least <see cref="postsleep_min_us"/> useconds, and at most
/// <see cref="postsleep_max_us"/> useconds *after* issuing command.Needed for
/// some read commands for which cards have no other way of indicating
/// they're ready for the next command (i.e. there is no equivalent of
/// a "busy" indicator for read operations).
/// </summary>
public uint postsleep_min_us;
/// <summary>
/// Sleep at least <see cref="postsleep_min_us"/> useconds, and at most
/// <see cref="postsleep_max_us"/> useconds *after* issuing command.Needed for
/// some read commands for which cards have no other way of indicating
/// they're ready for the next command (i.e. there is no equivalent of
/// a "busy" indicator for read operations).
/// </summary>
public uint postsleep_max_us;
/// <summary>
/// Override driver-computed timeouts.
/// </summary>
public uint data_timeout_ns;
/// <summary>
/// Override driver-computed timeouts.
/// </summary>
public uint cmd_timeout_ms;
/// <summary>
/// For 64-bit machines <see cref="data_ptr"/> , wants to
/// be 8-byte aligned.Make sure this struct is the same size when
/// built for 32-bit.
/// </summary>
public uint __pad;
/// <summary>
/// DAT buffer
/// </summary>
public ulong data_ptr;
}
} }