mirror of
https://github.com/aaru-dps/Aaru.Server.git
synced 2025-12-16 19:24:27 +00:00
1910 lines
94 KiB
C#
1910 lines
94 KiB
C#
// /***************************************************************************
|
|
// Aaru Data Preservation Suite
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Filename : Ata.cs
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
|
//
|
|
// Component : Aaru Server.
|
|
//
|
|
// --[ Description ] ----------------------------------------------------------
|
|
//
|
|
// Decodes ATA information from reports.
|
|
//
|
|
// --[ 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-2024 Natalia Portillo
|
|
// ****************************************************************************/
|
|
|
|
using Aaru.CommonTypes.Metadata;
|
|
using Aaru.CommonTypes.Structs.Devices.ATA;
|
|
using Aaru.CommonTypes.Structs.Devices.SCSI;
|
|
|
|
namespace Aaru.Server.New.Core;
|
|
|
|
// TODO: Use Humanizer
|
|
// TODO: Better use HTML and CSS
|
|
public static class Ata
|
|
{
|
|
/// <summary>
|
|
/// Takes the ATA part of a device report and prepares it to be rendered
|
|
/// </summary>
|
|
/// <param name="ataReport">ATA part of a device report</param>
|
|
/// <param name="cfa"><c>true</c> if compact flash device</param>
|
|
/// <param name="atapi"><c>true</c> if atapi device</param>
|
|
/// <param name="removable"><c>true</c> if removable device</param>
|
|
/// <param name="testedMedia">List of tested media</param>
|
|
/// <param name="deviceIdentification">List of device identification strings</param>
|
|
/// <param name="supportedAtaVersions">Supported ATA versions</param>
|
|
/// <param name="maximumAtaRevision">Maximum supported ATA revision</param>
|
|
/// <param name="transport">ATA transport layer</param>
|
|
/// <param name="transportVersions">Supported transport versions</param>
|
|
/// <param name="generalConfiguration">Device general configuration</param>
|
|
/// <param name="specificConfiguration">Device specific configuration</param>
|
|
/// <param name="deviceCapabilities">Device capabilities</param>
|
|
/// <param name="pioTransferModes">PIO transfer modes</param>
|
|
/// <param name="dmaTransferModes">Single-word DMA transfer modes</param>
|
|
/// <param name="mdmaTransferModes">Multi-word DMA transfer modes</param>
|
|
/// <param name="ultraDmaTransferModes">Ultra DMA transfer modes</param>
|
|
/// <param name="commandSetAndFeatures">Device command set and features</param>
|
|
/// <param name="security">Security parameters</param>
|
|
/// <param name="streaming">Streaming parameters</param>
|
|
/// <param name="smartCommandTransport">S.M.A.R.T. command transport</param>
|
|
/// <param name="nvCache">Non-volatile cache</param>
|
|
/// <param name="readCapabilitiesDictionary">Dictionary of read capabilities for non-removable media</param>
|
|
/// <param name="readCapabilitiesList">List of read capabilities for non-removable media</param>
|
|
public static void Report(CommonTypes.Metadata.Ata ataReport, bool cfa, bool atapi, ref bool removable,
|
|
out List<TestedMedia>? testedMedia, out Dictionary<string, string>? deviceIdentification,
|
|
out List<string> supportedAtaVersions, out string? maximumAtaRevision,
|
|
out string? transport, out List<string>? transportVersions,
|
|
out List<string> generalConfiguration, out List<string>? specificConfiguration,
|
|
out List<string> deviceCapabilities, out List<string> pioTransferModes,
|
|
out List<string> dmaTransferModes, out List<string> mdmaTransferModes,
|
|
out List<string> ultraDmaTransferModes, out List<string> commandSetAndFeatures,
|
|
out List<string>? security, out List<string>? streaming,
|
|
out List<string>? smartCommandTransport, out List<string>? nvCache,
|
|
out Dictionary<string, string> readCapabilitiesDictionary,
|
|
out List<string> readCapabilitiesList)
|
|
{
|
|
uint logicalSectorSize = 0;
|
|
testedMedia = null;
|
|
deviceIdentification = null;
|
|
supportedAtaVersions = [];
|
|
maximumAtaRevision = null;
|
|
transport = null;
|
|
transportVersions = null;
|
|
generalConfiguration = [];
|
|
specificConfiguration = null;
|
|
deviceCapabilities = [];
|
|
pioTransferModes = [];
|
|
dmaTransferModes = [];
|
|
mdmaTransferModes = [];
|
|
ultraDmaTransferModes = [];
|
|
commandSetAndFeatures = [];
|
|
security = null;
|
|
streaming = null;
|
|
smartCommandTransport = null;
|
|
nvCache = null;
|
|
readCapabilitiesDictionary = new Dictionary<string, string>();
|
|
readCapabilitiesList = [];
|
|
|
|
Identify.IdentifyDevice? ataIdentifyNullable = Identify.Decode(ataReport.Identify);
|
|
|
|
if(!ataIdentifyNullable.HasValue) return;
|
|
|
|
Identify.IdentifyDevice ataIdentify = ataIdentifyNullable.Value;
|
|
|
|
if(!string.IsNullOrEmpty(ataIdentify.Model))
|
|
{
|
|
deviceIdentification ??= new Dictionary<string, string>();
|
|
deviceIdentification["Model"] = ataIdentify.Model;
|
|
}
|
|
|
|
if(!string.IsNullOrEmpty(ataIdentify.FirmwareRevision))
|
|
{
|
|
deviceIdentification ??= new Dictionary<string, string>();
|
|
deviceIdentification["Firmware revision"] = ataIdentify.FirmwareRevision;
|
|
}
|
|
|
|
if(!string.IsNullOrEmpty(ataIdentify.AdditionalPID))
|
|
{
|
|
deviceIdentification ??= new Dictionary<string, string>();
|
|
deviceIdentification["Additional product ID"] = ataIdentify.AdditionalPID;
|
|
}
|
|
|
|
if(!atapi)
|
|
{
|
|
logicalSectorSize = ataIdentify.LogicalSectorWords * 2;
|
|
|
|
if(logicalSectorSize is 0) logicalSectorSize = 512;
|
|
|
|
// Multiple logical sectors per physical sector
|
|
if((ataIdentify.PhysLogSectorSize & 0xD000) == 0x5000)
|
|
logicalSectorSize *= (uint)(1 << (ataIdentify.PhysLogSectorSize & 0x0F));
|
|
}
|
|
|
|
bool ata1 = false,
|
|
ata2 = false,
|
|
ata3 = false,
|
|
ata4 = false,
|
|
ata5 = false,
|
|
ata6 = false,
|
|
ata7 = false,
|
|
acs = false,
|
|
acs2 = false,
|
|
acs3 = false,
|
|
acs4 = false;
|
|
|
|
if((ushort)ataIdentify.MajorVersion == 0x0000 || (ushort)ataIdentify.MajorVersion == 0xFFFF)
|
|
{
|
|
// Obsolete in ATA-2, if present, device supports ATA-1
|
|
ata1 |= ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.FastIDE) ||
|
|
ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.SlowIDE) ||
|
|
ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.UltraFastIDE);
|
|
|
|
ata2 |= ataIdentify.ExtendedIdentify.HasFlag(Identify.ExtendedIdentifyBit.Words54to58Valid) ||
|
|
ataIdentify.ExtendedIdentify.HasFlag(Identify.ExtendedIdentifyBit.Words64to70Valid) ||
|
|
ataIdentify.ExtendedIdentify.HasFlag(Identify.ExtendedIdentifyBit.Word88Valid);
|
|
|
|
if(!ata1 && !ata2 && !atapi && !cfa) ata2 = true;
|
|
|
|
ata4 |= atapi;
|
|
ata3 |= cfa;
|
|
|
|
if(cfa && ata1) ata1 = false;
|
|
|
|
if(cfa && ata2) ata2 = false;
|
|
}
|
|
else
|
|
{
|
|
ata1 |= ataIdentify.MajorVersion.HasFlag(Identify.MajorVersionBit.Ata1);
|
|
ata2 |= ataIdentify.MajorVersion.HasFlag(Identify.MajorVersionBit.Ata2);
|
|
ata3 |= ataIdentify.MajorVersion.HasFlag(Identify.MajorVersionBit.Ata3);
|
|
ata4 |= ataIdentify.MajorVersion.HasFlag(Identify.MajorVersionBit.AtaAtapi4);
|
|
ata5 |= ataIdentify.MajorVersion.HasFlag(Identify.MajorVersionBit.AtaAtapi5);
|
|
ata6 |= ataIdentify.MajorVersion.HasFlag(Identify.MajorVersionBit.AtaAtapi6);
|
|
ata7 |= ataIdentify.MajorVersion.HasFlag(Identify.MajorVersionBit.AtaAtapi7);
|
|
acs |= ataIdentify.MajorVersion.HasFlag(Identify.MajorVersionBit.Ata8ACS);
|
|
acs2 |= ataIdentify.MajorVersion.HasFlag(Identify.MajorVersionBit.ACS2);
|
|
acs3 |= ataIdentify.MajorVersion.HasFlag(Identify.MajorVersionBit.ACS3);
|
|
acs4 |= ataIdentify.MajorVersion.HasFlag(Identify.MajorVersionBit.ACS4);
|
|
}
|
|
|
|
var maxAtaLevel = 0;
|
|
var minAtaLevel = 255;
|
|
var tmpString = "";
|
|
|
|
if(ata1)
|
|
{
|
|
supportedAtaVersions.Add("ATA-1");
|
|
maxAtaLevel = 1;
|
|
minAtaLevel = 1;
|
|
}
|
|
|
|
if(ata2)
|
|
{
|
|
supportedAtaVersions.Add("ATA-2");
|
|
maxAtaLevel = 2;
|
|
|
|
if(minAtaLevel > 2) minAtaLevel = 2;
|
|
}
|
|
|
|
if(ata3)
|
|
{
|
|
supportedAtaVersions.Add("ATA-3");
|
|
maxAtaLevel = 3;
|
|
|
|
if(minAtaLevel > 3) minAtaLevel = 3;
|
|
}
|
|
|
|
if(ata4)
|
|
{
|
|
supportedAtaVersions.Add("ATA/ATAPI-4");
|
|
maxAtaLevel = 4;
|
|
|
|
if(minAtaLevel > 4) minAtaLevel = 4;
|
|
}
|
|
|
|
if(ata5)
|
|
{
|
|
supportedAtaVersions.Add("ATA/ATAPI-5");
|
|
maxAtaLevel = 5;
|
|
|
|
if(minAtaLevel > 5) minAtaLevel = 5;
|
|
}
|
|
|
|
if(ata6)
|
|
{
|
|
supportedAtaVersions.Add("ATA/ATAPI-6");
|
|
maxAtaLevel = 6;
|
|
|
|
if(minAtaLevel > 6) minAtaLevel = 6;
|
|
}
|
|
|
|
if(ata7)
|
|
{
|
|
supportedAtaVersions.Add("ATA/ATAPI-7");
|
|
maxAtaLevel = 7;
|
|
|
|
if(minAtaLevel > 7) minAtaLevel = 7;
|
|
}
|
|
|
|
if(acs)
|
|
{
|
|
supportedAtaVersions.Add("ATA8-ACS");
|
|
maxAtaLevel = 8;
|
|
|
|
if(minAtaLevel > 8) minAtaLevel = 8;
|
|
}
|
|
|
|
if(acs2)
|
|
{
|
|
supportedAtaVersions.Add("ATA8-ACS2");
|
|
maxAtaLevel = 9;
|
|
|
|
if(minAtaLevel > 9) minAtaLevel = 9;
|
|
}
|
|
|
|
if(acs3)
|
|
{
|
|
supportedAtaVersions.Add("ATA8-ACS3");
|
|
maxAtaLevel = 10;
|
|
|
|
if(minAtaLevel > 10) minAtaLevel = 10;
|
|
}
|
|
|
|
if(acs4)
|
|
{
|
|
supportedAtaVersions.Add("ATA8-ACS4");
|
|
maxAtaLevel = 11;
|
|
|
|
if(minAtaLevel > 11) minAtaLevel = 11;
|
|
}
|
|
|
|
if(maxAtaLevel >= 3)
|
|
{
|
|
maximumAtaRevision = ataIdentify.MinorVersion switch
|
|
{
|
|
0x0000 or 0xFFFF => "Minor ATA version not specified",
|
|
0x0001 => "ATA (ATA-1) X3T9.2 781D prior to revision 4",
|
|
0x0002 => "ATA-1 published, ANSI X3.221-1994",
|
|
0x0003 => "ATA (ATA-1) X3T9.2 781D revision 4",
|
|
0x0004 => "ATA-2 published, ANSI X3.279-1996",
|
|
0x0005 => "ATA-2 X3T10 948D prior to revision 2k",
|
|
0x0006 => "ATA-3 X3T10 2008D revision 1",
|
|
0x0007 => "ATA-2 X3T10 948D revision 2k",
|
|
0x0008 => "ATA-3 X3T10 2008D revision 0",
|
|
0x0009 => "ATA-2 X3T10 948D revision 3",
|
|
0x000A => "ATA-3 published, ANSI X3.298-1997",
|
|
0x000B => "ATA-3 X3T10 2008D revision 6",
|
|
0x000C => "ATA-3 X3T13 2008D revision 7",
|
|
0x000D => "ATA/ATAPI-4 X3T13 1153D revision 6",
|
|
0x000E => "ATA/ATAPI-4 T13 1153D revision 13",
|
|
0x000F => "ATA/ATAPI-4 X3T13 1153D revision 7",
|
|
0x0010 => "ATA/ATAPI-4 T13 1153D revision 18",
|
|
0x0011 => "ATA/ATAPI-4 T13 1153D revision 15",
|
|
0x0012 => "ATA/ATAPI-4 published, ANSI INCITS 317-1998",
|
|
0x0013 => "ATA/ATAPI-5 T13 1321D revision 3",
|
|
0x0014 => "ATA/ATAPI-4 T13 1153D revision 14",
|
|
0x0015 => "ATA/ATAPI-5 T13 1321D revision 1",
|
|
0x0016 => "ATA/ATAPI-5 published, ANSI INCITS 340-2000",
|
|
0x0017 => "ATA/ATAPI-4 T13 1153D revision 17",
|
|
0x0018 => "ATA/ATAPI-6 T13 1410D revision 0",
|
|
0x0019 => "ATA/ATAPI-6 T13 1410D revision 3a",
|
|
0x001A => "ATA/ATAPI-7 T13 1532D revision 1",
|
|
0x001B => "ATA/ATAPI-6 T13 1410D revision 2",
|
|
0x001C => "ATA/ATAPI-6 T13 1410D revision 1",
|
|
0x001D => "ATA/ATAPI-7 published ANSI INCITS 397-2005",
|
|
0x001E => "ATA/ATAPI-7 T13 1532D revision 0",
|
|
0x001F => "ACS-3 Revision 3b",
|
|
0x0021 => "ATA/ATAPI-7 T13 1532D revision 4a",
|
|
0x0022 => "ATA/ATAPI-6 published, ANSI INCITS 361-2002",
|
|
0x0027 => "ATA8-ACS revision 3c",
|
|
0x0028 => "ATA8-ACS revision 6",
|
|
0x0029 => "ATA8-ACS revision 4",
|
|
0x0031 => "ACS-2 Revision 2",
|
|
0x0033 => "ATA8-ACS Revision 3e",
|
|
0x0039 => "ATA8-ACS Revision 4c",
|
|
0x0042 => "ATA8-ACS Revision 3f",
|
|
0x0052 => "ATA8-ACS revision 3b",
|
|
0x006D => "ACS-3 Revision 5",
|
|
0x0082 => "ACS-2 published, ANSI INCITS 482-2012",
|
|
0x0107 => "ATA8-ACS revision 2d",
|
|
0x0110 => "ACS-2 Revision 3",
|
|
0x011B => "ACS-3 Revision 4",
|
|
_ => $"Unknown ATA revision 0x{ataIdentify.MinorVersion:X4}"
|
|
};
|
|
}
|
|
|
|
switch((ataIdentify.TransportMajorVersion & 0xF000) >> 12)
|
|
{
|
|
case 0x0:
|
|
if((ataIdentify.TransportMajorVersion & 0xFFF) > 0)
|
|
{
|
|
transportVersions = [];
|
|
if((ataIdentify.TransportMajorVersion & 0x0002) == 0x0002) transportVersions.Add("ATA/ATAPI-7");
|
|
|
|
if((ataIdentify.TransportMajorVersion & 0x0001) == 0x0001) transportVersions.Add("ATA8-APT");
|
|
}
|
|
|
|
transport = "Parallel ATA device";
|
|
|
|
break;
|
|
case 0x1:
|
|
if((ataIdentify.TransportMajorVersion & 0xFFF) > 0)
|
|
{
|
|
transportVersions = [];
|
|
if((ataIdentify.TransportMajorVersion & 0x0001) == 0x0001) transportVersions.Add("ATA8-AST");
|
|
|
|
if((ataIdentify.TransportMajorVersion & 0x0002) == 0x0002) transportVersions.Add("SATA 1.0a");
|
|
|
|
if((ataIdentify.TransportMajorVersion & 0x0004) == 0x0004)
|
|
transportVersions.Add("SATA II Extensions");
|
|
|
|
if((ataIdentify.TransportMajorVersion & 0x0008) == 0x0008) transportVersions.Add("SATA 2.5");
|
|
|
|
if((ataIdentify.TransportMajorVersion & 0x0010) == 0x0010) transportVersions.Add("SATA 2.6");
|
|
|
|
if((ataIdentify.TransportMajorVersion & 0x0020) == 0x0020) transportVersions.Add("SATA 3.0");
|
|
|
|
if((ataIdentify.TransportMajorVersion & 0x0040) == 0x0040) transportVersions.Add("SATA 3.1");
|
|
}
|
|
|
|
transport = "Serial ATA device";
|
|
|
|
break;
|
|
case 0xE:
|
|
transport = "SATA Express device";
|
|
|
|
break;
|
|
default:
|
|
transport = $"Unknown transport type 0x{(ataIdentify.TransportMajorVersion & 0xF000) >> 12:X1}";
|
|
|
|
break;
|
|
}
|
|
|
|
if(atapi)
|
|
{
|
|
// Bits 12 to 8, SCSI Peripheral Device Type
|
|
switch((PeripheralDeviceTypes)(((ushort)ataIdentify.GeneralConfiguration & 0x1F00) >> 8))
|
|
{
|
|
case PeripheralDeviceTypes.DirectAccess: //0x00,
|
|
generalConfiguration.Add("ATAPI Direct-access device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.SequentialAccess: //0x01,
|
|
generalConfiguration.Add("ATAPI Sequential-access device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.PrinterDevice: //0x02,
|
|
generalConfiguration.Add("ATAPI Printer device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.ProcessorDevice: //0x03,
|
|
generalConfiguration.Add("ATAPI Processor device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.WriteOnceDevice: //0x04,
|
|
generalConfiguration.Add("ATAPI Write-once device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.MultiMediaDevice: //0x05,
|
|
generalConfiguration.Add("ATAPI CD-ROM/DVD/etc device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.ScannerDevice: //0x06,
|
|
generalConfiguration.Add("ATAPI Scanner device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.OpticalDevice: //0x07,
|
|
generalConfiguration.Add("ATAPI Optical memory device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.MediumChangerDevice: //0x08,
|
|
generalConfiguration.Add("ATAPI Medium change device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.CommsDevice: //0x09,
|
|
generalConfiguration.Add("ATAPI Communications device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.PrePressDevice1: //0x0A,
|
|
generalConfiguration.Add("ATAPI Graphics arts pre-press device (defined in ASC IT8)");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.PrePressDevice2: //0x0B,
|
|
generalConfiguration.Add("ATAPI Graphics arts pre-press device (defined in ASC IT8)");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.ArrayControllerDevice: //0x0C,
|
|
generalConfiguration.Add("ATAPI Array controller device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.EnclosureServiceDevice: //0x0D,
|
|
generalConfiguration.Add("ATAPI Enclosure services device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.SimplifiedDevice: //0x0E,
|
|
generalConfiguration.Add("ATAPI Simplified direct-access device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.OCRWDevice: //0x0F,
|
|
generalConfiguration.Add("ATAPI Optical card reader/writer device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.BridgingExpander: //0x10,
|
|
generalConfiguration.Add("ATAPI Bridging Expanders");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.ObjectDevice: //0x11,
|
|
generalConfiguration.Add("ATAPI Object-based Storage Device");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.ADCDevice: //0x12,
|
|
generalConfiguration.Add("ATAPI Automation/Drive Interface");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.WellKnownDevice: //0x1E,
|
|
generalConfiguration.Add("ATAPI Well known logical unit");
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.UnknownDevice: //0x1F
|
|
generalConfiguration.Add("ATAPI Unknown or no device type");
|
|
|
|
break;
|
|
default:
|
|
generalConfiguration
|
|
.Add($"ATAPI Unknown device type field value 0x{((ushort)ataIdentify.GeneralConfiguration & 0x1F00) >> 8:X2}");
|
|
|
|
break;
|
|
}
|
|
|
|
// ATAPI DRQ behaviour
|
|
switch(((ushort)ataIdentify.GeneralConfiguration & 0x60) >> 5)
|
|
{
|
|
case 0:
|
|
generalConfiguration.Add("Device shall set DRQ within 3 ms of receiving PACKET");
|
|
|
|
break;
|
|
case 1:
|
|
generalConfiguration.Add("Device shall assert INTRQ when DRQ is set to one");
|
|
|
|
break;
|
|
case 2:
|
|
generalConfiguration.Add("Device shall set DRQ within 50 µs of receiving PACKET");
|
|
|
|
break;
|
|
default:
|
|
generalConfiguration
|
|
.Add($"Unknown ATAPI DRQ behaviour code {((ushort)ataIdentify.GeneralConfiguration & 0x60) >> 5}");
|
|
|
|
break;
|
|
}
|
|
|
|
// ATAPI PACKET size
|
|
switch((ushort)ataIdentify.GeneralConfiguration & 0x03)
|
|
{
|
|
case 0:
|
|
generalConfiguration.Add("ATAPI device uses 12 byte command packet");
|
|
|
|
break;
|
|
case 1:
|
|
generalConfiguration.Add("ATAPI device uses 16 byte command packet");
|
|
|
|
break;
|
|
default:
|
|
generalConfiguration
|
|
.Add($"Unknown ATAPI packet size code {(ushort)ataIdentify.GeneralConfiguration & 0x03}");
|
|
|
|
break;
|
|
}
|
|
}
|
|
else if(!cfa)
|
|
{
|
|
if(minAtaLevel >= 5)
|
|
{
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.IncompleteResponse))
|
|
generalConfiguration.Add("Incomplete identify response");
|
|
}
|
|
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.NonMagnetic))
|
|
generalConfiguration.Add("Device uses non-magnetic media");
|
|
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.Removable))
|
|
generalConfiguration.Add("Device is removable");
|
|
|
|
if(minAtaLevel <= 5)
|
|
{
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.Fixed))
|
|
generalConfiguration.Add("Device is fixed");
|
|
}
|
|
|
|
if(ata1)
|
|
{
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.SlowIDE))
|
|
generalConfiguration.Add("Device transfer rate is <= 5 Mb/s");
|
|
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.FastIDE))
|
|
generalConfiguration.Add("Device transfer rate is > 5 Mb/s but <= 10 Mb/s");
|
|
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.UltraFastIDE))
|
|
generalConfiguration.Add("Device transfer rate is > 10 Mb/s");
|
|
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.SoftSector))
|
|
generalConfiguration.Add("Device is soft sectored");
|
|
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.HardSector))
|
|
generalConfiguration.Add("Device is hard sectored");
|
|
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.NotMFM))
|
|
generalConfiguration.Add("Device is not MFM encoded");
|
|
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.FormatGapReq))
|
|
generalConfiguration.Add("Format speed tolerance gap is required");
|
|
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.TrackOffset))
|
|
generalConfiguration.Add("Track offset option is available");
|
|
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.DataStrobeOffset))
|
|
generalConfiguration.Add("Data strobe offset option is available");
|
|
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.RotationalSpeedTolerance))
|
|
generalConfiguration.Add("Rotational speed tolerance is higher than 0,5%");
|
|
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.SpindleControl))
|
|
generalConfiguration.Add("Spindle motor control is implemented");
|
|
|
|
if(ataIdentify.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.HighHeadSwitch))
|
|
generalConfiguration.Add("Head switch time is bigger than 15 µs.");
|
|
}
|
|
}
|
|
|
|
if((ushort)ataIdentify.SpecificConfiguration != 0x0000 && (ushort)ataIdentify.SpecificConfiguration != 0xFFFF)
|
|
{
|
|
specificConfiguration ??= [];
|
|
|
|
switch(ataIdentify.SpecificConfiguration)
|
|
{
|
|
case Identify.SpecificConfigurationEnum.RequiresSetIncompleteResponse:
|
|
specificConfiguration
|
|
.Add("Device requires SET FEATURES to spin up and IDENTIFY DEVICE response is incomplete.");
|
|
|
|
break;
|
|
case Identify.SpecificConfigurationEnum.RequiresSetCompleteResponse:
|
|
specificConfiguration
|
|
.Add("Device requires SET FEATURES to spin up and IDENTIFY DEVICE response is complete.");
|
|
|
|
break;
|
|
case Identify.SpecificConfigurationEnum.NotRequiresSetIncompleteResponse:
|
|
specificConfiguration
|
|
.Add("Device does not require SET FEATURES to spin up and IDENTIFY DEVICE response is incomplete.");
|
|
|
|
break;
|
|
case Identify.SpecificConfigurationEnum.NotRequiresSetCompleteResponse:
|
|
specificConfiguration
|
|
.Add("Device does not require SET FEATURES to spin up and IDENTIFY DEVICE response is complete.");
|
|
|
|
break;
|
|
default:
|
|
specificConfiguration
|
|
.Add($"Unknown device specific configuration 0x{(ushort)ataIdentify.SpecificConfiguration:X4}");
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Obsolete since ATA-2, however, it is yet used in ATA-8 devices
|
|
if(ataIdentify.BufferSize != 0x0000 &&
|
|
ataIdentify.BufferSize != 0xFFFF &&
|
|
ataIdentify.BufferType != 0x0000 &&
|
|
ataIdentify.BufferType != 0xFFFF)
|
|
{
|
|
switch(ataIdentify.BufferType)
|
|
{
|
|
case 1:
|
|
deviceCapabilities
|
|
.Add($"{ataIdentify.BufferSize * logicalSectorSize / 1024} KiB of single ported single sector buffer");
|
|
|
|
break;
|
|
case 2:
|
|
deviceCapabilities
|
|
.Add($"{ataIdentify.BufferSize * logicalSectorSize / 1024} KiB of dual ported multi sector buffer");
|
|
|
|
break;
|
|
case 3:
|
|
deviceCapabilities
|
|
.Add($"{ataIdentify.BufferSize * logicalSectorSize / 1024} KiB of dual ported multi sector buffer with read caching");
|
|
|
|
break;
|
|
default:
|
|
deviceCapabilities
|
|
.Add($"{ataIdentify.BufferSize * logicalSectorSize / 1024} KiB of unknown type {ataIdentify.BufferType} buffer");
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ataIdentify.Capabilities.HasFlag(Identify.CapabilitiesBit.StandardStandbyTimer))
|
|
deviceCapabilities.Add("Standby time values are standard");
|
|
|
|
if(ataIdentify.Capabilities.HasFlag(Identify.CapabilitiesBit.IORDY))
|
|
{
|
|
deviceCapabilities.Add(ataIdentify.Capabilities.HasFlag(Identify.CapabilitiesBit.CanDisableIORDY)
|
|
? "IORDY is supported and can be disabled"
|
|
: "IORDY is supported");
|
|
}
|
|
|
|
if(ataIdentify.Capabilities.HasFlag(Identify.CapabilitiesBit.DMASupport))
|
|
deviceCapabilities.Add("DMA is supported");
|
|
|
|
if(ataIdentify.Capabilities.HasFlag(Identify.CapabilitiesBit.PhysicalAlignment1) ||
|
|
ataIdentify.Capabilities.HasFlag(Identify.CapabilitiesBit.PhysicalAlignment0))
|
|
deviceCapabilities.Add($"Long Physical Alignment setting is {(ushort)ataIdentify.Capabilities & 0x03}");
|
|
|
|
if(atapi)
|
|
{
|
|
if(ataIdentify.Capabilities.HasFlag(Identify.CapabilitiesBit.InterleavedDMA))
|
|
deviceCapabilities.Add("ATAPI device supports interleaved DMA");
|
|
|
|
if(ataIdentify.Capabilities.HasFlag(Identify.CapabilitiesBit.CommandQueue))
|
|
deviceCapabilities.Add("ATAPI device supports command queueing");
|
|
|
|
if(ataIdentify.Capabilities.HasFlag(Identify.CapabilitiesBit.OverlapOperation))
|
|
deviceCapabilities.Add("ATAPI device supports overlapped operations");
|
|
|
|
if(ataIdentify.Capabilities.HasFlag(Identify.CapabilitiesBit.RequiresATASoftReset))
|
|
deviceCapabilities.Add("ATAPI device requires ATA software reset");
|
|
}
|
|
|
|
if(ataIdentify.Capabilities2.HasFlag(Identify.CapabilitiesBit2.MustBeSet) &&
|
|
!ataIdentify.Capabilities2.HasFlag(Identify.CapabilitiesBit2.MustBeClear))
|
|
{
|
|
if(ataIdentify.Capabilities2.HasFlag(Identify.CapabilitiesBit2.SpecificStandbyTimer))
|
|
deviceCapabilities.Add("Device indicates a specific minimum standby timer value");
|
|
}
|
|
|
|
if(ataIdentify.Capabilities3.HasFlag(Identify.CapabilitiesBit3.MultipleValid))
|
|
{
|
|
deviceCapabilities
|
|
.Add($"A maximum of {ataIdentify.MultipleSectorNumber} sectors can be transferred per interrupt on READ/WRITE MULTIPLE");
|
|
|
|
deviceCapabilities.Add($"Device supports setting a maximum of {ataIdentify.MultipleMaxSectors} sectors");
|
|
}
|
|
|
|
if(ata1)
|
|
{
|
|
if(ataIdentify.TrustedComputing.HasFlag(Identify.TrustedComputingBit.TrustedComputing))
|
|
deviceCapabilities.Add("Device supports doubleword I/O");
|
|
}
|
|
|
|
if(minAtaLevel <= 3)
|
|
{
|
|
if(ataIdentify.PIOTransferTimingMode > 0)
|
|
pioTransferModes.Add($"PIO timing mode {ataIdentify.PIOTransferTimingMode}");
|
|
|
|
if(ataIdentify.DMATransferTimingMode > 0)
|
|
dmaTransferModes.Add($"DMA timing mode {ataIdentify.DMATransferTimingMode}");
|
|
}
|
|
|
|
if(ataIdentify.APIOSupported.HasFlag(Identify.TransferMode.Mode0)) pioTransferModes.Add("PIO0");
|
|
|
|
if(ataIdentify.APIOSupported.HasFlag(Identify.TransferMode.Mode1)) pioTransferModes.Add("PIO1");
|
|
|
|
if(ataIdentify.APIOSupported.HasFlag(Identify.TransferMode.Mode2)) pioTransferModes.Add("PIO2");
|
|
|
|
if(ataIdentify.APIOSupported.HasFlag(Identify.TransferMode.Mode3)) pioTransferModes.Add("PIO3");
|
|
|
|
if(ataIdentify.APIOSupported.HasFlag(Identify.TransferMode.Mode4)) pioTransferModes.Add("PIO4");
|
|
|
|
if(ataIdentify.APIOSupported.HasFlag(Identify.TransferMode.Mode5)) pioTransferModes.Add("PIO5");
|
|
|
|
if(ataIdentify.APIOSupported.HasFlag(Identify.TransferMode.Mode6)) pioTransferModes.Add("PIO6");
|
|
|
|
if(ataIdentify.APIOSupported.HasFlag(Identify.TransferMode.Mode7)) pioTransferModes.Add("PIO7");
|
|
|
|
if(minAtaLevel <= 3 && !atapi)
|
|
{
|
|
if(ataIdentify.DMASupported.HasFlag(Identify.TransferMode.Mode0))
|
|
{
|
|
dmaTransferModes.Add(ataIdentify.DMAActive.HasFlag(Identify.TransferMode.Mode0)
|
|
? "DMA0 (active)"
|
|
: "DMA0");
|
|
}
|
|
|
|
if(ataIdentify.DMASupported.HasFlag(Identify.TransferMode.Mode1))
|
|
{
|
|
dmaTransferModes.Add(ataIdentify.DMAActive.HasFlag(Identify.TransferMode.Mode1)
|
|
? "DMA1 (active)"
|
|
: "DMA1");
|
|
}
|
|
|
|
if(ataIdentify.DMASupported.HasFlag(Identify.TransferMode.Mode2))
|
|
{
|
|
dmaTransferModes.Add(ataIdentify.DMAActive.HasFlag(Identify.TransferMode.Mode2)
|
|
? "DMA2 (active)"
|
|
: "DMA2");
|
|
}
|
|
|
|
if(ataIdentify.DMASupported.HasFlag(Identify.TransferMode.Mode3))
|
|
{
|
|
dmaTransferModes.Add(ataIdentify.DMAActive.HasFlag(Identify.TransferMode.Mode3)
|
|
? "DMA3 (active)"
|
|
: "DMA3");
|
|
}
|
|
|
|
if(ataIdentify.DMASupported.HasFlag(Identify.TransferMode.Mode4))
|
|
{
|
|
dmaTransferModes.Add(ataIdentify.DMAActive.HasFlag(Identify.TransferMode.Mode4)
|
|
? "DMA4 (active)"
|
|
: "DMA4");
|
|
}
|
|
|
|
if(ataIdentify.DMASupported.HasFlag(Identify.TransferMode.Mode5))
|
|
{
|
|
dmaTransferModes.Add(ataIdentify.DMAActive.HasFlag(Identify.TransferMode.Mode5)
|
|
? "DMA5 (active)"
|
|
: "DMA5");
|
|
}
|
|
|
|
if(ataIdentify.DMASupported.HasFlag(Identify.TransferMode.Mode6))
|
|
{
|
|
dmaTransferModes.Add(ataIdentify.DMAActive.HasFlag(Identify.TransferMode.Mode6)
|
|
? "DMA6 (active)"
|
|
: "DMA6");
|
|
}
|
|
|
|
if(ataIdentify.DMASupported.HasFlag(Identify.TransferMode.Mode7))
|
|
{
|
|
dmaTransferModes.Add(ataIdentify.DMAActive.HasFlag(Identify.TransferMode.Mode7)
|
|
? "DMA7 (active)"
|
|
: "DMA7");
|
|
}
|
|
}
|
|
|
|
if(ataIdentify.MDMASupported.HasFlag(Identify.TransferMode.Mode0))
|
|
{
|
|
mdmaTransferModes.Add(ataIdentify.MDMAActive.HasFlag(Identify.TransferMode.Mode0)
|
|
? "MDMA0 (active)"
|
|
: "MDMA0");
|
|
}
|
|
|
|
if(ataIdentify.MDMASupported.HasFlag(Identify.TransferMode.Mode1))
|
|
{
|
|
mdmaTransferModes.Add(ataIdentify.MDMAActive.HasFlag(Identify.TransferMode.Mode1)
|
|
? "MDMA1 (active)"
|
|
: "MDMA1");
|
|
}
|
|
|
|
if(ataIdentify.MDMASupported.HasFlag(Identify.TransferMode.Mode2))
|
|
{
|
|
mdmaTransferModes.Add(ataIdentify.MDMAActive.HasFlag(Identify.TransferMode.Mode2)
|
|
? "MDMA2 (active)"
|
|
: "MDMA2");
|
|
}
|
|
|
|
if(ataIdentify.MDMASupported.HasFlag(Identify.TransferMode.Mode3))
|
|
{
|
|
mdmaTransferModes.Add(ataIdentify.MDMAActive.HasFlag(Identify.TransferMode.Mode3)
|
|
? "MDMA3 (active)"
|
|
: "MDMA3");
|
|
}
|
|
|
|
if(ataIdentify.MDMASupported.HasFlag(Identify.TransferMode.Mode4))
|
|
{
|
|
mdmaTransferModes.Add(ataIdentify.MDMAActive.HasFlag(Identify.TransferMode.Mode4)
|
|
? "MDMA4 (active)"
|
|
: "MDMA4");
|
|
}
|
|
|
|
if(ataIdentify.MDMASupported.HasFlag(Identify.TransferMode.Mode5))
|
|
{
|
|
mdmaTransferModes.Add(ataIdentify.MDMAActive.HasFlag(Identify.TransferMode.Mode5)
|
|
? "MDMA5 (active)"
|
|
: "MDMA5");
|
|
}
|
|
|
|
if(ataIdentify.MDMASupported.HasFlag(Identify.TransferMode.Mode6))
|
|
{
|
|
mdmaTransferModes.Add(ataIdentify.MDMAActive.HasFlag(Identify.TransferMode.Mode6)
|
|
? "MDMA6 (active)"
|
|
: "MDMA6");
|
|
}
|
|
|
|
if(ataIdentify.MDMASupported.HasFlag(Identify.TransferMode.Mode7))
|
|
{
|
|
mdmaTransferModes.Add(ataIdentify.MDMAActive.HasFlag(Identify.TransferMode.Mode7)
|
|
? "MDMA7 (active)"
|
|
: "MDMA7");
|
|
}
|
|
|
|
if(ataIdentify.UDMASupported.HasFlag(Identify.TransferMode.Mode0))
|
|
{
|
|
ultraDmaTransferModes.Add(ataIdentify.UDMAActive.HasFlag(Identify.TransferMode.Mode0)
|
|
? "UDMA0 (active)"
|
|
: "UDMA0");
|
|
}
|
|
|
|
if(ataIdentify.UDMASupported.HasFlag(Identify.TransferMode.Mode1))
|
|
{
|
|
ultraDmaTransferModes.Add(ataIdentify.UDMAActive.HasFlag(Identify.TransferMode.Mode1)
|
|
? "UDMA1 (active)"
|
|
: "UDMA1");
|
|
}
|
|
|
|
if(ataIdentify.UDMASupported.HasFlag(Identify.TransferMode.Mode2))
|
|
{
|
|
ultraDmaTransferModes.Add(ataIdentify.UDMAActive.HasFlag(Identify.TransferMode.Mode2)
|
|
? "UDMA2 (active)"
|
|
: "UDMA2");
|
|
}
|
|
|
|
if(ataIdentify.UDMASupported.HasFlag(Identify.TransferMode.Mode3))
|
|
{
|
|
ultraDmaTransferModes.Add(ataIdentify.UDMAActive.HasFlag(Identify.TransferMode.Mode3)
|
|
? "UDMA3 (active)"
|
|
: "UDMA3");
|
|
}
|
|
|
|
if(ataIdentify.UDMASupported.HasFlag(Identify.TransferMode.Mode4))
|
|
{
|
|
ultraDmaTransferModes.Add(ataIdentify.UDMAActive.HasFlag(Identify.TransferMode.Mode4)
|
|
? "UDMA4 (active)"
|
|
: "UDMA4");
|
|
}
|
|
|
|
if(ataIdentify.UDMASupported.HasFlag(Identify.TransferMode.Mode5))
|
|
{
|
|
ultraDmaTransferModes.Add(ataIdentify.UDMAActive.HasFlag(Identify.TransferMode.Mode5)
|
|
? "UDMA5 (active)"
|
|
: "UDMA5");
|
|
}
|
|
|
|
if(ataIdentify.UDMASupported.HasFlag(Identify.TransferMode.Mode6))
|
|
{
|
|
ultraDmaTransferModes.Add(ataIdentify.UDMAActive.HasFlag(Identify.TransferMode.Mode6)
|
|
? "UDMA6 (active)"
|
|
: "UDMA6");
|
|
}
|
|
|
|
if(ataIdentify.UDMASupported.HasFlag(Identify.TransferMode.Mode7))
|
|
{
|
|
ultraDmaTransferModes.Add(ataIdentify.UDMAActive.HasFlag(Identify.TransferMode.Mode7)
|
|
? "UDMA7 (active)"
|
|
: "UDMA7");
|
|
}
|
|
|
|
if(ataIdentify.MinMDMACycleTime != 0 && ataIdentify.RecMDMACycleTime != 0)
|
|
{
|
|
specificConfiguration ??= [];
|
|
|
|
specificConfiguration
|
|
.Add($"At minimum {ataIdentify.MinMDMACycleTime} ns. transfer cycle time per word in MDMA, " +
|
|
$"{ataIdentify.RecMDMACycleTime} ns. recommended");
|
|
}
|
|
|
|
if(ataIdentify.MinPIOCycleTimeNoFlow != 0)
|
|
{
|
|
specificConfiguration ??= [];
|
|
|
|
specificConfiguration
|
|
.Add($"At minimum {ataIdentify.MinPIOCycleTimeNoFlow} ns. transfer cycle time per word in PIO, " +
|
|
"without flow control");
|
|
}
|
|
|
|
if(ataIdentify.MinPIOCycleTimeFlow != 0)
|
|
{
|
|
specificConfiguration ??= [];
|
|
|
|
specificConfiguration
|
|
.Add($"At minimum {ataIdentify.MinPIOCycleTimeFlow} ns. transfer cycle time per word in PIO, " +
|
|
"with IORDY flow control");
|
|
}
|
|
|
|
if(ataIdentify.MaxQueueDepth != 0)
|
|
{
|
|
specificConfiguration ??= [];
|
|
specificConfiguration.Add($"{ataIdentify.MaxQueueDepth + 1} depth of queue maximum");
|
|
}
|
|
|
|
if(atapi)
|
|
{
|
|
if(ataIdentify.PacketBusRelease != 0)
|
|
{
|
|
specificConfiguration ??= [];
|
|
|
|
specificConfiguration
|
|
.Add($"{ataIdentify.PacketBusRelease} ns. typical to release bus from receipt of PACKET");
|
|
}
|
|
|
|
if(ataIdentify.ServiceBusyClear != 0)
|
|
{
|
|
specificConfiguration ??= [];
|
|
|
|
specificConfiguration
|
|
.Add($"{ataIdentify.ServiceBusyClear} ns. typical to clear BSY bit from receipt of SERVICE");
|
|
}
|
|
}
|
|
|
|
if((ataIdentify.TransportMajorVersion & 0xF000) >> 12 == 0x1 ||
|
|
(ataIdentify.TransportMajorVersion & 0xF000) >> 12 == 0xE)
|
|
{
|
|
if(!ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.Clear))
|
|
{
|
|
if(ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.Gen1Speed))
|
|
deviceCapabilities.Add("SATA 1.5Gb/s is supported");
|
|
|
|
if(ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.Gen2Speed))
|
|
deviceCapabilities.Add("SATA 3.0Gb/s is supported");
|
|
|
|
if(ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.Gen3Speed))
|
|
deviceCapabilities.Add("SATA 6.0Gb/s is supported");
|
|
|
|
if(ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.PowerReceipt))
|
|
deviceCapabilities.Add("Receipt of host initiated power management requests is supported");
|
|
|
|
if(ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.PHYEventCounter))
|
|
deviceCapabilities.Add("PHY Event counters are supported");
|
|
|
|
if(ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.HostSlumbTrans))
|
|
deviceCapabilities.Add("Supports host automatic partial to slumber transitions is supported");
|
|
|
|
if(ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.DevSlumbTrans))
|
|
deviceCapabilities.Add("Supports device automatic partial to slumber transitions is supported");
|
|
|
|
if(ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.NCQ))
|
|
{
|
|
deviceCapabilities.Add("NCQ is supported");
|
|
|
|
if(ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.NCQPriority))
|
|
deviceCapabilities.Add("NCQ priority is supported");
|
|
|
|
if(ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.UnloadNCQ))
|
|
deviceCapabilities.Add("Unload is supported with outstanding NCQ commands");
|
|
}
|
|
}
|
|
|
|
if(!ataIdentify.SATACapabilities2.HasFlag(Identify.SATACapabilitiesBit2.Clear))
|
|
{
|
|
if(!ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.Clear) &&
|
|
ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.NCQ))
|
|
{
|
|
if(ataIdentify.SATACapabilities2.HasFlag(Identify.SATACapabilitiesBit2.NCQMgmt))
|
|
deviceCapabilities.Add("NCQ queue management is supported");
|
|
|
|
if(ataIdentify.SATACapabilities2.HasFlag(Identify.SATACapabilitiesBit2.NCQStream))
|
|
deviceCapabilities.Add("NCQ streaming is supported");
|
|
}
|
|
|
|
if(atapi)
|
|
{
|
|
if(ataIdentify.SATACapabilities2.HasFlag(Identify.SATACapabilitiesBit2.HostEnvDetect))
|
|
deviceCapabilities.Add("ATAPI device supports host environment detection");
|
|
|
|
if(ataIdentify.SATACapabilities2.HasFlag(Identify.SATACapabilitiesBit2.DevAttSlimline))
|
|
deviceCapabilities.Add("ATAPI device supports attention on slimline connected devices");
|
|
}
|
|
}
|
|
}
|
|
|
|
if(ataIdentify.InterseekDelay != 0x0000 && ataIdentify.InterseekDelay != 0xFFFF)
|
|
{
|
|
specificConfiguration ??= [];
|
|
|
|
specificConfiguration
|
|
.Add($"{ataIdentify.InterseekDelay} microseconds of interseek delay for ISO-7779 acoustic testing");
|
|
}
|
|
|
|
if((ushort)ataIdentify.DeviceFormFactor != 0x0000 && (ushort)ataIdentify.DeviceFormFactor != 0xFFFF)
|
|
{
|
|
specificConfiguration ??= [];
|
|
|
|
switch(ataIdentify.DeviceFormFactor)
|
|
{
|
|
case Identify.DeviceFormFactorEnum.FiveAndQuarter:
|
|
specificConfiguration.Add("Device nominal size is 5.25\"");
|
|
|
|
break;
|
|
case Identify.DeviceFormFactorEnum.ThreeAndHalf:
|
|
specificConfiguration.Add("Device nominal size is 3.5\"");
|
|
|
|
break;
|
|
case Identify.DeviceFormFactorEnum.TwoAndHalf:
|
|
specificConfiguration.Add("Device nominal size is 2.5\"");
|
|
|
|
break;
|
|
case Identify.DeviceFormFactorEnum.OnePointEight:
|
|
specificConfiguration.Add("Device nominal size is 1.8\"");
|
|
|
|
break;
|
|
case Identify.DeviceFormFactorEnum.LessThanOnePointEight:
|
|
specificConfiguration.Add("Device nominal size is smaller than 1.8\"");
|
|
|
|
break;
|
|
default:
|
|
specificConfiguration
|
|
.Add($"Device nominal size field value {ataIdentify.DeviceFormFactor} is unknown");
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(atapi && ataIdentify.ATAPIByteCount > 0)
|
|
{
|
|
specificConfiguration ??= [];
|
|
specificConfiguration.Add($"{ataIdentify.ATAPIByteCount} bytes count limit for ATAPI");
|
|
}
|
|
|
|
if(cfa)
|
|
{
|
|
if((ataIdentify.CFAPowerMode & 0x8000) == 0x8000)
|
|
{
|
|
specificConfiguration ??= [];
|
|
|
|
specificConfiguration.Add("CompactFlash device supports power mode 1");
|
|
|
|
if((ataIdentify.CFAPowerMode & 0x2000) == 0x2000)
|
|
specificConfiguration.Add("CompactFlash power mode 1 required for one or more commands");
|
|
|
|
if((ataIdentify.CFAPowerMode & 0x1000) == 0x1000)
|
|
specificConfiguration.Add("CompactFlash power mode 1 is disabled");
|
|
|
|
specificConfiguration
|
|
.Add($"CompactFlash device uses a maximum of {ataIdentify.CFAPowerMode & 0x0FFF} mA");
|
|
}
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.Nop))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.Nop)
|
|
? "NOP is supported and enabled"
|
|
: "NOP is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.ReadBuffer))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.ReadBuffer)
|
|
? "READ BUFFER is supported and enabled"
|
|
: "READ BUFFER is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.WriteBuffer))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.WriteBuffer)
|
|
? "WRITE BUFFER is supported and enabled"
|
|
: "WRITE BUFFER is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.HPA))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.HPA)
|
|
? "Host Protected Area is supported and enabled"
|
|
: "Host Protected Area is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.DeviceReset))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.DeviceReset)
|
|
? "DEVICE RESET is supported and enabled"
|
|
: "DEVICE RESET is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.Service))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.Service)
|
|
? "SERVICE interrupt is supported and enabled"
|
|
: "SERVICE interrupt is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.Release))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.Release)
|
|
? "Release is supported and enabled"
|
|
: "Release is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.LookAhead))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.LookAhead)
|
|
? "Look-ahead read is supported and enabled"
|
|
: "Look-ahead read is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.WriteCache))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.WriteCache)
|
|
? "Write cache is supported and enabled"
|
|
: "Write cache is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.Packet))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.Packet)
|
|
? "PACKET is supported and enabled"
|
|
: "PACKET is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.PowerManagement))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.PowerManagement)
|
|
? "Power management is supported and enabled"
|
|
: "Power management is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.RemovableMedia))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.RemovableMedia)
|
|
? "Removable media feature set is supported and enabled"
|
|
: "Removable media feature set is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.SecurityMode))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.SecurityMode)
|
|
? "Security mode is supported and enabled"
|
|
: "Security mode is supported");
|
|
}
|
|
|
|
if(ataIdentify.Capabilities.HasFlag(Identify.CapabilitiesBit.LBASupport))
|
|
commandSetAndFeatures.Add("28-bit LBA is supported");
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.MustBeSet) &&
|
|
!ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.MustBeClear))
|
|
{
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.LBA48))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet2.HasFlag(Identify.CommandSetBit2.LBA48)
|
|
? "48-bit LBA is supported and enabled"
|
|
: "48-bit LBA is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.FlushCache))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet2.HasFlag(Identify.CommandSetBit2.FlushCache)
|
|
? "FLUSH CACHE is supported and enabled"
|
|
: "FLUSH CACHE is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.FlushCacheExt))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet2.HasFlag(Identify.CommandSetBit2.FlushCacheExt)
|
|
? "FLUSH CACHE EXT is supported and enabled"
|
|
: "FLUSH CACHE EXT is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.DCO))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet2.HasFlag(Identify.CommandSetBit2.DCO)
|
|
? "Device Configuration Overlay feature set is supported and enabled"
|
|
: "Device Configuration Overlay feature set is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.AAM))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet2.HasFlag(Identify.CommandSetBit2.AAM)
|
|
? $"Automatic Acoustic Management is supported and enabled with value {ataIdentify.CurrentAAM} (vendor recommends {ataIdentify.RecommendedAAM}"
|
|
: "Automatic Acoustic Management is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.SetMax))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet2.HasFlag(Identify.CommandSetBit2.SetMax)
|
|
? "SET MAX security extension is supported and enabled"
|
|
: "SET MAX security extension is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.AddressOffsetReservedAreaBoot))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet2.HasFlag(Identify.CommandSetBit2
|
|
.AddressOffsetReservedAreaBoot)
|
|
? "Address Offset Reserved Area Boot is supported and enabled"
|
|
: "Address Offset Reserved Area Boot is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.SetFeaturesRequired))
|
|
commandSetAndFeatures.Add("SET FEATURES is required before spin-up");
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.PowerUpInStandby))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet2.HasFlag(Identify.CommandSetBit2
|
|
.PowerUpInStandby)
|
|
? "Power-up in standby is supported and enabled"
|
|
: "Power-up in standby is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.RemovableNotification))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet2.HasFlag(Identify.CommandSetBit2
|
|
.RemovableNotification)
|
|
? "Removable Media Status Notification is supported and enabled"
|
|
: "Removable Media Status Notification is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.APM))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet2.HasFlag(Identify.CommandSetBit2.APM)
|
|
? $"Advanced Power Management is supported and enabled with value {ataIdentify.CurrentAPM}"
|
|
: "Advanced Power Management is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.CompactFlash))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet2.HasFlag(Identify.CommandSetBit2.CompactFlash)
|
|
? "CompactFlash feature set is supported and enabled"
|
|
: "CompactFlash feature set is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.RWQueuedDMA))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet2.HasFlag(Identify.CommandSetBit2.RWQueuedDMA)
|
|
? "READ DMA QUEUED and WRITE DMA QUEUED are supported and enabled"
|
|
: "READ DMA QUEUED and WRITE DMA QUEUED are supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet2.HasFlag(Identify.CommandSetBit2.DownloadMicrocode))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet2.HasFlag(Identify.CommandSetBit2
|
|
.DownloadMicrocode)
|
|
? "DOWNLOAD MICROCODE is supported and enabled"
|
|
: "DOWNLOAD MICROCODE is supported");
|
|
}
|
|
}
|
|
|
|
if(ataIdentify.CommandSet.HasFlag(Identify.CommandSetBit.SMART))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet.HasFlag(Identify.CommandSetBit.SMART)
|
|
? "S.M.A.R.T. is supported and enabled"
|
|
: "S.M.A.R.T. is supported");
|
|
}
|
|
|
|
if(ataIdentify.SCTCommandTransport.HasFlag(Identify.SCTCommandTransportBit.Supported))
|
|
commandSetAndFeatures.Add("S.M.A.R.T. Command Transport is supported");
|
|
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.MustBeSet) &&
|
|
!ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.MustBeClear))
|
|
{
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.SMARTSelfTest))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet3.HasFlag(Identify.CommandSetBit3.SMARTSelfTest)
|
|
? "S.M.A.R.T. self-testing is supported and enabled"
|
|
: "S.M.A.R.T. self-testing is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.SMARTLog))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet3.HasFlag(Identify.CommandSetBit3.SMARTLog)
|
|
? "S.M.A.R.T. error logging is supported and enabled"
|
|
: "S.M.A.R.T. error logging is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.IdleImmediate))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet3.HasFlag(Identify.CommandSetBit3.IdleImmediate)
|
|
? "IDLE IMMEDIATE with UNLOAD FEATURE is supported and enabled"
|
|
: "IDLE IMMEDIATE with UNLOAD FEATURE is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.WriteURG))
|
|
commandSetAndFeatures.Add("URG bit is supported in WRITE STREAM DMA EXT and WRITE STREAM EXT");
|
|
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.ReadURG))
|
|
commandSetAndFeatures.Add("URG bit is supported in READ STREAM DMA EXT and READ STREAM EXT");
|
|
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.WWN))
|
|
commandSetAndFeatures.Add("Device has a World Wide Name");
|
|
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.FUAWriteQ))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet3.HasFlag(Identify.CommandSetBit3.FUAWriteQ)
|
|
? "WRITE DMA QUEUED FUA EXT is supported and enabled"
|
|
: "WRITE DMA QUEUED FUA EXT is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.FUAWrite))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet3.HasFlag(Identify.CommandSetBit3.FUAWrite)
|
|
? "WRITE DMA FUA EXT and WRITE MULTIPLE FUA EXT are supported and enabled"
|
|
: "WRITE DMA FUA EXT and WRITE MULTIPLE FUA EXT are supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.GPL))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet3.HasFlag(Identify.CommandSetBit3.GPL)
|
|
? "General Purpose Logging is supported and enabled"
|
|
: "General Purpose Logging is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.Streaming))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet3.HasFlag(Identify.CommandSetBit3.Streaming)
|
|
? "Streaming feature set is supported and enabled"
|
|
: "Streaming feature set is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.MCPT))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet3.HasFlag(Identify.CommandSetBit3.MCPT)
|
|
? "Media Card Pass Through command set is supported and enabled"
|
|
: "Media Card Pass Through command set is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.MediaSerial))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet3.HasFlag(Identify.CommandSetBit3.MediaSerial)
|
|
? "Media Serial is supported and valid"
|
|
: "Media Serial is supported");
|
|
}
|
|
}
|
|
|
|
if(ataIdentify.CommandSet4.HasFlag(Identify.CommandSetBit4.MustBeSet) &&
|
|
!ataIdentify.CommandSet4.HasFlag(Identify.CommandSetBit4.MustBeClear))
|
|
{
|
|
if(ataIdentify.CommandSet4.HasFlag(Identify.CommandSetBit4.DSN))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet4.HasFlag(Identify.CommandSetBit4.DSN)
|
|
? "DSN feature set is supported and enabled"
|
|
: "DSN feature set is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet4.HasFlag(Identify.CommandSetBit4.AMAC))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet4.HasFlag(Identify.CommandSetBit4.AMAC)
|
|
? "Accessible Max Address Configuration is supported and enabled"
|
|
: "Accessible Max Address Configuration is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet4.HasFlag(Identify.CommandSetBit4.ExtPowerCond))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet4.HasFlag(Identify.CommandSetBit4.ExtPowerCond)
|
|
? "Extended Power Conditions are supported and enabled"
|
|
: "Extended Power Conditions are supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet4.HasFlag(Identify.CommandSetBit4.ExtStatusReport))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet4.HasFlag(Identify.CommandSetBit4
|
|
.ExtStatusReport)
|
|
? "Extended Status Reporting is supported and enabled"
|
|
: "Extended Status Reporting is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet4.HasFlag(Identify.CommandSetBit4.FreeFallControl))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet4.HasFlag(Identify.CommandSetBit4
|
|
.FreeFallControl)
|
|
? "Free-fall control feature set is supported and enabled"
|
|
: "Free-fall control feature set is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet4.HasFlag(Identify.CommandSetBit4.SegmentedDownloadMicrocode))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet4.HasFlag(Identify.CommandSetBit4
|
|
.SegmentedDownloadMicrocode)
|
|
? "Segmented feature in DOWNLOAD MICROCODE is supported and enabled"
|
|
: "Segmented feature in DOWNLOAD MICROCODE is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet4.HasFlag(Identify.CommandSetBit4.RWDMAExtGpl))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet4.HasFlag(Identify.CommandSetBit4.RWDMAExtGpl)
|
|
? "READ/WRITE DMA EXT GPL are supported and enabled"
|
|
: "READ/WRITE DMA EXT GPL are supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet4.HasFlag(Identify.CommandSetBit4.WriteUnc))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet4.HasFlag(Identify.CommandSetBit4.WriteUnc)
|
|
? "WRITE UNCORRECTABLE is supported and enabled"
|
|
: "WRITE UNCORRECTABLE is supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet4.HasFlag(Identify.CommandSetBit4.WRV))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet4.HasFlag(Identify.CommandSetBit4.WRV)
|
|
? "Write/Read/Verify is supported and enabled"
|
|
: "Write/Read/Verify is supported");
|
|
|
|
commandSetAndFeatures.Add($"{ataIdentify.WRVSectorCountMode2} sectors for Write/Read/Verify mode 2");
|
|
commandSetAndFeatures.Add($"{ataIdentify.WRVSectorCountMode3} sectors for Write/Read/Verify mode 3");
|
|
|
|
if(ataIdentify.EnabledCommandSet4.HasFlag(Identify.CommandSetBit4.WRV))
|
|
commandSetAndFeatures.Add($"Current Write/Read/Verify mode: {ataIdentify.WRVMode}");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet4.HasFlag(Identify.CommandSetBit4.DT1825))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledCommandSet4.HasFlag(Identify.CommandSetBit4.DT1825)
|
|
? "DT1825 is supported and enabled"
|
|
: "DT1825 is supported");
|
|
}
|
|
}
|
|
|
|
if(ataIdentify.Capabilities3.HasFlag(Identify.CapabilitiesBit3.BlockErase))
|
|
commandSetAndFeatures.Add("BLOCK ERASE EXT is supported");
|
|
|
|
if(ataIdentify.Capabilities3.HasFlag(Identify.CapabilitiesBit3.Overwrite))
|
|
commandSetAndFeatures.Add("OVERWRITE EXT is supported");
|
|
|
|
if(ataIdentify.Capabilities3.HasFlag(Identify.CapabilitiesBit3.CryptoScramble))
|
|
commandSetAndFeatures.Add("CRYPTO SCRAMBLE EXT is supported");
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.DeviceConfDMA))
|
|
{
|
|
commandSetAndFeatures
|
|
.Add("DEVICE CONFIGURATION IDENTIFY DMA and DEVICE CONFIGURATION SET DMA are supported");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.ReadBufferDMA))
|
|
commandSetAndFeatures.Add("READ BUFFER DMA is supported");
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.WriteBufferDMA))
|
|
commandSetAndFeatures.Add("WRITE BUFFER DMA is supported");
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.DownloadMicroCodeDMA))
|
|
commandSetAndFeatures.Add("DOWNLOAD MICROCODE DMA is supported");
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.SetMaxDMA))
|
|
commandSetAndFeatures.Add("SET PASSWORD DMA and SET UNLOCK DMA are supported");
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.Ata28))
|
|
commandSetAndFeatures.Add("Not all 28-bit commands are supported");
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.CFast))
|
|
commandSetAndFeatures.Add("Device follows CFast specification");
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.IEEE1667))
|
|
commandSetAndFeatures.Add("Device follows IEEE-1667");
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.DeterministicTrim))
|
|
{
|
|
commandSetAndFeatures.Add("Read after TRIM is deterministic");
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.ReadZeroTrim))
|
|
commandSetAndFeatures.Add("Read after TRIM returns empty data");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.LongPhysSectorAligError))
|
|
commandSetAndFeatures.Add("Device supports Long Physical Sector Alignment Error Reporting Control");
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.Encrypted))
|
|
commandSetAndFeatures.Add("Device encrypts all user data");
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.AllCacheNV))
|
|
commandSetAndFeatures.Add("Device's write cache is non-volatile");
|
|
|
|
if(ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.ZonedBit0) ||
|
|
ataIdentify.CommandSet5.HasFlag(Identify.CommandSetBit5.ZonedBit1))
|
|
commandSetAndFeatures.Add("Device is zoned");
|
|
|
|
if(ataIdentify.Capabilities3.HasFlag(Identify.CapabilitiesBit3.Sanitize))
|
|
{
|
|
commandSetAndFeatures.Add("Sanitize feature set is supported");
|
|
|
|
commandSetAndFeatures.Add(ataIdentify.Capabilities3.HasFlag(Identify.CapabilitiesBit3.SanitizeCommands)
|
|
? "Sanitize commands are specified by ACS-3 or higher"
|
|
: "Sanitize commands are specified by ACS-2");
|
|
|
|
if(ataIdentify.Capabilities3.HasFlag(Identify.CapabilitiesBit3.SanitizeAntifreeze))
|
|
commandSetAndFeatures.Add("SANITIZE ANTIFREEZE LOCK EXT is supported");
|
|
}
|
|
|
|
|
|
if(!ata1 && maxAtaLevel >= 8)
|
|
{
|
|
if(ataIdentify.TrustedComputing.HasFlag(Identify.TrustedComputingBit.Set) &&
|
|
!ataIdentify.TrustedComputing.HasFlag(Identify.TrustedComputingBit.Clear) &&
|
|
ataIdentify.TrustedComputing.HasFlag(Identify.TrustedComputingBit.TrustedComputing))
|
|
commandSetAndFeatures.Add("Trusted Computing feature set is supported");
|
|
}
|
|
|
|
if((ataIdentify.TransportMajorVersion & 0xF000) >> 12 == 0x1 ||
|
|
(ataIdentify.TransportMajorVersion & 0xF000) >> 12 == 0xE)
|
|
{
|
|
if(true)
|
|
{
|
|
if(!ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.Clear))
|
|
{
|
|
if(ataIdentify.SATACapabilities.HasFlag(Identify.SATACapabilitiesBit.ReadLogDMAExt))
|
|
commandSetAndFeatures.Add("READ LOG DMA EXT is supported");
|
|
}
|
|
}
|
|
|
|
if(true)
|
|
{
|
|
if(!ataIdentify.SATACapabilities2.HasFlag(Identify.SATACapabilitiesBit2.Clear))
|
|
{
|
|
if(ataIdentify.SATACapabilities2.HasFlag(Identify.SATACapabilitiesBit2.FPDMAQ))
|
|
commandSetAndFeatures.Add("RECEIVE FPDMA QUEUED and SEND FPDMA QUEUED are supported");
|
|
}
|
|
}
|
|
|
|
if(true)
|
|
{
|
|
if(!ataIdentify.SATAFeatures.HasFlag(Identify.SATAFeaturesBit.Clear))
|
|
{
|
|
if(ataIdentify.SATAFeatures.HasFlag(Identify.SATAFeaturesBit.NonZeroBufferOffset))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledSATAFeatures.HasFlag(Identify.SATAFeaturesBit
|
|
.NonZeroBufferOffset)
|
|
? "Non-zero buffer offsets are supported and enabled"
|
|
: "Non-zero buffer offsets are supported");
|
|
}
|
|
|
|
if(ataIdentify.SATAFeatures.HasFlag(Identify.SATAFeaturesBit.DMASetup))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledSATAFeatures.HasFlag(Identify.SATAFeaturesBit
|
|
.DMASetup)
|
|
? "DMA Setup auto-activation is supported and enabled"
|
|
: "DMA Setup auto-activation is supported");
|
|
}
|
|
|
|
if(ataIdentify.SATAFeatures.HasFlag(Identify.SATAFeaturesBit.InitPowerMgmt))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledSATAFeatures.HasFlag(Identify.SATAFeaturesBit
|
|
.InitPowerMgmt)
|
|
? "Device-initiated power management is supported and enabled"
|
|
: "Device-initiated power management is supported");
|
|
}
|
|
|
|
if(ataIdentify.SATAFeatures.HasFlag(Identify.SATAFeaturesBit.InOrderData))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledSATAFeatures.HasFlag(Identify.SATAFeaturesBit
|
|
.InOrderData)
|
|
? "In-order data delivery is supported and enabled"
|
|
: "In-order data delivery is supported");
|
|
}
|
|
|
|
switch(atapi)
|
|
{
|
|
case false:
|
|
{
|
|
if(ataIdentify.SATAFeatures.HasFlag(Identify.SATAFeaturesBit.HardwareFeatureControl))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledSATAFeatures.HasFlag(Identify
|
|
.SATAFeaturesBit.HardwareFeatureControl)
|
|
? "Hardware Feature Control is supported and enabled"
|
|
: "Hardware Feature Control is supported");
|
|
}
|
|
|
|
break;
|
|
}
|
|
case true:
|
|
{
|
|
if(ataIdentify.SATAFeatures.HasFlag(Identify.SATAFeaturesBit.AsyncNotification))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledSATAFeatures.HasFlag(Identify
|
|
.SATAFeaturesBit.AsyncNotification)
|
|
? "Asynchronous notification is supported and enabled"
|
|
: "Asynchronous notification is supported");
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ataIdentify.SATAFeatures.HasFlag(Identify.SATAFeaturesBit.SettingsPreserve))
|
|
{
|
|
commandSetAndFeatures.Add(ataIdentify.EnabledSATAFeatures.HasFlag(Identify.SATAFeaturesBit
|
|
.SettingsPreserve)
|
|
? "Software Settings Preservation is supported and enabled"
|
|
: "Software Settings Preservation is supported");
|
|
}
|
|
|
|
if(ataIdentify.SATAFeatures.HasFlag(Identify.SATAFeaturesBit.NCQAutoSense))
|
|
commandSetAndFeatures.Add("NCQ Autosense is supported");
|
|
|
|
if(ataIdentify.EnabledSATAFeatures.HasFlag(Identify.SATAFeaturesBit.EnabledSlumber))
|
|
commandSetAndFeatures.Add("Automatic Partial to Slumber transitions are enabled");
|
|
}
|
|
}
|
|
}
|
|
|
|
if((ataIdentify.RemovableStatusSet & 0x03) > 0)
|
|
commandSetAndFeatures.Add("Removable Media Status Notification feature set is supported");
|
|
|
|
if(ataIdentify.FreeFallSensitivity != 0x00 && ataIdentify.FreeFallSensitivity != 0xFF)
|
|
{
|
|
specificConfiguration ??= [];
|
|
specificConfiguration.Add($"Free-fall sensitivity set to {ataIdentify.FreeFallSensitivity}");
|
|
}
|
|
|
|
if(ataIdentify.DataSetMgmt.HasFlag(Identify.DataSetMgmtBit.Trim))
|
|
commandSetAndFeatures.Add("TRIM is supported");
|
|
|
|
if(ataIdentify.DataSetMgmtSize > 0)
|
|
{
|
|
commandSetAndFeatures
|
|
.Add($"DATA SET MANAGEMENT can receive a maximum of {ataIdentify.DataSetMgmtSize} blocks of 512 bytes");
|
|
}
|
|
|
|
if(ataIdentify.SecurityStatus.HasFlag(Identify.SecurityStatusBit.Supported))
|
|
{
|
|
security = [];
|
|
|
|
if(ataIdentify.SecurityStatus.HasFlag(Identify.SecurityStatusBit.Enabled))
|
|
{
|
|
security.Add("Security is enabled");
|
|
|
|
security.Add(ataIdentify.SecurityStatus.HasFlag(Identify.SecurityStatusBit.Locked)
|
|
? "Security is locked"
|
|
: "Security is not locked");
|
|
|
|
security.Add(ataIdentify.SecurityStatus.HasFlag(Identify.SecurityStatusBit.Frozen)
|
|
? "Security is frozen"
|
|
: "Security is not frozen");
|
|
|
|
security.Add(ataIdentify.SecurityStatus.HasFlag(Identify.SecurityStatusBit.Expired)
|
|
? "Security count has expired"
|
|
: "Security count has not expired");
|
|
|
|
security.Add(ataIdentify.SecurityStatus.HasFlag(Identify.SecurityStatusBit.Maximum)
|
|
? "Security level is maximum"
|
|
: "Security level is high");
|
|
}
|
|
else
|
|
security.Add("Security is not enabled");
|
|
|
|
if(ataIdentify.SecurityStatus.HasFlag(Identify.SecurityStatusBit.Enhanced))
|
|
security.Add("Supports enhanced security erase");
|
|
|
|
security.Add($"{ataIdentify.SecurityEraseTime * 2} minutes to complete secure erase");
|
|
|
|
if(ataIdentify.SecurityStatus.HasFlag(Identify.SecurityStatusBit.Enhanced))
|
|
security.Add($"{ataIdentify.EnhancedSecurityEraseTime * 2} minutes to complete enhanced secure erase");
|
|
|
|
security.Add($"Master password revision code: {ataIdentify.MasterPasswordRevisionCode}");
|
|
}
|
|
|
|
if(ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.MustBeSet) &&
|
|
!ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.MustBeClear) &&
|
|
ataIdentify.CommandSet3.HasFlag(Identify.CommandSetBit3.Streaming))
|
|
{
|
|
streaming = [];
|
|
streaming.Add($"Minimum request size is {ataIdentify.StreamMinReqSize}");
|
|
streaming.Add($"Streaming transfer time in PIO is {ataIdentify.StreamTransferTimePIO}");
|
|
streaming.Add($"Streaming transfer time in DMA is {ataIdentify.StreamTransferTimeDMA}");
|
|
streaming.Add($"Streaming access latency is {ataIdentify.StreamAccessLatency}");
|
|
streaming.Add($"Streaming performance granularity is {ataIdentify.StreamPerformanceGranularity}");
|
|
}
|
|
|
|
if(ataIdentify.SCTCommandTransport.HasFlag(Identify.SCTCommandTransportBit.Supported))
|
|
{
|
|
smartCommandTransport = [];
|
|
|
|
if(ataIdentify.SCTCommandTransport.HasFlag(Identify.SCTCommandTransportBit.LongSectorAccess))
|
|
smartCommandTransport.Add("SCT Long Sector Address is supported");
|
|
|
|
if(ataIdentify.SCTCommandTransport.HasFlag(Identify.SCTCommandTransportBit.WriteSame))
|
|
smartCommandTransport.Add("SCT Write Same is supported");
|
|
|
|
if(ataIdentify.SCTCommandTransport.HasFlag(Identify.SCTCommandTransportBit.ErrorRecoveryControl))
|
|
smartCommandTransport.Add("SCT Error Recovery Control is supported");
|
|
|
|
if(ataIdentify.SCTCommandTransport.HasFlag(Identify.SCTCommandTransportBit.FeaturesControl))
|
|
smartCommandTransport.Add("SCT Features Control is supported");
|
|
|
|
if(ataIdentify.SCTCommandTransport.HasFlag(Identify.SCTCommandTransportBit.DataTables))
|
|
smartCommandTransport.Add("SCT Data Tables are supported");
|
|
}
|
|
|
|
if((ataIdentify.NVCacheCaps & 0x0010) == 0x0010)
|
|
{
|
|
nvCache = [];
|
|
nvCache.Add($"Version {(ataIdentify.NVCacheCaps & 0xF000) >> 12}");
|
|
|
|
if((ataIdentify.NVCacheCaps & 0x0001) == 0x0001)
|
|
{
|
|
nvCache.Add((ataIdentify.NVCacheCaps & 0x0002) == 0x0002
|
|
? "Power mode feature set is supported and enabled"
|
|
: "Power mode feature set is supported");
|
|
|
|
nvCache.Add($"Version {(ataIdentify.NVCacheCaps & 0x0F00) >> 8}");
|
|
}
|
|
|
|
nvCache.Add($"Non-Volatile Cache is {ataIdentify.NVCacheSize * logicalSectorSize} bytes");
|
|
}
|
|
|
|
if(ataReport.ReadCapabilities != null)
|
|
{
|
|
removable = false;
|
|
|
|
if(ataReport.ReadCapabilities.NominalRotationRate != null &&
|
|
ataReport.ReadCapabilities.NominalRotationRate != 0x0000 &&
|
|
ataReport.ReadCapabilities.NominalRotationRate != 0xFFFF)
|
|
{
|
|
readCapabilitiesList.Add(ataReport.ReadCapabilities.NominalRotationRate == 0x0001
|
|
? "Device does not rotate."
|
|
: $"Device rotates at {ataReport.ReadCapabilities.NominalRotationRate} rpm");
|
|
}
|
|
|
|
if(!atapi)
|
|
{
|
|
if(ataReport.ReadCapabilities.BlockSize != null)
|
|
{
|
|
readCapabilitiesDictionary.Add("Logical sector size",
|
|
$"{ataReport.ReadCapabilities.BlockSize} bytes");
|
|
|
|
logicalSectorSize = ataReport.ReadCapabilities.BlockSize.Value;
|
|
}
|
|
|
|
if(ataReport.ReadCapabilities.PhysicalBlockSize != null)
|
|
readCapabilitiesDictionary.Add("Physical sector size",
|
|
$"{ataReport.ReadCapabilities.PhysicalBlockSize} bytes");
|
|
|
|
if(ataReport.ReadCapabilities.LongBlockSize != null)
|
|
readCapabilitiesDictionary.Add("READ LONG sector size",
|
|
$"{ataReport.ReadCapabilities.LongBlockSize} bytes");
|
|
|
|
if(ataReport.ReadCapabilities.BlockSize != null &&
|
|
ataReport.ReadCapabilities.PhysicalBlockSize != null &&
|
|
ataReport.ReadCapabilities.BlockSize.Value != ataReport.ReadCapabilities.PhysicalBlockSize.Value &&
|
|
(ataReport.ReadCapabilities.LogicalAlignment & 0x8000) == 0x0000 &&
|
|
(ataReport.ReadCapabilities.LogicalAlignment & 0x4000) == 0x4000)
|
|
{
|
|
readCapabilitiesList
|
|
.Add($"Logical sector starts at offset {ataReport.ReadCapabilities.LogicalAlignment & 0x3FFF} from physical sector");
|
|
}
|
|
|
|
if(ataReport.ReadCapabilities.CHS != null && ataReport.ReadCapabilities.CurrentCHS != null)
|
|
{
|
|
int currentSectors = ataReport.ReadCapabilities.CurrentCHS.Cylinders *
|
|
ataReport.ReadCapabilities.CurrentCHS.Heads *
|
|
ataReport.ReadCapabilities.CurrentCHS.Sectors;
|
|
|
|
readCapabilitiesDictionary.Add("Cylinders",
|
|
$"{ataReport.ReadCapabilities.CHS.Cylinders} max., {ataReport.ReadCapabilities.CurrentCHS.Cylinders} current");
|
|
|
|
readCapabilitiesDictionary.Add("Heads",
|
|
$"{ataReport.ReadCapabilities.CHS.Heads} max., {ataReport.ReadCapabilities.CurrentCHS.Heads} current");
|
|
|
|
readCapabilitiesDictionary.Add("Sectors per track",
|
|
$"{ataReport.ReadCapabilities.CHS.Sectors} max., {ataReport.ReadCapabilities.CurrentCHS.Sectors} current");
|
|
|
|
readCapabilitiesDictionary.Add("Sectors addressable in CHS mode",
|
|
$"{ataReport.ReadCapabilities.CHS.Cylinders * ataReport.ReadCapabilities.CHS.Heads * ataReport.ReadCapabilities.CHS.Sectors} max., {currentSectors} current");
|
|
|
|
readCapabilitiesDictionary.Add("Device size in CHS mode",
|
|
$"{(ulong)currentSectors * logicalSectorSize} bytes, {(ulong)currentSectors * logicalSectorSize / 1000 / 1000} Mb, {(double)((ulong)currentSectors * logicalSectorSize) / 1024 / 1024:F2} MiB");
|
|
}
|
|
else if(ataReport.ReadCapabilities.CHS != null)
|
|
{
|
|
int currentSectors = ataReport.ReadCapabilities.CHS.Cylinders *
|
|
ataReport.ReadCapabilities.CHS.Heads *
|
|
ataReport.ReadCapabilities.CHS.Sectors;
|
|
|
|
readCapabilitiesDictionary.Add("Cylinders", $"{ataReport.ReadCapabilities.CHS.Cylinders}");
|
|
readCapabilitiesDictionary.Add("Heads", $"{ataReport.ReadCapabilities.CHS.Heads}");
|
|
readCapabilitiesDictionary.Add("Sectors per track", $"{ataReport.ReadCapabilities.CHS.Sectors}");
|
|
readCapabilitiesDictionary.Add("Sectors addressable in CHS mode", $"{currentSectors}");
|
|
|
|
readCapabilitiesDictionary.Add("Device size in CHS mode",
|
|
$"{(ulong)currentSectors * logicalSectorSize} bytes, {(ulong)currentSectors * logicalSectorSize / 1000 / 1000} Mb, {(double)((ulong)currentSectors * logicalSectorSize) / 1024 / 1024:F2} MiB");
|
|
}
|
|
|
|
if(ataReport.ReadCapabilities.LBASectors != null)
|
|
{
|
|
readCapabilitiesDictionary.Add("Sectors addressable in sectors in 28-bit LBA mode",
|
|
$"{ataReport.ReadCapabilities.LBASectors}");
|
|
|
|
switch((ulong)ataReport.ReadCapabilities.LBASectors * logicalSectorSize / 1024 / 1024)
|
|
{
|
|
case > 1000000:
|
|
readCapabilitiesDictionary.Add("Device size in 28-bit LBA mode",
|
|
$"{(ulong)ataReport.ReadCapabilities.LBASectors * logicalSectorSize} bytes, {(ulong)ataReport.ReadCapabilities.LBASectors * logicalSectorSize / 1000 / 1000 / 1000 / 1000} Tb, {(double)((ulong)ataReport.ReadCapabilities.LBASectors * logicalSectorSize) / 1024 / 1024 / 1024 / 1024:F2} TiB");
|
|
|
|
break;
|
|
case > 1000:
|
|
readCapabilitiesDictionary.Add("Device size in 28-bit LBA mode",
|
|
$"{(ulong)ataReport.ReadCapabilities.LBASectors * logicalSectorSize} bytes, {(ulong)ataReport.ReadCapabilities.LBASectors * logicalSectorSize / 1000 / 1000 / 1000} Gb, {(double)((ulong)ataReport.ReadCapabilities.LBASectors * logicalSectorSize) / 1024 / 1024 / 1024:F2} GiB");
|
|
|
|
break;
|
|
default:
|
|
readCapabilitiesDictionary.Add("Device size in 28-bit LBA mode",
|
|
$"{(ulong)ataReport.ReadCapabilities.LBASectors * logicalSectorSize} bytes, {(ulong)ataReport.ReadCapabilities.LBASectors * logicalSectorSize / 1000 / 1000} Mb, {(double)((ulong)ataReport.ReadCapabilities.LBASectors * logicalSectorSize) / 1024 / 1024:F2} MiB");
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ataReport.ReadCapabilities.LBA48Sectors != null)
|
|
{
|
|
readCapabilitiesDictionary.Add("Sectors addressable in sectors in 48-bit LBA mode",
|
|
$"{ataReport.ReadCapabilities.LBA48Sectors}");
|
|
|
|
switch(ataReport.ReadCapabilities.LBA48Sectors * logicalSectorSize / 1024 / 1024)
|
|
{
|
|
case > 1000000:
|
|
readCapabilitiesDictionary.Add("Device size in 48-bit LBA mode",
|
|
$"{ataReport.ReadCapabilities.LBA48Sectors * logicalSectorSize} bytes, {ataReport.ReadCapabilities.LBA48Sectors * logicalSectorSize / 1000 / 1000 / 1000 / 1000} Tb, {(double)(ataReport.ReadCapabilities.LBA48Sectors * logicalSectorSize) / 1024 / 1024 / 1024 / 1024:F2} TiB");
|
|
|
|
break;
|
|
case > 1000:
|
|
readCapabilitiesDictionary.Add("Device size in 48-bit LBA mode",
|
|
$"{ataReport.ReadCapabilities.LBA48Sectors * logicalSectorSize} bytes, {ataReport.ReadCapabilities.LBA48Sectors * logicalSectorSize / 1000 / 1000 / 1000} Gb, {(double)(ataReport.ReadCapabilities.LBA48Sectors * logicalSectorSize) / 1024 / 1024 / 1024:F2} GiB");
|
|
|
|
break;
|
|
default:
|
|
readCapabilitiesDictionary.Add("Device size in 48-bit LBA mode",
|
|
$"{ataReport.ReadCapabilities.LBA48Sectors * logicalSectorSize} bytes, {ataReport.ReadCapabilities.LBA48Sectors * logicalSectorSize / 1000 / 1000} Mb, {(double)(ataReport.ReadCapabilities.LBA48Sectors * logicalSectorSize) / 1024 / 1024:F2} MiB");
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ata1 || cfa)
|
|
{
|
|
if(ataReport.ReadCapabilities.UnformattedBPT > 0)
|
|
readCapabilitiesDictionary.Add("Bytes per unformatted track",
|
|
$"{ataReport.ReadCapabilities.UnformattedBPT}");
|
|
|
|
if(ataReport.ReadCapabilities.UnformattedBPS > 0)
|
|
readCapabilitiesDictionary.Add("Bytes per unformatted sector",
|
|
$"{ataReport.ReadCapabilities.UnformattedBPS}");
|
|
}
|
|
}
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadSectors == true)
|
|
readCapabilitiesList.Add("Device supports READ SECTOR(S) command in CHS mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadRetry == true)
|
|
readCapabilitiesList.Add("Device supports READ SECTOR(S) RETRY command in CHS mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadDma == true)
|
|
readCapabilitiesList.Add("Device supports READ DMA command in CHS mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadDmaRetry == true)
|
|
readCapabilitiesList.Add("Device supports READ DMA RETRY command in CHS mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadLong == true)
|
|
readCapabilitiesList.Add("Device supports READ LONG command in CHS mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadLongRetry == true)
|
|
readCapabilitiesList.Add("Device supports READ LONG RETRY command in CHS mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadLba == true)
|
|
readCapabilitiesList.Add("Device supports READ SECTOR(S) command in 28-bit LBA mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadRetryLba == true)
|
|
readCapabilitiesList.Add("Device supports READ SECTOR(S) RETRY command in 28-bit LBA mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadDmaLba == true)
|
|
readCapabilitiesList.Add("Device supports READ DMA command in 28-bit LBA mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadDmaRetryLba == true)
|
|
readCapabilitiesList.Add("Device supports READ DMA RETRY command in 28-bit LBA mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadLongLba == true)
|
|
readCapabilitiesList.Add("Device supports READ LONG command in 28-bit LBA mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadLongRetryLba == true)
|
|
readCapabilitiesList.Add("Device supports READ LONG RETRY command in 28-bit LBA mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadLba48 == true)
|
|
readCapabilitiesList.Add("Device supports READ SECTOR(S) command in 48-bit LBA mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsReadDmaLba48 == true)
|
|
readCapabilitiesList.Add("Device supports READ DMA command in 48-bit LBA mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsSeek == true)
|
|
readCapabilitiesList.Add("Device supports SEEK command in CHS mode");
|
|
|
|
if(ataReport.ReadCapabilities.SupportsSeekLba == true)
|
|
readCapabilitiesList.Add("Device supports SEEK command in 28-bit LBA mode");
|
|
}
|
|
else
|
|
testedMedia = ataReport.RemovableMedias;
|
|
}
|
|
} |