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
d777061105f781dacf471b4611007485089d6dfb
Aaru/DiscImageChef/Commands/DeviceInfo.cs
Natalia Portillo d777061105 * commandline: 
* DiscImageChef.Settings/Settings.cs:
	* DiscImageChef.Settings/docs/README.txt:
	* DiscImageChef.Settings/packages.config:
	* DiscImageChef.Settings/docs/LICENSE.txt:
	* DiscImageChef.Settings/docs/ChangeLog.txt:
	* DiscImageChef.Settings/docs/mono/index.xml:
	* DiscImageChef.Settings/docs/html/index.html:
	* DiscImageChef.Settings/Properties/AssemblyInfo.cs:
	* DiscImageChef.Settings/DiscImageChef.Settings.csproj:
	* DiscImageChef.Settings/docs/mono/ns-Claunia.PropertyList.xml:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/UID.xml:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/UID.html:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/NSSet.xml:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/index.html:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/NSSet.html:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/NSDate.xml:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/NSData.xml:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/NSDate.html:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/NSData.html:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/NSArray.xml:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/NSNumber.xml:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/NSString.xml:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/NSObject.xml:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/NSArray.html:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/NSNumber.html:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/NSString.html:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/NSObject.html:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/NSDictionary.xml:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/NSDictionary.html:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/PropertyListParser.xml:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/PropertyListParser.html:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/XmlPropertyListParser.xml:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/XmlPropertyListParser.html:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/ASCIIPropertyListParser.xml:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/ASCIIPropertyListParser.html:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/BinaryPropertyListParser.xml:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/BinaryPropertyListWriter.xml:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/BinaryPropertyListWriter.html:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/BinaryPropertyListParser.html:
	* DiscImageChef.Settings/docs/mono/Claunia.PropertyList/PropertyListFormatException.xml:
	* DiscImageChef.Settings/docs/html/Claunia.PropertyList/PropertyListFormatException.html:
	  Added supports for settings

	* DiscImageChef/Commands/Configure.cs:
	  Added support for settings.

	* DiscImageChef/Core/Statistics.cs:
	* DiscImageChef/Commands/Verify.cs:
	* DiscImageChef/Commands/Entropy.cs:
	* DiscImageChef/Commands/Formats.cs:
	* DiscImageChef/Commands/PrintHex.cs:
	* DiscImageChef/Commands/MediaInfo.cs:
	* DiscImageChef/Commands/Statistics.cs:
	  Added statistics.

	* DiscImageChef.Decoders/SCSI/Inquiry.cs:
	  Corrected bug on inquiry decoding.

	* DiscImageChef.Decoders/SCSI/Modes.cs:
	  Corrected bug on decoding mode page 2Ah without write
	  performance descriptors.
	Corrected bug when there is a vendor page 0 in mode sense
	  decoding.

	* DiscImageChef.Devices/Device/Constructor.cs:
	  Corrected detecting USB or FireWire attached CD/DVD/BD and
	  tape drives.
	Try ATA identify on USB or FireWire that don't have SCSI
	  INQUIRY.

	* DiscImageChef.DiscImages/CDRWin.cs:
	  Corrected CD-ROM XA vs CD-ROM detection.

	* DiscImageChef.Partitions/AppleMap.cs:
	  Corrected big endian working.
	Added debug output.

	* DiscImageChef.sln:
	  Added supports for settings.

	* DiscImageChef/Commands/Decode.cs:
	* DiscImageChef/Commands/Analyze.cs:
	* DiscImageChef/Commands/Compare.cs:
	* DiscImageChef/Commands/Checksum.cs:
	* DiscImageChef/Commands/Benchmark.cs:
	* DiscImageChef/Commands/DeviceInfo.cs:
	* DiscImageChef/Commands/CreateSidecar.cs:
	  Added statistics.

	* DiscImageChef/Commands/DeviceReport.cs:
	  Added statistics.
	Correct handling empty inquiry string fields.
	Suppose it is not removable, til proved wrong.
	Corrected MODE SENSE (6/10) detection and calling order.
	If device is MMC type but reports neither mode page 2Ah
	  neither GET CONFIGURATION, try all CDs (old drives work like
	  that).
	Try reading Lead-In and Lead-Out in Audio CD using Audio READ
	  CD commands.
	Corrected READ LONG information handling, some drives return
	  2s-complement in 32 bit. Upper 16 bits are ignored.
	Added support for DVD raw block (37856 bytes).
	Check READ LONG up to 36 times the cooked block size. That
	  should be enough to detect huge blocked media (like DVD and
	  BD) without taking ages.
	If READ LONG size had to be bruteforced, and debug is
	  activated, save the result.

	* DiscImageChef/Commands/DumpMedia.cs:
	  Added statistics.
	Corrected READ LONG information handling, some drives return
	  2s-complement in 32 bit. Upper 16 bits are ignored.
	Start trying with 64 blocks at a time. Some drives report to
	  be able to read 255 at a time, but they really don't, they
	  take a lot longer to read.

	* DiscImageChef/Commands/MediaScan.cs:
	  Added statistics.
	Start trying with 64 blocks at a time. Some drives report to
	  be able to read 255 at a time, but they really don't, they
	  take a lot longer to read.

	* DiscImageChef/DiscImageChef.csproj:
	  Added support for settings.
	Added statistics.

	* DiscImageChef/Main.cs:
	* DiscImageChef/Options.cs:
	  Added support for settings.
	Added statistics.
2016-02-03 18:58:11 +00:00

1036 lines
63 KiB
C#
Raw Blame History

// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : DeviceInfo.cs
// Version : 1.0
// Author(s) : Natalia Portillo
//
// Component : Component
//
// Revision : $Revision$
// Last change by : $Author$
// Date : $Date$
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ 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/>.
//
// ----------------------------------------------------------------------------
// Copyright (C) 2011-2015 Claunia.com
// ****************************************************************************/
// //$Id$
using System;
using DiscImageChef.Devices;
using System.IO;
using DiscImageChef.Console;
using System.Text;
using DiscImageChef.Decoders.ATA;
namespace DiscImageChef.Commands
{
public static class DeviceInfo
{
public static void doDeviceInfo(DeviceInfoSubOptions options)
{
DicConsole.DebugWriteLine("Device-Info command", "--debug={0}", options.Debug);
DicConsole.DebugWriteLine("Device-Info command", "--verbose={0}", options.Verbose);
DicConsole.DebugWriteLine("Device-Info command", "--device={0}", options.DevicePath);
DicConsole.DebugWriteLine("Device-Info command", "--output-prefix={0}", options.OutputPrefix);
if (options.DevicePath.Length == 2 && options.DevicePath[1] == ':' &&
options.DevicePath[0] != '/' && Char.IsLetter(options.DevicePath[0]))
{
options.DevicePath = "\\\\.\\" + Char.ToUpper(options.DevicePath[0]) + ':';
}
Device dev = new Device(options.DevicePath);
if (dev.Error)
{
DicConsole.ErrorWriteLine("Error {0} opening device.", dev.LastError);
return;
}
Core.Statistics.AddDevice(dev);
if (dev.IsUSB)
{
DicConsole.WriteLine("USB device");
if(dev.USBDescriptors != null)
DicConsole.WriteLine("USB descriptor is {0} bytes", dev.USBDescriptors.Length);
DicConsole.WriteLine("USB Vendor ID: {0:X4}", dev.USBVendorID);
DicConsole.WriteLine("USB Product ID: {0:X4}", dev.USBProductID);
DicConsole.WriteLine("USB Manufacturer: {0}", dev.USBManufacturerString);
DicConsole.WriteLine("USB Product: {0}", dev.USBProductString);
DicConsole.WriteLine("USB Serial number: {0}", dev.USBSerialString);
DicConsole.WriteLine();
}
if (dev.IsFireWire)
{
DicConsole.WriteLine("FireWire device");
DicConsole.WriteLine("FireWire Vendor ID: {0:X6}", dev.FireWireVendor);
DicConsole.WriteLine("FireWire Model ID: {0:X6}", dev.FireWireModel);
DicConsole.WriteLine("FireWire Manufacturer: {0}", dev.FireWireVendorName);
DicConsole.WriteLine("FireWire Model: {0}", dev.FireWireModelName);
DicConsole.WriteLine("FireWire GUID: {0:X16}", dev.FireWireGUID);
DicConsole.WriteLine();
}
switch (dev.Type)
{
case DeviceType.ATA:
{
AtaErrorRegistersCHS errorRegisters;
byte[] ataBuf;
bool sense = dev.AtaIdentify(out ataBuf, out errorRegisters);
if (sense)
{
DicConsole.DebugWriteLine("Device-Info command", "STATUS = 0x{0:X2}", errorRegisters.status);
DicConsole.DebugWriteLine("Device-Info command", "ERROR = 0x{0:X2}", errorRegisters.error);
DicConsole.DebugWriteLine("Device-Info command", "NSECTOR = 0x{0:X2}", errorRegisters.sectorCount);
DicConsole.DebugWriteLine("Device-Info command", "SECTOR = 0x{0:X2}", errorRegisters.sector);
DicConsole.DebugWriteLine("Device-Info command", "CYLHIGH = 0x{0:X2}", errorRegisters.cylinderHigh);
DicConsole.DebugWriteLine("Device-Info command", "CYLLOW = 0x{0:X2}", errorRegisters.cylinderLow);
DicConsole.DebugWriteLine("Device-Info command", "DEVICE = 0x{0:X2}", errorRegisters.deviceHead);
DicConsole.DebugWriteLine("Device-Info command", "COMMAND = 0x{0:X2}", errorRegisters.command);
DicConsole.DebugWriteLine("Device-Info command", "Error code = {0}", dev.LastError);
break;
}
doWriteFile(options.OutputPrefix, "_ata_identify.bin", "ATA IDENTIFY", ataBuf);
DicConsole.WriteLine(Decoders.ATA.Identify.Prettify(ataBuf));
break;
}
case DeviceType.ATAPI:
{
AtaErrorRegistersCHS errorRegisters;
byte[] ataBuf;
bool sense = dev.AtapiIdentify(out ataBuf, out errorRegisters);
if (sense)
{
DicConsole.DebugWriteLine("Device-Info command", "STATUS = 0x{0:X2}", errorRegisters.status);
DicConsole.DebugWriteLine("Device-Info command", "ERROR = 0x{0:X2}", errorRegisters.error);
DicConsole.DebugWriteLine("Device-Info command", "NSECTOR = 0x{0:X2}", errorRegisters.sectorCount);
DicConsole.DebugWriteLine("Device-Info command", "SECTOR = 0x{0:X2}", errorRegisters.sector);
DicConsole.DebugWriteLine("Device-Info command", "CYLHIGH = 0x{0:X2}", errorRegisters.cylinderHigh);
DicConsole.DebugWriteLine("Device-Info command", "CYLLOW = 0x{0:X2}", errorRegisters.cylinderLow);
DicConsole.DebugWriteLine("Device-Info command", "DEVICE = 0x{0:X2}", errorRegisters.deviceHead);
DicConsole.DebugWriteLine("Device-Info command", "COMMAND = 0x{0:X2}", errorRegisters.command);
DicConsole.DebugWriteLine("Device-Info command", "Error code = {0}", dev.LastError);
break;
}
doWriteFile(options.OutputPrefix, "_atapi_identify.bin", "ATAPI IDENTIFY", ataBuf);
DicConsole.WriteLine(Decoders.ATA.Identify.Prettify(ataBuf));
// ATAPI devices are also SCSI devices
goto case DeviceType.SCSI;
}
case DeviceType.SCSI:
{
byte[] senseBuf;
byte[] inqBuf;
bool sense = dev.ScsiInquiry(out inqBuf, out senseBuf);
if (sense)
{
DicConsole.ErrorWriteLine("SCSI error:\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
break;
}
if (dev.Type != DeviceType.ATAPI)
DicConsole.WriteLine("SCSI device");
doWriteFile(options.OutputPrefix, "_scsi_inquiry.bin", "SCSI INQUIRY", inqBuf);
Decoders.SCSI.Inquiry.SCSIInquiry? inq = Decoders.SCSI.Inquiry.Decode(inqBuf);
DicConsole.WriteLine(Decoders.SCSI.Inquiry.Prettify(inq));
bool scsi80 = false;
string scsiSerial = null;
StringBuilder sb = null;
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, 0x00);
if (!sense)
{
byte[] pages = Decoders.SCSI.EVPD.DecodePage00(inqBuf);
if (pages != null)
{
foreach (byte page in pages)
{
if (page >= 0x01 && page <= 0x7F)
{
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
if (!sense)
{
if (sb == null)
sb = new StringBuilder();
sb.AppendFormat("Page 0x{0:X2}: ", Decoders.SCSI.EVPD.DecodeASCIIPage(inqBuf)).AppendLine();
doWriteFile(options.OutputPrefix, String.Format("_scsi_evpd_{0:X2}h.bin", page), String.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
}
}
else if (page == 0x80)
{
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
if (!sense)
{
scsi80 = true;
scsiSerial = Decoders.SCSI.EVPD.DecodePage80(inqBuf);
doWriteFile(options.OutputPrefix, String.Format("_scsi_evpd_{0:X2}h.bin", page), String.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
}
}
else
{
if (page != 0x00)
{
DicConsole.DebugWriteLine("Device-Info command", "Found undecoded SCSI VPD page 0x{0:X2}", page);
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
if (!sense)
{
doWriteFile(options.OutputPrefix, String.Format("_scsi_evpd_{0:X2}h.bin", page), String.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
}
}
}
}
}
}
if (scsi80)
DicConsole.WriteLine("Unit Serial Number: {0}", scsiSerial);
if (sb != null)
{
DicConsole.WriteLine("ASCII VPDs:");
DicConsole.WriteLine(sb.ToString());
}
byte[] modeBuf;
double duration;
Decoders.SCSI.Modes.DecodedMode? decMode = null;
Decoders.SCSI.PeripheralDeviceTypes devType = (DiscImageChef.Decoders.SCSI.PeripheralDeviceTypes)inq.Value.PeripheralDeviceType;
sense = dev.ModeSense10(out modeBuf, out senseBuf, false, true, ScsiModeSensePageControl.Current, 0x3F, 0xFF, 5, out duration);
if (sense || dev.Error)
{
sense = dev.ModeSense10(out modeBuf, out senseBuf, false, true, ScsiModeSensePageControl.Current, 0x3F, 0x00, 5, out duration);
}
if (!sense && !dev.Error)
{
decMode = Decoders.SCSI.Modes.DecodeMode10(modeBuf, devType);
}
if(sense || dev.Error || !decMode.HasValue)
{
sense = dev.ModeSense6(out modeBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F, 0xFF, 5, out duration);
if (sense || dev.Error)
sense = dev.ModeSense6(out modeBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F, 0x00, 5, out duration);
if (sense || dev.Error)
sense = dev.ModeSense(out modeBuf, out senseBuf, 5, out duration);
if (!sense && !dev.Error)
decMode = Decoders.SCSI.Modes.DecodeMode6(modeBuf, devType);
}
if (!sense)
doWriteFile(options.OutputPrefix, "_scsi_modesense.bin", "SCSI MODE SENSE", modeBuf);
if (decMode.HasValue)
{
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModeHeader(decMode.Value.Header, devType));
if (decMode.Value.Pages != null)
{
foreach (Decoders.SCSI.Modes.ModePage page in decMode.Value.Pages)
{
//DicConsole.WriteLine("Page {0:X2}h subpage {1:X2}h is {2} bytes long", page.Page, page.Subpage, page.PageResponse.Length);
switch (page.Page)
{
case 0x00:
{
if (devType == DiscImageChef.Decoders.SCSI.PeripheralDeviceTypes.MultiMediaDevice && page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_00_SFF(page.PageResponse));
else
{
if (page.Subpage != 0)
DicConsole.WriteLine("Found unknown vendor mode page {0:X2}h subpage {1:X2}h", page.Page, page.Subpage);
else
DicConsole.WriteLine("Found unknown vendor mode page {0:X2}h", page.Page);
}
break;
}
case 0x01:
{
if (page.Subpage == 0)
{
if (devType == DiscImageChef.Decoders.SCSI.PeripheralDeviceTypes.MultiMediaDevice)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_01_MMC(page.PageResponse));
else
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_01(page.PageResponse));
}
else
goto default;
break;
}
case 0x02:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_02(page.PageResponse));
else
goto default;
break;
}
case 0x03:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_03(page.PageResponse));
else
goto default;
break;
}
case 0x04:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_04(page.PageResponse));
else
goto default;
break;
}
case 0x05:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_05(page.PageResponse));
else
goto default;
break;
}
case 0x06:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_06(page.PageResponse));
else
goto default;
break;
}
case 0x07:
{
if (page.Subpage == 0)
{
if (devType == DiscImageChef.Decoders.SCSI.PeripheralDeviceTypes.MultiMediaDevice)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_07_MMC(page.PageResponse));
else
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_07(page.PageResponse));
}
else
goto default;
break;
}
case 0x08:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_08(page.PageResponse));
else
goto default;
break;
}
case 0x0A:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_0A(page.PageResponse));
else if (page.Subpage == 1)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_0A_S01(page.PageResponse));
else
goto default;
break;
}
case 0x0B:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_0B(page.PageResponse));
else
goto default;
break;
}
case 0x0D:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_0D(page.PageResponse));
else
goto default;
break;
}
case 0x0E:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_0E(page.PageResponse));
else
goto default;
break;
}
case 0x0F:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_0F(page.PageResponse));
else
goto default;
break;
}
case 0x10:
{
if (page.Subpage == 0)
{
if (devType == DiscImageChef.Decoders.SCSI.PeripheralDeviceTypes.SequentialAccess)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_10_SSC(page.PageResponse));
else
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_10(page.PageResponse));
}
else
goto default;
break;
}
case 0x1A:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_1A(page.PageResponse));
else if (page.Subpage == 1)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_1A_S01(page.PageResponse));
else
goto default;
break;
}
case 0x1B:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_1B(page.PageResponse));
else
goto default;
break;
}
case 0x1C:
{
if (page.Subpage == 0)
{
if (devType == DiscImageChef.Decoders.SCSI.PeripheralDeviceTypes.MultiMediaDevice)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_1C_SFF(page.PageResponse));
else
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_1C(page.PageResponse));
}
else if (page.Subpage == 1)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_1C_S01(page.PageResponse));
else
goto default;
break;
}
case 0x2A:
{
if (page.Subpage == 0)
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModePage_2A(page.PageResponse));
else
goto default;
break;
}
case 0x3E:
{
if (StringHandlers.CToString(inq.Value.VendorIdentification).Trim() == "FUJITSU")
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyFujitsuModePage_3E(page.PageResponse));
else
goto default;
break;
}
default:
{
if (page.Subpage != 0)
DicConsole.WriteLine("Found unknown mode page {0:X2}h subpage {1:X2}h", page.Page, page.Subpage);
else
DicConsole.WriteLine("Found unknown mode page {0:X2}h", page.Page);
break;
}
}
}
}
}
if (devType == DiscImageChef.Decoders.SCSI.PeripheralDeviceTypes.MultiMediaDevice)
{
byte[] confBuf;
sense = dev.GetConfiguration(out confBuf, out senseBuf, dev.Timeout, out duration);
if (!sense)
{
doWriteFile(options.OutputPrefix, "_mmc_getconfiguration.bin", "MMC GET CONFIGURATION", confBuf);
Decoders.SCSI.MMC.Features.SeparatedFeatures ftr = Decoders.SCSI.MMC.Features.Separate(confBuf);
DicConsole.DebugWriteLine("Device-Info command", "GET CONFIGURATION length is {0} bytes", ftr.DataLength);
DicConsole.DebugWriteLine("Device-Info command", "GET CONFIGURATION current profile is {0:X4}h", ftr.CurrentProfile);
if (ftr.Descriptors != null)
{
DicConsole.WriteLine("SCSI MMC GET CONFIGURATION Features:");
foreach (Decoders.SCSI.MMC.Features.FeatureDescriptor desc in ftr.Descriptors)
{
DicConsole.DebugWriteLine("Device-Info command", "Feature {0:X4}h", desc.Code);
switch (desc.Code)
{
case 0x0000:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0000(desc.Data));
break;
case 0x0001:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0001(desc.Data));
break;
case 0x0002:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0002(desc.Data));
break;
case 0x0003:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0003(desc.Data));
break;
case 0x0004:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0004(desc.Data));
break;
case 0x0010:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0010(desc.Data));
break;
case 0x001D:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_001D(desc.Data));
break;
case 0x001E:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_001E(desc.Data));
break;
case 0x001F:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_001F(desc.Data));
break;
case 0x0020:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0020(desc.Data));
break;
case 0x0021:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0021(desc.Data));
break;
case 0x0022:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0022(desc.Data));
break;
case 0x0023:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0023(desc.Data));
break;
case 0x0024:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0024(desc.Data));
break;
case 0x0025:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0025(desc.Data));
break;
case 0x0026:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0026(desc.Data));
break;
case 0x0027:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0027(desc.Data));
break;
case 0x0028:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0028(desc.Data));
break;
case 0x0029:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0029(desc.Data));
break;
case 0x002A:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_002A(desc.Data));
break;
case 0x002B:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_002B(desc.Data));
break;
case 0x002C:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_002C(desc.Data));
break;
case 0x002D:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_002D(desc.Data));
break;
case 0x002E:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_002E(desc.Data));
break;
case 0x002F:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_002F(desc.Data));
break;
case 0x0030:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0030(desc.Data));
break;
case 0x0031:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0031(desc.Data));
break;
case 0x0032:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0032(desc.Data));
break;
case 0x0033:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0033(desc.Data));
break;
case 0x0035:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0035(desc.Data));
break;
case 0x0037:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0037(desc.Data));
break;
case 0x0038:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0038(desc.Data));
break;
case 0x003A:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_003A(desc.Data));
break;
case 0x003B:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_003B(desc.Data));
break;
case 0x0040:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0040(desc.Data));
break;
case 0x0041:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0041(desc.Data));
break;
case 0x0042:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0042(desc.Data));
break;
case 0x0050:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0050(desc.Data));
break;
case 0x0051:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0051(desc.Data));
break;
case 0x0080:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0080(desc.Data));
break;
case 0x0100:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0100(desc.Data));
break;
case 0x0101:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0101(desc.Data));
break;
case 0x0102:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0102(desc.Data));
break;
case 0x0103:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0103(desc.Data));
break;
case 0x0104:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0104(desc.Data));
break;
case 0x0105:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0105(desc.Data));
break;
case 0x0106:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0106(desc.Data));
break;
case 0x0107:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0107(desc.Data));
break;
case 0x0108:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0108(desc.Data));
break;
case 0x0109:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0109(desc.Data));
break;
case 0x010A:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_010A(desc.Data));
break;
case 0x010B:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_010B(desc.Data));
break;
case 0x010C:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_010C(desc.Data));
break;
case 0x010D:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_010D(desc.Data));
break;
case 0x010E:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_010E(desc.Data));
break;
case 0x0110:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0110(desc.Data));
break;
case 0x0113:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0113(desc.Data));
break;
case 0x0142:
DicConsole.WriteLine(Decoders.SCSI.MMC.Features.Prettify_0142(desc.Data));
break;
default:
DicConsole.WriteLine("Found unknown feature code {0:X4}h", desc.Code);
break;
}
}
}
else
DicConsole.DebugWriteLine("Device-Info command", "GET CONFIGURATION returned no feature descriptors");
}
// TODO: DVD drives respond correctly to BD status.
// While specification says if no medium is present
// it should inform all possible capabilities,
// testing drives show only supported media capabilities.
/*
byte[] strBuf;
sense = dev.ReadDiscStructure(out strBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.CapabilityList, 0, dev.Timeout, out duration);
if (!sense)
{
Decoders.SCSI.DiscStructureCapabilities.Capability[] caps = Decoders.SCSI.DiscStructureCapabilities.Decode(strBuf);
if (caps != null)
{
foreach (Decoders.SCSI.DiscStructureCapabilities.Capability cap in caps)
{
if (cap.SDS && cap.RDS)
DicConsole.WriteLine("Drive can READ/SEND DISC STRUCTURE format {0:X2}h", cap.FormatCode);
else if (cap.SDS)
DicConsole.WriteLine("Drive can SEND DISC STRUCTURE format {0:X2}h", cap.FormatCode);
else if (cap.RDS)
DicConsole.WriteLine("Drive can READ DISC STRUCTURE format {0:X2}h", cap.FormatCode);
}
}
}
sense = dev.ReadDiscStructure(out strBuf, out senseBuf, MmcDiscStructureMediaType.BD, 0, 0, MmcDiscStructureFormat.CapabilityList, 0, dev.Timeout, out duration);
if (!sense)
{
Decoders.SCSI.DiscStructureCapabilities.Capability[] caps = Decoders.SCSI.DiscStructureCapabilities.Decode(strBuf);
if (caps != null)
{
foreach (Decoders.SCSI.DiscStructureCapabilities.Capability cap in caps)
{
if (cap.SDS && cap.RDS)
DicConsole.WriteLine("Drive can READ/SEND DISC STRUCTURE format {0:X2}h", cap.FormatCode);
else if (cap.SDS)
DicConsole.WriteLine("Drive can SEND DISC STRUCTURE format {0:X2}h", cap.FormatCode);
else if (cap.RDS)
DicConsole.WriteLine("Drive can READ DISC STRUCTURE format {0:X2}h", cap.FormatCode);
}
}
}
*/
#region Plextor
if (dev.Manufacturer == "PLEXTOR")
{
bool plxtSense = true;
bool plxtDvd = false;
byte[] plxtBuf = null;
switch (dev.Model)
{
case "DVDR PX-708A":
case "DVDR PX-708A2":
case "DVDR PX-712A":
plxtDvd = true;
plxtSense = dev.PlextorReadEeprom(out plxtBuf, out senseBuf, dev.Timeout, out duration);
break;
case "DVDR PX-714A":
case "DVDR PX-716A":
case "DVDR PX-716AL":
case "DVDR PX-755A":
case "DVDR PX-760A":
{
byte[] plxtBufSmall;
plxtBuf = new byte[256 * 4];
for (byte i = 0; i < 4; i++)
{
plxtSense = dev.PlextorReadEepromBlock(out plxtBufSmall, out senseBuf, i, 256, dev.Timeout, out duration);
if (plxtSense)
break;
Array.Copy(plxtBufSmall, 0, plxtBuf, i * 256, 256);
}
plxtDvd = true;
break;
}
default:
{
if (dev.Model.StartsWith("CD-R "))
{
plxtSense = dev.PlextorReadEepromCDR(out plxtBuf, out senseBuf, dev.Timeout, out duration);
}
break;
}
}
if (!plxtSense)
{
doWriteFile(options.OutputPrefix, "_plextor_eeprom.bin", "PLEXTOR READ EEPROM", plxtBuf);
ushort discs;
uint cdReadTime, cdWriteTime, dvdReadTime = 0, dvdWriteTime = 0;
BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;
if (plxtDvd)
{
discs = BigEndianBitConverter.ToUInt16(plxtBuf, 0x0120);
cdReadTime = BigEndianBitConverter.ToUInt32(plxtBuf, 0x0122);
cdWriteTime = BigEndianBitConverter.ToUInt32(plxtBuf, 0x0126);
dvdReadTime = BigEndianBitConverter.ToUInt32(plxtBuf, 0x012A);
dvdWriteTime = BigEndianBitConverter.ToUInt32(plxtBuf, 0x012E);
}
else
{
discs = BigEndianBitConverter.ToUInt16(plxtBuf, 0x0078);
cdReadTime = BigEndianBitConverter.ToUInt32(plxtBuf, 0x006C);
cdWriteTime = BigEndianBitConverter.ToUInt32(plxtBuf, 0x007A);
}
DicConsole.WriteLine("Drive has loaded a total of {0} discs", discs);
DicConsole.WriteLine("Drive has spent {0} hours, {1} minutes and {2} seconds reading CDs",
cdReadTime / 3600, (cdReadTime / 60) % 60, cdReadTime % 60);
DicConsole.WriteLine("Drive has spent {0} hours, {1} minutes and {2} seconds writing CDs",
cdWriteTime / 3600, (cdWriteTime / 60) % 60, cdWriteTime % 60);
if (plxtDvd)
{
DicConsole.WriteLine("Drive has spent {0} hours, {1} minutes and {2} seconds reading DVDs",
dvdReadTime / 3600, (dvdReadTime / 60) % 60, dvdReadTime % 60);
DicConsole.WriteLine("Drive has spent {0} hours, {1} minutes and {2} seconds writing DVDs",
dvdWriteTime / 3600, (dvdWriteTime / 60) % 60, dvdWriteTime % 60);
}
}
bool plxtPwrRecEnabled;
ushort plxtPwrRecSpeed;
plxtSense = dev.PlextorGetPoweRec(out senseBuf, out plxtPwrRecEnabled, out plxtPwrRecSpeed, dev.Timeout, out duration);
if (!plxtSense)
{
DicConsole.Write("Drive supports PoweRec");
if (plxtPwrRecEnabled)
{
DicConsole.Write(", has it enabled");
if (plxtPwrRecSpeed > 0)
DicConsole.WriteLine(" and recommends {0} Kb/sec.", plxtPwrRecSpeed);
else
DicConsole.WriteLine(".");
ushort plxtPwrRecSelected, plxtPwrRecMax, plxtPwrRecLast;
plxtSense = dev.PlextorGetSpeeds(out senseBuf, out plxtPwrRecSelected, out plxtPwrRecMax, out plxtPwrRecLast, dev.Timeout, out duration);
if (!plxtSense)
{
if (plxtPwrRecSelected > 0)
DicConsole.WriteLine("Selected PoweRec speed for currently inserted media is {0} Kb/sec ({1}x)", plxtPwrRecSelected, plxtPwrRecSelected / 177);
if (plxtPwrRecMax > 0)
DicConsole.WriteLine("Maximum PoweRec speed for currently inserted media is {0} Kb/sec ({1}x)", plxtPwrRecMax, plxtPwrRecMax / 177);
if (plxtPwrRecLast > 0)
DicConsole.WriteLine("Last used PoweRec was {0} Kb/sec ({1}x)", plxtPwrRecLast, plxtPwrRecLast / 177);
}
}
else
DicConsole.WriteLine("PoweRec is disabled");
}
// TODO: Check it with a drive
plxtSense = dev.PlextorGetSilentMode(out plxtBuf, out senseBuf, dev.Timeout, out duration);
if (!plxtSense)
{
DicConsole.WriteLine("Drive supports Plextor SilentMode");
if (plxtBuf[0] == 1)
{
DicConsole.WriteLine("Plextor SilentMode is enabled:");
if (plxtBuf[1] == 2)
DicConsole.WriteLine("\tAccess time is slow");
else
DicConsole.WriteLine("\tAccess time is fast");
if (plxtBuf[2] > 0)
DicConsole.WriteLine("\tCD read speed limited to {0}x", plxtBuf[2]);
if (plxtBuf[3] > 0 && plxtDvd)
DicConsole.WriteLine("\tDVD read speed limited to {0}x", plxtBuf[3]);
if (plxtBuf[4] > 0)
DicConsole.WriteLine("\tCD write speed limited to {0}x", plxtBuf[4]);
if (plxtBuf[6] > 0)
DicConsole.WriteLine("\tTray eject speed limited to {0}", -(plxtBuf[6] + 48));
if (plxtBuf[7] > 0)
DicConsole.WriteLine("\tTray eject speed limited to {0}", plxtBuf[7] - 47);
}
}
plxtSense = dev.PlextorGetGigaRec(out plxtBuf, out senseBuf, dev.Timeout, out duration);
if (!plxtSense)
{
DicConsole.WriteLine("Drive supports Plextor GigaRec");
// TODO: Pretty print it
}
plxtSense = dev.PlextorGetSecuRec(out plxtBuf, out senseBuf, dev.Timeout, out duration);
if (!plxtSense)
{
DicConsole.WriteLine("Drive supports Plextor SecuRec");
// TODO: Pretty print it
}
plxtSense = dev.PlextorGetSpeedRead(out plxtBuf, out senseBuf, dev.Timeout, out duration);
if (!plxtSense)
{
DicConsole.Write("Drive supports Plextor SpeedRead");
if ((plxtBuf[2] & 0x01) == 0x01)
DicConsole.WriteLine("and has it enabled");
else
DicConsole.WriteLine();
}
plxtSense = dev.PlextorGetHiding(out plxtBuf, out senseBuf, dev.Timeout, out duration);
if (!plxtSense)
{
DicConsole.WriteLine("Drive supports hiding CD-Rs and forcing single session");
if ((plxtBuf[2] & 0x02) == 0x02)
DicConsole.WriteLine("Drive currently hides CD-Rs");
if ((plxtBuf[2] & 0x01) == 0x01)
DicConsole.WriteLine("Drive currently forces single session");
}
plxtSense = dev.PlextorGetVariRec(out plxtBuf, out senseBuf, false, dev.Timeout, out duration);
if (!plxtSense)
{
DicConsole.WriteLine("Drive supports Plextor VariRec");
// TODO: Pretty print it
}
if (plxtDvd)
{
plxtSense = dev.PlextorGetVariRec(out plxtBuf, out senseBuf, true, dev.Timeout, out duration);
if (!plxtSense)
{
DicConsole.WriteLine("Drive supports Plextor VariRec for DVDs");
// TODO: Pretty print it
}
plxtSense = dev.PlextorGetBitsetting(out plxtBuf, out senseBuf, false, dev.Timeout, out duration);
if (!plxtSense)
DicConsole.WriteLine("Drive supports bitsetting DVD+R book type");
plxtSense = dev.PlextorGetBitsetting(out plxtBuf, out senseBuf, true, dev.Timeout, out duration);
if (!plxtSense)
DicConsole.WriteLine("Drive supports bitsetting DVD+R DL book type");
plxtSense = dev.PlextorGetTestWriteDvdPlus(out plxtBuf, out senseBuf, dev.Timeout, out duration);
if (!plxtSense)
DicConsole.WriteLine("Drive supports test writing DVD+");
}
}
#endregion Plextor
}
if (devType == DiscImageChef.Decoders.SCSI.PeripheralDeviceTypes.SequentialAccess)
{
byte[] seqBuf;
sense = dev.ReadBlockLimits(out seqBuf, out senseBuf, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ BLOCK LIMITS:\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
else
{
doWriteFile(options.OutputPrefix, "_ssc_readblocklimits.bin", "SSC READ BLOCK LIMITS", seqBuf);
DicConsole.WriteLine("Block limits for device:");
DicConsole.WriteLine(Decoders.SCSI.SSC.BlockLimits.Prettify(seqBuf));
}
sense = dev.ReportDensitySupport(out seqBuf, out senseBuf, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("REPORT DENSITY SUPPORT:\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
else
{
doWriteFile(options.OutputPrefix, "_ssc_reportdensitysupport.bin", "SSC REPORT DENSITY SUPPORT", seqBuf);
Decoders.SCSI.SSC.DensitySupport.DensitySupportHeader? dens = Decoders.SCSI.SSC.DensitySupport.DecodeDensity(seqBuf);
if (dens.HasValue)
{
DicConsole.WriteLine("Densities supported by device:");
DicConsole.WriteLine(Decoders.SCSI.SSC.DensitySupport.PrettifyDensity(dens));
}
}
sense = dev.ReportDensitySupport(out seqBuf, out senseBuf, true, false, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("REPORT DENSITY SUPPORT (MEDIUM):\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
else
{
doWriteFile(options.OutputPrefix, "_ssc_reportdensitysupport_medium.bin", "SSC REPORT DENSITY SUPPORT (MEDIUM)", seqBuf);
Decoders.SCSI.SSC.DensitySupport.MediaTypeSupportHeader? meds = Decoders.SCSI.SSC.DensitySupport.DecodeMediumType(seqBuf);
if (meds.HasValue)
{
DicConsole.WriteLine("Medium types supported by device:");
DicConsole.WriteLine(Decoders.SCSI.SSC.DensitySupport.PrettifyMediumType(meds));
}
DicConsole.WriteLine(Decoders.SCSI.SSC.DensitySupport.PrettifyMediumType(seqBuf));
}
}
break;
}
default:
DicConsole.ErrorWriteLine("Unknown device type {0}, cannot get information.", dev.Type);
break;
}
Core.Statistics.AddCommand("device-info");
}
static void doWriteFile(string outputPrefix, string outputSuffix, string whatWriting, byte[] data)
{
if(!string.IsNullOrEmpty(outputPrefix))
{
if (!File.Exists(outputPrefix + outputSuffix))
{
try
{
DicConsole.DebugWriteLine("Device-Info command", "Writing " + whatWriting + " to {0}{1}", outputPrefix, outputSuffix);
FileStream outputFs = new FileStream(outputPrefix + outputSuffix, FileMode.CreateNew);
outputFs.Write(data, 0, data.Length);
outputFs.Close();
}
catch
{
DicConsole.ErrorWriteLine("Unable to write file {0}{1}", outputPrefix, outputSuffix);
}
}
else
DicConsole.ErrorWriteLine("Not overwriting file {0}{1}", outputPrefix, outputSuffix);
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink