aaru-dps/Aaru
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.git synced 2025-12-16 19:24:25 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
e05de44620a4cf1f3e3e31dfe2229a0a8acffe40
Aaru/DiscImageChef.Core/Devices/Report/ATA.cs

1239 lines
65 KiB
C#
Raw Normal View History

Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : ATA.cs
REFACTOR: Updated comments and copyright date.
2017-12-19 03:50:57 +00:00
// Author(s) : Natalia Portillo <claunia@claunia.com>
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
//
REFACTOR: Updated comments and copyright date.
2017-12-19 03:50:57 +00:00
// Component : Core algorithms.
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
//
// --[ Description ] ----------------------------------------------------------
//
REFACTOR: Updated comments and copyright date.
2017-12-19 03:50:57 +00:00
// Creates reports from ATA devices.
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
//
// --[ License ] --------------------------------------------------------------
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
REFACTOR: Updated comments and copyright date.
2017-12-19 03:50:57 +00:00
// Copyright © 2011-2018 Natalia Portillo
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
// ****************************************************************************/
REFACTOR: Updated comments and copyright date.
2017-12-19 03:50:57 +00:00
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
using System;
using System.Collections.Generic;
using DiscImageChef.Console;
REFACTOR: Remove unneeded code.
2017-12-21 14:30:38 +00:00
using DiscImageChef.Decoders.ATA;
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
using DiscImageChef.Devices;
using DiscImageChef.Metadata;
namespace DiscImageChef.Core.Devices.Report
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
/// <summary>
/// Implements creating a report for an ATA device
/// </summary>
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
public static class Ata
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
/// <summary>
/// Creates a report of an ATA device
/// </summary>
/// <param name="dev">Device</param>
/// <param name="report">Device report</param>
/// <param name="debug">If debug is enabled</param>
/// <param name="removable">If device is removable</param>
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
public static void Report(Device dev, ref DeviceReport report, bool debug, ref bool removable)
{
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
if(report == null) return;
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
REFACTOR: All refactor in DiscImageChef.Core.
2017-12-21 23:00:30 +00:00
const uint TIMEOUT = 5;
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(dev.IsUsb) Usb.Report(dev, ref report, debug, ref removable);
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
REFACTOR: All refactor in DiscImageChef.Core.
2017-12-21 23:00:30 +00:00
if(dev.IsFireWire) FireWire.Report(dev, ref report, ref removable);
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
REFACTOR: All refactor in DiscImageChef.Core.
2017-12-21 23:00:30 +00:00
if(dev.IsPcmcia) Pcmcia.Report(dev, ref report);
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
DicConsole.WriteLine("Querying ATA IDENTIFY...");
REFACTOR: All refactor in DiscImageChef.Core.
2017-12-21 23:00:30 +00:00
dev.AtaIdentify(out byte[] buffer, out _, TIMEOUT, out _);
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
REFACTOR: Remove unneeded code.
2017-12-21 14:30:38 +00:00
if(!Identify.Decode(buffer).HasValue) return;
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
Identify.IdentifyDevice? ataIdNullable = Identify.Decode(buffer);
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataIdNullable == null) return;
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
Identify.IdentifyDevice ataId = ataIdNullable.Value;
ConsoleKeyInfo pressedKey;
if((ushort)ataId.GeneralConfiguration == 0x848A)
{
report.CompactFlash = true;
report.CompactFlashSpecified = true;
removable = false;
}
else if(!removable &&
ataId.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.Removable))
{
pressedKey = new ConsoleKeyInfo();
while(pressedKey.Key != ConsoleKey.Y && pressedKey.Key != ConsoleKey.N)
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
DicConsole.Write("Is the media removable from the reading/writing elements? (Y/N): ");
pressedKey = System.Console.ReadKey();
DicConsole.WriteLine();
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
}
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
removable = pressedKey.Key == ConsoleKey.Y;
}
if(removable)
{
DicConsole.WriteLine("Please remove any media from the device and press any key when it is out.");
System.Console.ReadKey(true);
DicConsole.WriteLine("Querying ATA IDENTIFY...");
dev.AtaIdentify(out buffer, out _, TIMEOUT, out _);
ataId = Identify.Decode(buffer).Value;
}
report.ATA = new ataType();
if(!string.IsNullOrWhiteSpace(ataId.AdditionalPID))
{
report.ATA.AdditionalPID = ataId.AdditionalPID;
report.ATA.AdditionalPIDSpecified = true;
}
if(ataId.APIOSupported != 0)
{
report.ATA.APIOSupported = ataId.APIOSupported;
report.ATA.APIOSupportedSpecified = true;
}
if(ataId.BufferType != 0)
{
report.ATA.BufferType = ataId.BufferType;
report.ATA.BufferTypeSpecified = true;
}
if(ataId.BufferSize != 0)
{
report.ATA.BufferSize = ataId.BufferSize;
report.ATA.BufferSizeSpecified = true;
}
if(ataId.Capabilities != 0)
{
report.ATA.Capabilities = ataId.Capabilities;
report.ATA.CapabilitiesSpecified = true;
}
if(ataId.Capabilities2 != 0)
{
report.ATA.Capabilities2 = ataId.Capabilities2;
report.ATA.Capabilities2Specified = true;
}
if(ataId.Capabilities3 != 0)
{
report.ATA.Capabilities3 = ataId.Capabilities3;
report.ATA.Capabilities3Specified = true;
}
if(ataId.CFAPowerMode != 0)
{
report.ATA.CFAPowerMode = ataId.CFAPowerMode;
report.ATA.CFAPowerModeSpecified = true;
}
if(ataId.CommandSet != 0)
{
report.ATA.CommandSet = ataId.CommandSet;
report.ATA.CommandSetSpecified = true;
}
if(ataId.CommandSet2 != 0)
{
report.ATA.CommandSet2 = ataId.CommandSet2;
report.ATA.CommandSet2Specified = true;
}
if(ataId.CommandSet3 != 0)
{
report.ATA.CommandSet3 = ataId.CommandSet3;
report.ATA.CommandSet3Specified = true;
}
if(ataId.CommandSet4 != 0)
{
report.ATA.CommandSet4 = ataId.CommandSet4;
report.ATA.CommandSet4Specified = true;
}
if(ataId.CommandSet5 != 0)
{
report.ATA.CommandSet5 = ataId.CommandSet5;
report.ATA.CommandSet5Specified = true;
}
if(ataId.CurrentAAM != 0)
{
report.ATA.CurrentAAM = ataId.CurrentAAM;
report.ATA.CurrentAAMSpecified = true;
}
if(ataId.CurrentAPM != 0)
{
report.ATA.CurrentAPM = ataId.CurrentAPM;
report.ATA.CurrentAPMSpecified = true;
}
if(ataId.DataSetMgmt != 0)
{
report.ATA.DataSetMgmt = ataId.DataSetMgmt;
report.ATA.DataSetMgmtSpecified = true;
}
if(ataId.DataSetMgmtSize != 0)
{
report.ATA.DataSetMgmtSize = ataId.DataSetMgmtSize;
report.ATA.DataSetMgmtSizeSpecified = true;
}
if(ataId.DeviceFormFactor != 0)
{
report.ATA.DeviceFormFactor = ataId.DeviceFormFactor;
report.ATA.DeviceFormFactorSpecified = true;
}
if(ataId.DMAActive != 0)
{
report.ATA.DMAActive = ataId.DMAActive;
report.ATA.DMAActiveSpecified = true;
}
if(ataId.DMASupported != 0)
{
report.ATA.DMASupported = ataId.DMASupported;
report.ATA.DMASupportedSpecified = true;
}
if(ataId.DMATransferTimingMode != 0)
{
report.ATA.DMATransferTimingMode = ataId.DMATransferTimingMode;
report.ATA.DMATransferTimingModeSpecified = true;
}
if(ataId.EnhancedSecurityEraseTime != 0)
{
report.ATA.EnhancedSecurityEraseTime = ataId.EnhancedSecurityEraseTime;
report.ATA.EnhancedSecurityEraseTimeSpecified = true;
}
if(ataId.EnabledCommandSet != 0)
{
report.ATA.EnabledCommandSet = ataId.EnabledCommandSet;
report.ATA.EnabledCommandSetSpecified = true;
}
if(ataId.EnabledCommandSet2 != 0)
{
report.ATA.EnabledCommandSet2 = ataId.EnabledCommandSet2;
report.ATA.EnabledCommandSet2Specified = true;
}
if(ataId.EnabledCommandSet3 != 0)
{
report.ATA.EnabledCommandSet3 = ataId.EnabledCommandSet3;
report.ATA.EnabledCommandSet3Specified = true;
}
if(ataId.EnabledCommandSet4 != 0)
{
report.ATA.EnabledCommandSet4 = ataId.EnabledCommandSet4;
report.ATA.EnabledCommandSet4Specified = true;
}
if(ataId.EnabledSATAFeatures != 0)
{
report.ATA.EnabledSATAFeatures = ataId.EnabledSATAFeatures;
report.ATA.EnabledSATAFeaturesSpecified = true;
}
if(ataId.ExtendedUserSectors != 0)
{
report.ATA.ExtendedUserSectors = ataId.ExtendedUserSectors;
report.ATA.ExtendedUserSectorsSpecified = true;
}
if(ataId.FreeFallSensitivity != 0)
{
report.ATA.FreeFallSensitivity = ataId.FreeFallSensitivity;
report.ATA.FreeFallSensitivitySpecified = true;
}
if(!string.IsNullOrWhiteSpace(ataId.FirmwareRevision))
{
report.ATA.FirmwareRevision = ataId.FirmwareRevision;
report.ATA.FirmwareRevisionSpecified = true;
}
if(ataId.GeneralConfiguration != 0)
{
report.ATA.GeneralConfiguration = ataId.GeneralConfiguration;
report.ATA.GeneralConfigurationSpecified = true;
}
if(ataId.HardwareResetResult != 0)
{
report.ATA.HardwareResetResult = ataId.HardwareResetResult;
report.ATA.HardwareResetResultSpecified = true;
}
if(ataId.InterseekDelay != 0)
{
report.ATA.InterseekDelay = ataId.InterseekDelay;
report.ATA.InterseekDelaySpecified = true;
}
if(ataId.MajorVersion != 0)
{
report.ATA.MajorVersion = ataId.MajorVersion;
report.ATA.MajorVersionSpecified = true;
}
if(ataId.MasterPasswordRevisionCode != 0)
{
report.ATA.MasterPasswordRevisionCode = ataId.MasterPasswordRevisionCode;
report.ATA.MasterPasswordRevisionCodeSpecified = true;
}
if(ataId.MaxDownloadMicroMode3 != 0)
{
report.ATA.MaxDownloadMicroMode3 = ataId.MaxDownloadMicroMode3;
report.ATA.MaxDownloadMicroMode3Specified = true;
}
if(ataId.MaxQueueDepth != 0)
{
report.ATA.MaxQueueDepth = ataId.MaxQueueDepth;
report.ATA.MaxQueueDepthSpecified = true;
}
if(ataId.MDMAActive != 0)
{
report.ATA.MDMAActive = ataId.MDMAActive;
report.ATA.MDMAActiveSpecified = true;
}
if(ataId.MDMASupported != 0)
{
report.ATA.MDMASupported = ataId.MDMASupported;
report.ATA.MDMASupportedSpecified = true;
}
if(ataId.MinDownloadMicroMode3 != 0)
{
report.ATA.MinDownloadMicroMode3 = ataId.MinDownloadMicroMode3;
report.ATA.MinDownloadMicroMode3Specified = true;
}
if(ataId.MinMDMACycleTime != 0)
{
report.ATA.MinMDMACycleTime = ataId.MinMDMACycleTime;
report.ATA.MinMDMACycleTimeSpecified = true;
}
if(ataId.MinorVersion != 0)
{
report.ATA.MinorVersion = ataId.MinorVersion;
report.ATA.MinorVersionSpecified = true;
}
if(ataId.MinPIOCycleTimeNoFlow != 0)
{
report.ATA.MinPIOCycleTimeNoFlow = ataId.MinPIOCycleTimeNoFlow;
report.ATA.MinPIOCycleTimeNoFlowSpecified = true;
}
if(ataId.MinPIOCycleTimeFlow != 0)
{
report.ATA.MinPIOCycleTimeFlow = ataId.MinPIOCycleTimeFlow;
report.ATA.MinPIOCycleTimeFlowSpecified = true;
}
if(!string.IsNullOrWhiteSpace(ataId.Model))
{
report.ATA.Model = ataId.Model;
report.ATA.ModelSpecified = true;
}
if(ataId.MultipleMaxSectors != 0)
{
report.ATA.MultipleMaxSectors = ataId.MultipleMaxSectors;
report.ATA.MultipleMaxSectorsSpecified = true;
}
if(ataId.MultipleSectorNumber != 0)
{
report.ATA.MultipleSectorNumber = ataId.MultipleSectorNumber;
report.ATA.MultipleSectorNumberSpecified = true;
}
if(ataId.NVCacheCaps != 0)
{
report.ATA.NVCacheCaps = ataId.NVCacheCaps;
report.ATA.NVCacheCapsSpecified = true;
}
if(ataId.NVCacheSize != 0)
{
report.ATA.NVCacheSize = ataId.NVCacheSize;
report.ATA.NVCacheSizeSpecified = true;
}
if(ataId.NVCacheWriteSpeed != 0)
{
report.ATA.NVCacheWriteSpeed = ataId.NVCacheWriteSpeed;
report.ATA.NVCacheWriteSpeedSpecified = true;
}
if(ataId.NVEstimatedSpinUp != 0)
{
report.ATA.NVEstimatedSpinUp = ataId.NVEstimatedSpinUp;
report.ATA.NVEstimatedSpinUpSpecified = true;
}
if(ataId.PacketBusRelease != 0)
{
report.ATA.PacketBusRelease = ataId.PacketBusRelease;
report.ATA.PacketBusReleaseSpecified = true;
}
if(ataId.PIOTransferTimingMode != 0)
{
report.ATA.PIOTransferTimingMode = ataId.PIOTransferTimingMode;
report.ATA.PIOTransferTimingModeSpecified = true;
}
if(ataId.RecommendedAAM != 0)
{
report.ATA.RecommendedAAM = ataId.RecommendedAAM;
report.ATA.RecommendedAAMSpecified = true;
}
if(ataId.RecMDMACycleTime != 0)
{
report.ATA.RecommendedMDMACycleTime = ataId.RecMDMACycleTime;
report.ATA.RecommendedMDMACycleTimeSpecified = true;
}
if(ataId.RemovableStatusSet != 0)
{
report.ATA.RemovableStatusSet = ataId.RemovableStatusSet;
report.ATA.RemovableStatusSetSpecified = true;
}
if(ataId.SATACapabilities != 0)
{
report.ATA.SATACapabilities = ataId.SATACapabilities;
report.ATA.SATACapabilitiesSpecified = true;
}
if(ataId.SATACapabilities2 != 0)
{
report.ATA.SATACapabilities2 = ataId.SATACapabilities2;
report.ATA.SATACapabilities2Specified = true;
}
if(ataId.SATAFeatures != 0)
{
report.ATA.SATAFeatures = ataId.SATAFeatures;
report.ATA.SATAFeaturesSpecified = true;
}
if(ataId.SCTCommandTransport != 0)
{
report.ATA.SCTCommandTransport = ataId.SCTCommandTransport;
report.ATA.SCTCommandTransportSpecified = true;
}
if(ataId.SectorsPerCard != 0)
{
report.ATA.SectorsPerCard = ataId.SectorsPerCard;
report.ATA.SectorsPerCardSpecified = true;
}
if(ataId.SecurityEraseTime != 0)
{
report.ATA.SecurityEraseTime = ataId.SecurityEraseTime;
report.ATA.SecurityEraseTimeSpecified = true;
}
if(ataId.SecurityStatus != 0)
{
report.ATA.SecurityStatus = ataId.SecurityStatus;
report.ATA.SecurityStatusSpecified = true;
}
if(ataId.ServiceBusyClear != 0)
{
report.ATA.ServiceBusyClear = ataId.ServiceBusyClear;
report.ATA.ServiceBusyClearSpecified = true;
}
if(ataId.SpecificConfiguration != 0)
{
report.ATA.SpecificConfiguration = ataId.SpecificConfiguration;
report.ATA.SpecificConfigurationSpecified = true;
}
if(ataId.StreamAccessLatency != 0)
{
report.ATA.StreamAccessLatency = ataId.StreamAccessLatency;
report.ATA.StreamAccessLatencySpecified = true;
}
if(ataId.StreamMinReqSize != 0)
{
report.ATA.StreamMinReqSize = ataId.StreamMinReqSize;
report.ATA.StreamMinReqSizeSpecified = true;
}
if(ataId.StreamPerformanceGranularity != 0)
{
report.ATA.StreamPerformanceGranularity = ataId.StreamPerformanceGranularity;
report.ATA.StreamPerformanceGranularitySpecified = true;
}
if(ataId.StreamTransferTimeDMA != 0)
{
report.ATA.StreamTransferTimeDMA = ataId.StreamTransferTimeDMA;
report.ATA.StreamTransferTimeDMASpecified = true;
}
if(ataId.StreamTransferTimePIO != 0)
{
report.ATA.StreamTransferTimePIO = ataId.StreamTransferTimePIO;
report.ATA.StreamTransferTimePIOSpecified = true;
}
if(ataId.TransportMajorVersion != 0)
{
report.ATA.TransportMajorVersion = ataId.TransportMajorVersion;
report.ATA.TransportMajorVersionSpecified = true;
}
if(ataId.TransportMinorVersion != 0)
{
report.ATA.TransportMinorVersion = ataId.TransportMinorVersion;
report.ATA.TransportMinorVersionSpecified = true;
}
if(ataId.TrustedComputing != 0)
{
report.ATA.TrustedComputing = ataId.TrustedComputing;
report.ATA.TrustedComputingSpecified = true;
}
if(ataId.UDMAActive != 0)
{
report.ATA.UDMAActive = ataId.UDMAActive;
report.ATA.UDMAActiveSpecified = true;
}
if(ataId.UDMASupported != 0)
{
report.ATA.UDMASupported = ataId.UDMASupported;
report.ATA.UDMASupportedSpecified = true;
}
if(ataId.WRVMode != 0)
{
report.ATA.WRVMode = ataId.WRVMode;
report.ATA.WRVModeSpecified = true;
}
if(ataId.WRVSectorCountMode3 != 0)
{
report.ATA.WRVSectorCountMode3 = ataId.WRVSectorCountMode3;
report.ATA.WRVSectorCountMode3Specified = true;
}
if(ataId.WRVSectorCountMode2 != 0)
{
report.ATA.WRVSectorCountMode2 = ataId.WRVSectorCountMode2;
report.ATA.WRVSectorCountMode2Specified = true;
}
if(debug) report.ATA.Identify = buffer;
if(removable)
{
List<testedMediaType> mediaTests = new List<testedMediaType>();
pressedKey = new ConsoleKeyInfo();
while(pressedKey.Key != ConsoleKey.N)
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
{
pressedKey = new ConsoleKeyInfo();
while(pressedKey.Key != ConsoleKey.Y && pressedKey.Key != ConsoleKey.N)
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
DicConsole.Write("Do you have media that you can insert in the drive? (Y/N): ");
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
pressedKey = System.Console.ReadKey();
DicConsole.WriteLine();
}
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(pressedKey.Key != ConsoleKey.Y) continue;
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
DicConsole.WriteLine("Please insert it in the drive and press any key when it is ready.");
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
System.Console.ReadKey(true);
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
testedMediaType mediaTest = new testedMediaType();
DicConsole.Write("Please write a description of the media type and press enter: ");
mediaTest.MediumTypeName = System.Console.ReadLine();
DicConsole.Write("Please write the media model and press enter: ");
mediaTest.Model = System.Console.ReadLine();
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
mediaTest.ManufacturerSpecified = true;
mediaTest.ModelSpecified = true;
mediaTest.MediaIsRecognized = true;
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
DicConsole.WriteLine("Querying ATA IDENTIFY...");
dev.AtaIdentify(out buffer, out _, TIMEOUT, out _);
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(Identify.Decode(buffer).HasValue)
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
ataId = Identify.Decode(buffer).Value;
if(ataId.UnformattedBPT != 0)
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
mediaTest.UnformattedBPT = ataId.UnformattedBPT;
mediaTest.UnformattedBPTSpecified = true;
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
}
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.UnformattedBPS != 0)
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
mediaTest.UnformattedBPS = ataId.UnformattedBPS;
mediaTest.UnformattedBPSSpecified = true;
}
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.Cylinders > 0 && ataId.Heads > 0 && ataId.SectorsPerTrack > 0)
{
mediaTest.CHS = new chsType
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
Cylinders = ataId.Cylinders,
Heads = ataId.Heads,
Sectors = ataId.SectorsPerTrack
};
mediaTest.Blocks = (ulong)(ataId.Cylinders * ataId.Heads * ataId.SectorsPerTrack);
mediaTest.BlocksSpecified = true;
}
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.CurrentCylinders > 0 && ataId.CurrentHeads > 0 &&
ataId.CurrentSectorsPerTrack > 0)
{
mediaTest.CurrentCHS = new chsType
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
Cylinders = ataId.CurrentCylinders,
Heads = ataId.CurrentHeads,
Sectors = ataId.CurrentSectorsPerTrack
};
if(mediaTest.Blocks == 0)
mediaTest.Blocks =
(ulong)(ataId.CurrentCylinders * ataId.CurrentHeads *
ataId.CurrentSectorsPerTrack);
mediaTest.BlocksSpecified = true;
}
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.Capabilities.HasFlag(Identify.CapabilitiesBit.LBASupport))
{
mediaTest.LBASectors = ataId.LBASectors;
mediaTest.LBASectorsSpecified = true;
mediaTest.Blocks = ataId.LBASectors;
mediaTest.BlocksSpecified = true;
}
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.CommandSet2.HasFlag(Identify.CommandSetBit2.LBA48))
{
mediaTest.LBA48Sectors = ataId.LBA48Sectors;
mediaTest.LBA48SectorsSpecified = true;
mediaTest.Blocks = ataId.LBA48Sectors;
mediaTest.BlocksSpecified = true;
}
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.NominalRotationRate != 0x0000 && ataId.NominalRotationRate != 0xFFFF)
if(ataId.NominalRotationRate == 0x0001)
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
mediaTest.SolidStateDevice = true;
mediaTest.SolidStateDeviceSpecified = true;
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
}
else
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
mediaTest.SolidStateDevice = false;
mediaTest.SolidStateDeviceSpecified = true;
mediaTest.NominalRotationRate = ataId.NominalRotationRate;
mediaTest.NominalRotationRateSpecified = true;
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
}
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
uint logicalsectorsize;
uint physicalsectorsize;
if((ataId.PhysLogSectorSize & 0x8000) == 0x0000 &&
(ataId.PhysLogSectorSize & 0x4000) == 0x4000)
{
if((ataId.PhysLogSectorSize & 0x1000) == 0x1000)
if(ataId.LogicalSectorWords <= 255 || ataId.LogicalAlignment == 0xFFFF)
logicalsectorsize = 512;
else logicalsectorsize = ataId.LogicalSectorWords * 2;
else logicalsectorsize = 512;
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if((ataId.PhysLogSectorSize & 0x2000) == 0x2000)
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
physicalsectorsize =
(uint)(logicalsectorsize * ((1 << ataId.PhysLogSectorSize) & 0xF));
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
}
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
else physicalsectorsize = logicalsectorsize;
}
else
{
logicalsectorsize = 512;
physicalsectorsize = 512;
}
mediaTest.BlockSize = logicalsectorsize;
mediaTest.BlockSizeSpecified = true;
if(physicalsectorsize != logicalsectorsize)
{
mediaTest.PhysicalBlockSize = physicalsectorsize;
mediaTest.PhysicalBlockSizeSpecified = true;
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if((ataId.LogicalAlignment & 0x8000) == 0x0000 &&
(ataId.LogicalAlignment & 0x4000) == 0x4000)
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
mediaTest.LogicalAlignment = (ushort)(ataId.LogicalAlignment & 0x3FFF);
mediaTest.LogicalAlignmentSpecified = true;
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
}
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
}
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.EccBytes != 0x0000 && ataId.EccBytes != 0xFFFF)
{
mediaTest.LongBlockSize = logicalsectorsize + ataId.EccBytes;
mediaTest.LongBlockSizeSpecified = true;
}
if(ataId.UnformattedBPS > logicalsectorsize &&
(!mediaTest.LongBlockSizeSpecified || mediaTest.LongBlockSize == 516))
{
mediaTest.LongBlockSize = ataId.UnformattedBPS;
mediaTest.LongBlockSizeSpecified = true;
}
if(ataId.CommandSet3.HasFlag(Identify.CommandSetBit3.MustBeSet) &&
!ataId.CommandSet3.HasFlag(Identify.CommandSetBit3.MustBeClear) &&
ataId.EnabledCommandSet3.HasFlag(Identify.CommandSetBit3.MediaSerial))
{
mediaTest.CanReadMediaSerial = true;
mediaTest.CanReadMediaSerialSpecified = true;
if(!string.IsNullOrWhiteSpace(ataId.MediaManufacturer))
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
mediaTest.Manufacturer = ataId.MediaManufacturer;
mediaTest.ManufacturerSpecified = true;
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
}
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
}
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
mediaTest.SupportsReadLbaSpecified = true;
mediaTest.SupportsReadRetryLbaSpecified = true;
mediaTest.SupportsReadDmaLbaSpecified = true;
mediaTest.SupportsReadDmaRetryLbaSpecified = true;
mediaTest.SupportsReadLongLbaSpecified = true;
mediaTest.SupportsReadLongRetryLbaSpecified = true;
mediaTest.SupportsSeekLbaSpecified = true;
mediaTest.SupportsReadLba48Specified = true;
mediaTest.SupportsReadDmaLba48Specified = true;
mediaTest.SupportsReadSpecified = true;
mediaTest.SupportsReadRetrySpecified = true;
mediaTest.SupportsReadDmaSpecified = true;
mediaTest.SupportsReadDmaRetrySpecified = true;
mediaTest.SupportsReadLongSpecified = true;
mediaTest.SupportsReadLongRetrySpecified = true;
mediaTest.SupportsSeekSpecified = true;
ulong checkCorrectRead = BitConverter.ToUInt64(buffer, 0);
bool sense;
DicConsole.WriteLine("Trying READ SECTOR(S) in CHS mode...");
sense = dev.Read(out byte[] readBuf, out AtaErrorRegistersChs errorChs, false, 0, 0, 1, 1, TIMEOUT, out _);
mediaTest.SupportsRead =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0 &&
readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readsectorschs",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying READ SECTOR(S) RETRY in CHS mode...");
sense = dev.Read(out readBuf, out errorChs, true, 0, 0, 1, 1, TIMEOUT, out _);
mediaTest.SupportsReadRetry =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0 &&
readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readsectorsretrychs",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying READ DMA in CHS mode...");
sense = dev.ReadDma(out readBuf, out errorChs, false, 0, 0, 1, 1, TIMEOUT,
out _);
mediaTest.SupportsReadDma =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0 &&
readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readdmachs",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying READ DMA RETRY in CHS mode...");
sense = dev.ReadDma(out readBuf, out errorChs, true, 0, 0, 1, 1, TIMEOUT, out _);
mediaTest.SupportsReadDmaRetry =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0 &&
readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readdmaretrychs",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying SEEK in CHS mode...");
sense = dev.Seek(out errorChs, 0, 0, 1, TIMEOUT, out _);
mediaTest.SupportsSeek =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}", sense,
errorChs.Status, errorChs.Error);
DicConsole.WriteLine("Trying READ SECTOR(S) in LBA mode...");
sense = dev.Read(out readBuf, out AtaErrorRegistersLba28 errorLba, false, 0, 1, TIMEOUT, out _);
mediaTest.SupportsReadLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0 &&
readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readsectors",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying READ SECTOR(S) RETRY in LBA mode...");
sense = dev.Read(out readBuf, out errorLba, true, 0, 1, TIMEOUT, out _);
mediaTest.SupportsReadRetryLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0 &&
readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readsectorsretry",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying READ DMA in LBA mode...");
sense = dev.ReadDma(out readBuf, out errorLba, false, 0, 1, TIMEOUT, out _);
mediaTest.SupportsReadDmaLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0 &&
readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readdma",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying READ DMA RETRY in LBA mode...");
sense = dev.ReadDma(out readBuf, out errorLba, true, 0, 1, TIMEOUT, out _);
mediaTest.SupportsReadDmaRetryLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0 &&
readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readdmaretry",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying SEEK in LBA mode...");
sense = dev.Seek(out errorLba, 0, TIMEOUT, out _);
mediaTest.SupportsSeekLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}", sense,
errorChs.Status, errorChs.Error);
DicConsole.WriteLine("Trying READ SECTOR(S) in LBA48 mode...");
sense = dev.Read(out readBuf, out AtaErrorRegistersLba48 errorLba48, 0, 1, TIMEOUT, out _);
mediaTest.SupportsReadLba48 =
!sense && (errorLba48.Status & 0x01) != 0x01 && errorLba48.Error == 0 &&
readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readsectors48",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying READ DMA in LBA48 mode...");
sense = dev.ReadDma(out readBuf, out errorLba48, 0, 1, TIMEOUT, out _);
mediaTest.SupportsReadDmaLba48 =
!sense && (errorLba48.Status & 0x01) != 0x01 && errorLba48.Error == 0 &&
readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readdma48",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying READ LONG in CHS mode...");
sense = dev.ReadLong(out readBuf, out errorChs, false, 0, 0, 1, mediaTest.LongBlockSize,
TIMEOUT, out _);
mediaTest.SupportsReadLong =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0 &&
readBuf.Length > 0 && BitConverter.ToUInt64(readBuf, 0) != checkCorrectRead;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readlongchs",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying READ LONG RETRY in CHS mode...");
sense = dev.ReadLong(out readBuf, out errorChs, true, 0, 0, 1, mediaTest.LongBlockSize,
TIMEOUT, out _);
mediaTest.SupportsReadLongRetry =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0 &&
readBuf.Length > 0 && BitConverter.ToUInt64(readBuf, 0) != checkCorrectRead;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readlongretrychs",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying READ LONG in LBA mode...");
sense = dev.ReadLong(out readBuf, out errorLba, false, 0, mediaTest.LongBlockSize,
TIMEOUT, out _);
mediaTest.SupportsReadLongLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0 &&
readBuf.Length > 0 && BitConverter.ToUInt64(readBuf, 0) != checkCorrectRead;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readlong",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying READ LONG RETRY in LBA mode...");
sense = dev.ReadLong(out readBuf, out errorLba, true, 0, mediaTest.LongBlockSize,
TIMEOUT, out _);
mediaTest.SupportsReadLongRetryLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0 &&
readBuf.Length > 0 && BitConverter.ToUInt64(readBuf, 0) != checkCorrectRead;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}",
sense, errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readlongretry",
"_debug_" + mediaTest.MediumTypeName + ".bin", "read results",
readBuf);
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
}
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
else mediaTest.MediaIsRecognized = false;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
mediaTests.Add(mediaTest);
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
}
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
report.ATA.RemovableMedias = mediaTests.ToArray();
}
else
{
report.ATA.ReadCapabilities = new testedMediaType();
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.UnformattedBPT != 0)
{
report.ATA.ReadCapabilities.UnformattedBPT = ataId.UnformattedBPT;
report.ATA.ReadCapabilities.UnformattedBPTSpecified = true;
}
if(ataId.UnformattedBPS != 0)
{
report.ATA.ReadCapabilities.UnformattedBPS = ataId.UnformattedBPS;
report.ATA.ReadCapabilities.UnformattedBPSSpecified = true;
}
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.Cylinders > 0 && ataId.Heads > 0 && ataId.SectorsPerTrack > 0)
{
report.ATA.ReadCapabilities.CHS = new chsType
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
Cylinders = ataId.Cylinders,
Heads = ataId.Heads,
Sectors = ataId.SectorsPerTrack
};
report.ATA.ReadCapabilities.Blocks =
(ulong)(ataId.Cylinders * ataId.Heads * ataId.SectorsPerTrack);
report.ATA.ReadCapabilities.BlocksSpecified = true;
}
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.CurrentCylinders > 0 && ataId.CurrentHeads > 0 && ataId.CurrentSectorsPerTrack > 0)
{
report.ATA.ReadCapabilities.CurrentCHS = new chsType
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
Cylinders = ataId.CurrentCylinders,
Heads = ataId.CurrentHeads,
Sectors = ataId.CurrentSectorsPerTrack
};
report.ATA.ReadCapabilities.Blocks =
(ulong)(ataId.CurrentCylinders * ataId.CurrentHeads * ataId.CurrentSectorsPerTrack);
report.ATA.ReadCapabilities.BlocksSpecified = true;
}
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.Capabilities.HasFlag(Identify.CapabilitiesBit.LBASupport))
{
report.ATA.ReadCapabilities.LBASectors = ataId.LBASectors;
report.ATA.ReadCapabilities.LBASectorsSpecified = true;
report.ATA.ReadCapabilities.Blocks = ataId.LBASectors;
report.ATA.ReadCapabilities.BlocksSpecified = true;
}
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.CommandSet2.HasFlag(Identify.CommandSetBit2.LBA48))
{
report.ATA.ReadCapabilities.LBA48Sectors = ataId.LBA48Sectors;
report.ATA.ReadCapabilities.LBA48SectorsSpecified = true;
report.ATA.ReadCapabilities.Blocks = ataId.LBA48Sectors;
report.ATA.ReadCapabilities.BlocksSpecified = true;
}
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.NominalRotationRate != 0x0000 && ataId.NominalRotationRate != 0xFFFF)
if(ataId.NominalRotationRate == 0x0001)
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
report.ATA.ReadCapabilities.SolidStateDevice = true;
report.ATA.ReadCapabilities.SolidStateDeviceSpecified = true;
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
}
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
else
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
report.ATA.ReadCapabilities.SolidStateDevice = false;
report.ATA.ReadCapabilities.SolidStateDeviceSpecified = true;
report.ATA.ReadCapabilities.NominalRotationRate = ataId.NominalRotationRate;
report.ATA.ReadCapabilities.NominalRotationRateSpecified = true;
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
}
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
uint logicalsectorsize;
uint physicalsectorsize;
if((ataId.PhysLogSectorSize & 0x8000) == 0x0000 && (ataId.PhysLogSectorSize & 0x4000) == 0x4000)
{
if((ataId.PhysLogSectorSize & 0x1000) == 0x1000)
if(ataId.LogicalSectorWords <= 255 || ataId.LogicalAlignment == 0xFFFF)
logicalsectorsize = 512;
else logicalsectorsize = ataId.LogicalSectorWords * 2;
else logicalsectorsize = 512;
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if((ataId.PhysLogSectorSize & 0x2000) == 0x2000)
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
physicalsectorsize = logicalsectorsize *
(uint)Math.Pow(2, ataId.PhysLogSectorSize & 0xF);
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
}
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
else physicalsectorsize = logicalsectorsize;
}
else
{
logicalsectorsize = 512;
physicalsectorsize = 512;
}
Check if unformattedbps is set, this may be readlong sector size.
2017-06-04 05:06:49 +01:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
report.ATA.ReadCapabilities.BlockSize = logicalsectorsize;
report.ATA.ReadCapabilities.BlockSizeSpecified = true;
if(physicalsectorsize != logicalsectorsize)
{
report.ATA.ReadCapabilities.PhysicalBlockSize = physicalsectorsize;
report.ATA.ReadCapabilities.PhysicalBlockSizeSpecified = true;
if((ataId.LogicalAlignment & 0x8000) == 0x0000 && (ataId.LogicalAlignment & 0x4000) == 0x4000)
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
report.ATA.ReadCapabilities.LogicalAlignment = (ushort)(ataId.LogicalAlignment & 0x3FFF);
report.ATA.ReadCapabilities.LogicalAlignmentSpecified = true;
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
}
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
}
REFACTOR: Invert 'if' statement to reduce nesting.
2017-12-21 06:06:19 +00:00
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
if(ataId.EccBytes != 0x0000 && ataId.EccBytes != 0xFFFF)
{
report.ATA.ReadCapabilities.LongBlockSize = logicalsectorsize + ataId.EccBytes;
report.ATA.ReadCapabilities.LongBlockSizeSpecified = true;
}
if(ataId.UnformattedBPS > logicalsectorsize &&
(!report.ATA.ReadCapabilities.LongBlockSizeSpecified ||
report.ATA.ReadCapabilities.LongBlockSize == 516))
{
report.ATA.ReadCapabilities.LongBlockSize = ataId.UnformattedBPS;
report.ATA.ReadCapabilities.LongBlockSizeSpecified = true;
}
if(ataId.CommandSet3.HasFlag(Identify.CommandSetBit3.MustBeSet) &&
!ataId.CommandSet3.HasFlag(Identify.CommandSetBit3.MustBeClear) &&
ataId.EnabledCommandSet3.HasFlag(Identify.CommandSetBit3.MediaSerial))
{
report.ATA.ReadCapabilities.CanReadMediaSerial = true;
report.ATA.ReadCapabilities.CanReadMediaSerialSpecified = true;
if(!string.IsNullOrWhiteSpace(ataId.MediaManufacturer))
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
{
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
report.ATA.ReadCapabilities.Manufacturer = ataId.MediaManufacturer;
report.ATA.ReadCapabilities.ManufacturerSpecified = true;
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
}
REFACTOR: Possible 'System.InvalidOperationException'.
2017-12-21 17:10:37 +00:00
}
DOCUMENTATION: Added XML documentation to DiscImageChef.Core.
2017-12-23 01:46:08 +00:00
report.ATA.ReadCapabilities.SupportsReadLbaSpecified = true;
report.ATA.ReadCapabilities.SupportsReadRetryLbaSpecified = true;
report.ATA.ReadCapabilities.SupportsReadDmaLbaSpecified = true;
report.ATA.ReadCapabilities.SupportsReadDmaRetryLbaSpecified = true;
report.ATA.ReadCapabilities.SupportsReadLongLbaSpecified = true;
report.ATA.ReadCapabilities.SupportsReadLongRetryLbaSpecified = true;
report.ATA.ReadCapabilities.SupportsSeekLbaSpecified = true;
report.ATA.ReadCapabilities.SupportsReadLba48Specified = true;
report.ATA.ReadCapabilities.SupportsReadDmaLba48Specified = true;
report.ATA.ReadCapabilities.SupportsReadSpecified = true;
report.ATA.ReadCapabilities.SupportsReadRetrySpecified = true;
report.ATA.ReadCapabilities.SupportsReadDmaSpecified = true;
report.ATA.ReadCapabilities.SupportsReadDmaRetrySpecified = true;
report.ATA.ReadCapabilities.SupportsReadLongSpecified = true;
report.ATA.ReadCapabilities.SupportsReadLongRetrySpecified = true;
report.ATA.ReadCapabilities.SupportsSeekSpecified = true;
ulong checkCorrectRead = BitConverter.ToUInt64(buffer, 0);
bool sense;
DicConsole.WriteLine("Trying READ SECTOR(S) in CHS mode...");
sense = dev.Read(out byte[] readBuf, out AtaErrorRegistersChs errorChs, false, 0, 0, 1, 1, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsRead =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0 && readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readsectorschs", "_debug_" + report.ATA.Model + ".bin",
"read results", readBuf);
DicConsole.WriteLine("Trying READ SECTOR(S) RETRY in CHS mode...");
sense = dev.Read(out readBuf, out errorChs, true, 0, 0, 1, 1, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsReadRetry =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0 && readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readsectorsretrychs", "_debug_" + report.ATA.Model + ".bin",
"read results", readBuf);
DicConsole.WriteLine("Trying READ DMA in CHS mode...");
sense = dev.ReadDma(out readBuf, out errorChs, false, 0, 0, 1, 1, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsReadDma =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0 && readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readdmachs", "_debug_" + report.ATA.Model + ".bin",
"read results", readBuf);
DicConsole.WriteLine("Trying READ DMA RETRY in CHS mode...");
sense = dev.ReadDma(out readBuf, out errorChs, true, 0, 0, 1, 1, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsReadDmaRetry =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0 && readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readdmaretrychs", "_debug_" + report.ATA.Model + ".bin",
"read results", readBuf);
DicConsole.WriteLine("Trying SEEK in CHS mode...");
sense = dev.Seek(out errorChs, 0, 0, 1, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsSeek =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0;
DicConsole.DebugWriteLine("ATA Report", "Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}", sense,
errorChs.Status, errorChs.Error);
DicConsole.WriteLine("Trying READ SECTOR(S) in LBA mode...");
sense = dev.Read(out readBuf, out AtaErrorRegistersLba28 errorLba, false, 0, 1, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsReadLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0 && readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorLba.Status, errorLba.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readsectors", "_debug_" + report.ATA.Model + ".bin",
"read results", readBuf);
DicConsole.WriteLine("Trying READ SECTOR(S) RETRY in LBA mode...");
sense = dev.Read(out readBuf, out errorLba, true, 0, 1, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsReadRetryLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0 && readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorLba.Status, errorLba.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readsectorsretry", "_debug_" + report.ATA.Model + ".bin",
"read results", readBuf);
DicConsole.WriteLine("Trying READ DMA in LBA mode...");
sense = dev.ReadDma(out readBuf, out errorLba, false, 0, 1, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsReadDmaLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0 && readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorLba.Status, errorLba.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readdma", "_debug_" + report.ATA.Model + ".bin", "read results",
readBuf);
DicConsole.WriteLine("Trying READ DMA RETRY in LBA mode...");
sense = dev.ReadDma(out readBuf, out errorLba, true, 0, 1, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsReadDmaRetryLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0 && readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorLba.Status, errorLba.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readdmaretry", "_debug_" + report.ATA.Model + ".bin",
"read results", readBuf);
DicConsole.WriteLine("Trying SEEK in LBA mode...");
sense = dev.Seek(out errorLba, 0, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsSeekLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0;
DicConsole.DebugWriteLine("ATA Report", "Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}", sense,
errorLba.Status, errorLba.Error);
DicConsole.WriteLine("Trying READ SECTOR(S) in LBA48 mode...");
sense = dev.Read(out readBuf, out AtaErrorRegistersLba48 errorLba48, 0, 1, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsReadLba48 =
!sense && (errorLba48.Status & 0x01) != 0x01 && errorLba48.Error == 0 && readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorLba48.Status, errorLba48.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readsectors48", "_debug_" + report.ATA.Model + ".bin",
"read results", readBuf);
DicConsole.WriteLine("Trying READ DMA in LBA48 mode...");
sense = dev.ReadDma(out readBuf, out errorLba48, 0, 1, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsReadDmaLba48 =
!sense && (errorLba48.Status & 0x01) != 0x01 && errorLba48.Error == 0 && readBuf.Length > 0;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorLba48.Status, errorLba48.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readdma48", "_debug_" + report.ATA.Model + ".bin",
"read results", readBuf);
DicConsole.WriteLine("Trying READ LONG in CHS mode...");
sense = dev.ReadLong(out readBuf, out errorChs, false, 0, 0, 1,
report.ATA.ReadCapabilities.LongBlockSize, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsReadLong =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0 && readBuf.Length > 0 &&
BitConverter.ToUInt64(readBuf, 0) != checkCorrectRead;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readlongchs", "_debug_" + report.ATA.Model + ".bin",
"read results", readBuf);
DicConsole.WriteLine("Trying READ LONG RETRY in CHS mode...");
sense = dev.ReadLong(out readBuf, out errorChs, true, 0, 0, 1,
report.ATA.ReadCapabilities.LongBlockSize, TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsReadLongRetry =
!sense && (errorChs.Status & 0x01) != 0x01 && errorChs.Error == 0 && readBuf.Length > 0 &&
BitConverter.ToUInt64(readBuf, 0) != checkCorrectRead;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorChs.Status, errorChs.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readlongretrychs", "_debug_" + report.ATA.Model + ".bin",
"read results", readBuf);
DicConsole.WriteLine("Trying READ LONG in LBA mode...");
sense = dev.ReadLong(out readBuf, out errorLba, false, 0, report.ATA.ReadCapabilities.LongBlockSize,
TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsReadLongLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0 && readBuf.Length > 0 &&
BitConverter.ToUInt64(readBuf, 0) != checkCorrectRead;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorLba.Status, errorLba.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readlong", "_debug_" + report.ATA.Model + ".bin",
"read results", readBuf);
DicConsole.WriteLine("Trying READ LONG RETRY in LBA mode...");
sense = dev.ReadLong(out readBuf, out errorLba, true, 0, report.ATA.ReadCapabilities.LongBlockSize,
TIMEOUT, out _);
report.ATA.ReadCapabilities.SupportsReadLongRetryLba =
!sense && (errorLba.Status & 0x01) != 0x01 && errorLba.Error == 0 && readBuf.Length > 0 &&
BitConverter.ToUInt64(readBuf, 0) != checkCorrectRead;
DicConsole.DebugWriteLine("ATA Report",
"Sense = {0}, Status = 0x{1:X2}, Error = 0x{2:X2}, Length = {3}", sense,
errorLba.Status, errorLba.Error, readBuf.Length);
if(debug)
DataFile.WriteTo("ATA Report", "readlongretry", "_debug_" + report.ATA.Model + ".bin",
"read results", readBuf);
Refactor: Move device-report logic to Core and separate by category.
2017-05-28 21:01:17 +01:00
}
}
}
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
Reference in New Issue Copy Permalink