2017-05-19 20:28:49 +01:00
|
|
|
// /***************************************************************************
|
2015-10-13 01:45:07 +01:00
|
|
|
// The Disc Image Chef
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
|
//
|
|
|
|
|
// Filename : DeviceInfo.cs
|
2016-07-28 18:13:49 +01:00
|
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
2015-10-13 01:45:07 +01:00
|
|
|
//
|
2016-07-28 18:13:49 +01:00
|
|
|
// Component : Verbs.
|
2015-10-13 01:45:07 +01:00
|
|
|
//
|
|
|
|
|
// --[ Description ] ----------------------------------------------------------
|
|
|
|
|
//
|
2016-07-28 18:13:49 +01:00
|
|
|
// Implements the 'device-info' verb.
|
2015-10-13 01:45:07 +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/>.
|
|
|
|
|
//
|
|
|
|
|
// ----------------------------------------------------------------------------
|
2017-12-19 03:50:57 +00:00
|
|
|
// Copyright © 2011-2018 Natalia Portillo
|
2015-10-13 01:45:07 +01:00
|
|
|
// ****************************************************************************/
|
2016-07-28 18:13:49 +01:00
|
|
|
|
2015-10-13 01:45:07 +01:00
|
|
|
using System;
|
2015-10-18 22:04:03 +01:00
|
|
|
using DiscImageChef.Console;
|
2017-05-27 20:02:57 +01:00
|
|
|
using DiscImageChef.Core;
|
2017-12-19 19:33:46 +00:00
|
|
|
using DiscImageChef.Decoders.ATA;
|
|
|
|
|
using DiscImageChef.Devices;
|
2015-10-13 01:45:07 +01:00
|
|
|
|
|
|
|
|
namespace DiscImageChef.Commands
|
|
|
|
|
{
|
2017-12-20 02:08:37 +00:00
|
|
|
static class DeviceInfo
|
2015-10-13 01:45:07 +01:00
|
|
|
{
|
2017-12-20 17:15:26 +00:00
|
|
|
internal static void DoDeviceInfo(DeviceInfoOptions options)
|
2015-10-13 01:45:07 +01:00
|
|
|
{
|
2015-10-18 22:04:03 +01:00
|
|
|
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);
|
2015-11-02 21:08:38 +00:00
|
|
|
DicConsole.DebugWriteLine("Device-Info command", "--output-prefix={0}", options.OutputPrefix);
|
2015-10-13 01:45:07 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
if(options.DevicePath.Length == 2 && options.DevicePath[1] == ':' && options.DevicePath[0] != '/' &&
|
2017-12-20 23:07:46 +00:00
|
|
|
char.IsLetter(options.DevicePath[0])) options.DevicePath = "\\\\.\\" + char.ToUpper(options.DevicePath[0]) + ':';
|
2015-10-13 01:45:07 +01:00
|
|
|
|
|
|
|
|
Device dev = new Device(options.DevicePath);
|
|
|
|
|
|
2016-04-19 02:11:47 +01:00
|
|
|
if(dev.Error)
|
2015-10-13 01:45:07 +01:00
|
|
|
{
|
2015-10-18 22:04:03 +01:00
|
|
|
DicConsole.ErrorWriteLine("Error {0} opening device.", dev.LastError);
|
2015-10-13 01:45:07 +01:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
* 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
|
|
|
Core.Statistics.AddDevice(dev);
|
|
|
|
|
|
2017-12-20 17:15:26 +00:00
|
|
|
if(dev.IsUsb)
|
2015-12-31 16:12:22 +00:00
|
|
|
{
|
|
|
|
|
DicConsole.WriteLine("USB device");
|
2017-12-20 17:15:26 +00:00
|
|
|
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);
|
2015-12-31 16:33:20 +00:00
|
|
|
DicConsole.WriteLine();
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-19 02:11:47 +01:00
|
|
|
if(dev.IsFireWire)
|
2015-12-31 16:33:20 +00:00
|
|
|
{
|
|
|
|
|
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);
|
2017-12-20 17:15:26 +00:00
|
|
|
DicConsole.WriteLine("FireWire GUID: {0:X16}", dev.FireWireGuid);
|
2015-12-31 16:12:22 +00:00
|
|
|
DicConsole.WriteLine();
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-20 17:15:26 +00:00
|
|
|
if(dev.IsPcmcia)
|
2016-10-17 04:41:27 +01:00
|
|
|
{
|
|
|
|
|
DicConsole.WriteLine("PCMCIA device");
|
2017-12-20 17:15:26 +00:00
|
|
|
DicConsole.WriteLine("PCMCIA CIS is {0} bytes", dev.Cis.Length);
|
|
|
|
|
Decoders.PCMCIA.Tuple[] tuples = Decoders.PCMCIA.CIS.GetTuples(dev.Cis);
|
2016-10-17 04:41:27 +01:00
|
|
|
if(tuples != null)
|
|
|
|
|
foreach(Decoders.PCMCIA.Tuple tuple in tuples)
|
|
|
|
|
switch(tuple.Code)
|
|
|
|
|
{
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_NULL:
|
2017-12-19 20:33:03 +00:00
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_END: break;
|
2016-10-17 04:41:27 +01:00
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_DEVICEGEO:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_DEVICEGEO_A:
|
|
|
|
|
DicConsole.WriteLine("{0}", Decoders.PCMCIA.CIS.PrettifyDeviceGeometryTuple(tuple));
|
|
|
|
|
break;
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_MANFID:
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}",
|
|
|
|
|
Decoders.PCMCIA.CIS
|
|
|
|
|
.PrettifyManufacturerIdentificationTuple(tuple));
|
2016-10-17 04:41:27 +01:00
|
|
|
break;
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_VERS_1:
|
|
|
|
|
DicConsole.WriteLine("{0}", Decoders.PCMCIA.CIS.PrettifyLevel1VersionTuple(tuple));
|
|
|
|
|
break;
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_ALTSTR:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_BAR:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_BATTERY:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_BYTEORDER:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_CFTABLE_ENTRY:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_CFTABLE_ENTRY_CB:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_CHECKSUM:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_CONFIG:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_CONFIG_CB:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_DATE:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_DEVICE:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_DEVICE_A:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_DEVICE_OA:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_DEVICE_OC:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_EXTDEVIC:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_FORMAT:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_FORMAT_A:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_FUNCE:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_FUNCID:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_GEOMETRY:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_INDIRECT:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_JEDEC_A:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_JEDEC_C:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_LINKTARGET:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_LONGLINK_A:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_LONGLINK_C:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_LONGLINK_CB:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_LONGLINK_MFC:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_NO_LINK:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_ORG:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_PWR_MGMNT:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_SPCL:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_SWIL:
|
|
|
|
|
case Decoders.PCMCIA.TupleCodes.CISTPL_VERS_2:
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.DebugWriteLine("Device-Info command", "Found undecoded tuple ID {0}",
|
|
|
|
|
tuple.Code);
|
2016-10-17 04:41:27 +01:00
|
|
|
break;
|
|
|
|
|
default:
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.DebugWriteLine("Device-Info command", "Found unknown tuple ID 0x{0:X2}",
|
|
|
|
|
(byte)tuple.Code);
|
2016-10-17 04:41:27 +01:00
|
|
|
break;
|
|
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
else DicConsole.DebugWriteLine("Device-Info command", "Could not get tuples");
|
2016-10-17 04:41:27 +01:00
|
|
|
}
|
|
|
|
|
|
2016-04-19 02:11:47 +01:00
|
|
|
switch(dev.Type)
|
2015-10-19 05:11:28 +01:00
|
|
|
{
|
|
|
|
|
case DeviceType.ATA:
|
2017-12-19 20:33:03 +00:00
|
|
|
{
|
|
|
|
|
AtaErrorRegistersCHS errorRegisters;
|
2015-10-13 01:45:07 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
byte[] ataBuf;
|
|
|
|
|
bool sense = dev.AtaIdentify(out ataBuf, out errorRegisters);
|
2015-10-13 01:45:07 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
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;
|
|
|
|
|
}
|
2015-10-15 01:46:31 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_ata_identify.bin", "ATA IDENTIFY",
|
|
|
|
|
ataBuf);
|
2015-11-02 21:08:38 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine(Identify.Prettify(ataBuf));
|
2016-02-10 03:00:39 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
double duration;
|
|
|
|
|
dev.EnableMediaCardPassThrough(out errorRegisters, dev.Timeout, out duration);
|
2016-02-10 03:00:39 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
if(errorRegisters.sector == 0xAA && errorRegisters.sectorCount == 0x55)
|
|
|
|
|
{
|
|
|
|
|
DicConsole.WriteLine("Device supports the Media Card Pass Through Command Set");
|
|
|
|
|
switch(errorRegisters.deviceHead & 0x7)
|
2016-02-10 03:00:39 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
case 0:
|
|
|
|
|
DicConsole.WriteLine("Device reports incorrect media card type");
|
|
|
|
|
break;
|
|
|
|
|
case 1:
|
|
|
|
|
DicConsole.WriteLine("Device contains a Secure Digital card");
|
|
|
|
|
break;
|
|
|
|
|
case 2:
|
|
|
|
|
DicConsole.WriteLine("Device contains a MultiMediaCard ");
|
|
|
|
|
break;
|
|
|
|
|
case 3:
|
|
|
|
|
DicConsole.WriteLine("Device contains a Secure Digital I/O card");
|
|
|
|
|
break;
|
|
|
|
|
case 4:
|
|
|
|
|
DicConsole.WriteLine("Device contains a Smart Media card");
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
DicConsole.WriteLine("Device contains unknown media card type {0}",
|
|
|
|
|
errorRegisters.deviceHead & 0x07);
|
|
|
|
|
break;
|
2016-02-10 03:00:39 +00:00
|
|
|
}
|
|
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
if((errorRegisters.deviceHead & 0x08) == 0x08)
|
|
|
|
|
DicConsole.WriteLine("Media card is write protected");
|
|
|
|
|
|
|
|
|
|
ushort specificData =
|
2017-12-20 17:26:28 +00:00
|
|
|
(ushort)(errorRegisters.cylinderHigh * 0x100 + errorRegisters.cylinderLow);
|
2017-12-19 20:33:03 +00:00
|
|
|
if(specificData != 0) DicConsole.WriteLine("Card specific data: 0x{0:X4}", specificData);
|
2015-10-19 05:11:28 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
2015-10-19 05:11:28 +01:00
|
|
|
case DeviceType.ATAPI:
|
2017-12-19 20:33:03 +00:00
|
|
|
{
|
|
|
|
|
AtaErrorRegistersCHS errorRegisters;
|
2015-10-15 01:46:31 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
byte[] ataBuf;
|
|
|
|
|
bool sense = dev.AtapiIdentify(out ataBuf, out errorRegisters);
|
2015-10-15 01:46:31 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
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;
|
|
|
|
|
}
|
2015-10-19 04:32:16 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_atapi_identify.bin",
|
|
|
|
|
"ATAPI IDENTIFY", ataBuf);
|
2015-11-02 21:08:38 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine(Identify.Prettify(ataBuf));
|
2015-10-15 01:46:31 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
// ATAPI devices are also SCSI devices
|
|
|
|
|
goto case DeviceType.SCSI;
|
|
|
|
|
}
|
2015-10-19 05:11:28 +01:00
|
|
|
case DeviceType.SCSI:
|
2017-12-19 20:33:03 +00:00
|
|
|
{
|
|
|
|
|
byte[] senseBuf;
|
|
|
|
|
byte[] inqBuf;
|
2015-10-19 04:32:16 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
bool sense = dev.ScsiInquiry(out inqBuf, out senseBuf);
|
2015-10-19 04:32:16 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
if(sense)
|
|
|
|
|
{
|
|
|
|
|
DicConsole.ErrorWriteLine("SCSI error:\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
2015-10-19 04:32:16 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
2015-10-19 04:32:16 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
if(dev.Type != DeviceType.ATAPI) DicConsole.WriteLine("SCSI device");
|
2015-10-19 04:32:16 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_scsi_inquiry.bin", "SCSI INQUIRY",
|
|
|
|
|
inqBuf);
|
2015-11-02 21:08:38 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
Decoders.SCSI.Inquiry.SCSIInquiry? inq = Decoders.SCSI.Inquiry.Decode(inqBuf);
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Inquiry.Prettify(inq));
|
2015-10-19 04:32:16 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, 0x00);
|
2015-10-19 05:11:28 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
if(!sense)
|
|
|
|
|
{
|
|
|
|
|
byte[] pages = Decoders.SCSI.EVPD.DecodePage00(inqBuf);
|
2015-10-19 05:11:28 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
if(pages != null)
|
|
|
|
|
foreach(byte page in pages)
|
|
|
|
|
if(page >= 0x01 && page <= 0x7F)
|
2015-10-19 04:32:16 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2015-10-19 05:11:28 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("ASCII Page {0:X2}h: {1}", page,
|
|
|
|
|
Decoders.SCSI.EVPD.DecodeASCIIPage(inqBuf));
|
2015-11-02 21:08:38 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2015-10-19 05:11:28 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0x80)
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2015-10-19 05:11:28 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("Unit Serial Number: {0}",
|
|
|
|
|
Decoders.SCSI.EVPD.DecodePage80(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 06:18:12 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0x81)
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 06:18:12 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_81(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2015-10-31 21:03:18 +00:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0x82)
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 04:01:39 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("ASCII implemented operating definitions: {0}",
|
|
|
|
|
Decoders.SCSI.EVPD.DecodePage82(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 04:55:00 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0x83)
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 04:55:00 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_83(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 04:01:39 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0x84)
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 06:59:56 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_84(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 06:59:56 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0x85)
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 06:59:56 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_85(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 06:59:56 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0x86)
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 18:31:05 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_86(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 18:31:05 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0x89)
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 18:31:05 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_89(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 18:31:05 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0xB0)
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 22:59:48 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_B0(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 22:59:48 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0xB1)
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-14 00:02:42 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("Manufacturer-assigned Serial Number: {0}",
|
|
|
|
|
Decoders.SCSI.EVPD.DecodePageB1(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-14 00:02:42 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0xB2)
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-14 00:02:42 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("TapeAlert Supported Flags Bitmap: 0x{0:X16}",
|
|
|
|
|
Decoders.SCSI.EVPD.DecodePageB2(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-14 00:02:42 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0xB3)
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-14 00:02:42 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("Automation Device Serial Number: {0}",
|
|
|
|
|
Decoders.SCSI.EVPD.DecodePageB3(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-14 00:02:42 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0xB4)
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-14 00:02:42 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("Data Transfer Device Element Address: 0x{0}",
|
|
|
|
|
Decoders.SCSI.EVPD.DecodePageB4(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-14 00:02:42 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0xC0 &&
|
|
|
|
|
StringHandlers
|
|
|
|
|
.CToString(inq.Value.VendorIdentification).ToLowerInvariant().Trim() ==
|
|
|
|
|
"quantum")
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 19:15:52 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_C0_Quantum(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-14 23:05:36 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0xC0 &&
|
|
|
|
|
StringHandlers
|
|
|
|
|
.CToString(inq.Value.VendorIdentification).ToLowerInvariant().Trim() ==
|
|
|
|
|
"seagate")
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-14 23:05:36 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_C0_Seagate(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 19:15:52 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0xC0 &&
|
|
|
|
|
StringHandlers
|
|
|
|
|
.CToString(inq.Value.VendorIdentification).ToLowerInvariant().Trim() ==
|
|
|
|
|
"ibm")
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 22:56:16 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_C0_IBM(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 22:56:16 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0xC1 &&
|
|
|
|
|
StringHandlers
|
|
|
|
|
.CToString(inq.Value.VendorIdentification).ToLowerInvariant().Trim() ==
|
|
|
|
|
"ibm")
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 22:56:16 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_C1_IBM(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 22:56:16 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if((page == 0xC0 || page == 0xC1) &&
|
|
|
|
|
StringHandlers
|
|
|
|
|
.CToString(inq.Value.VendorIdentification).ToLowerInvariant().Trim() ==
|
|
|
|
|
"certance")
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 20:28:08 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}",
|
|
|
|
|
Decoders.SCSI.EVPD.PrettifyPage_C0_C1_Certance(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 20:28:08 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(
|
|
|
|
|
(page == 0xC2 || page == 0xC3 || page == 0xC4 || page == 0xC5 || page == 0xC6) &&
|
|
|
|
|
StringHandlers.CToString(inq.Value.VendorIdentification).ToLowerInvariant()
|
|
|
|
|
.Trim() == "certance")
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 20:28:08 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}",
|
|
|
|
|
Decoders
|
|
|
|
|
.SCSI.EVPD
|
|
|
|
|
.PrettifyPage_C2_C3_C4_C5_C6_Certance(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 20:28:08 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if((page == 0xC0 || page == 0xC1 || page == 0xC2 || page == 0xC3 || page == 0xC4 ||
|
|
|
|
|
page == 0xC5) &&
|
|
|
|
|
StringHandlers
|
|
|
|
|
.CToString(inq.Value.VendorIdentification).ToLowerInvariant().Trim() ==
|
|
|
|
|
"hp")
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-14 02:20:00 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}",
|
|
|
|
|
Decoders.SCSI.EVPD.PrettifyPage_C0_to_C5_HP(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-14 02:20:00 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else if(page == 0xDF &&
|
|
|
|
|
StringHandlers
|
|
|
|
|
.CToString(inq.Value.VendorIdentification).ToLowerInvariant().Trim() ==
|
|
|
|
|
"certance")
|
|
|
|
|
{
|
|
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
2016-10-13 20:28:08 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.WriteLine("{0}",
|
|
|
|
|
Decoders.SCSI.EVPD.PrettifyPage_DF_Certance(inqBuf));
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2016-10-13 20:28:08 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if(page != 0x00)
|
2015-10-31 21:03:18 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole.DebugWriteLine("Device-Info command",
|
|
|
|
|
"Found undecoded SCSI VPD page 0x{0:X2}", page);
|
2015-11-02 21:08:38 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
|
|
|
|
|
if(!sense)
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix,
|
|
|
|
|
string.Format("_scsi_evpd_{0:X2}h.bin", page),
|
|
|
|
|
string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
|
2015-10-19 05:11:28 +01:00
|
|
|
}
|
2015-10-19 04:32:16 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
byte[] modeBuf;
|
|
|
|
|
double duration;
|
|
|
|
|
Decoders.SCSI.Modes.DecodedMode? decMode = null;
|
|
|
|
|
Decoders.SCSI.PeripheralDeviceTypes devType =
|
|
|
|
|
(Decoders.SCSI.PeripheralDeviceTypes)inq.Value.PeripheralDeviceType;
|
2015-10-19 04:32:16 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
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);
|
2015-10-31 21:03:18 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
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);
|
2016-04-19 02:11:47 +01:00
|
|
|
if(sense || dev.Error)
|
2017-12-19 20:33:03 +00:00
|
|
|
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);
|
2015-10-31 21:03:18 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
if(!sense && !dev.Error) decMode = Decoders.SCSI.Modes.DecodeMode6(modeBuf, devType);
|
|
|
|
|
}
|
2015-10-31 21:32:10 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
if(!sense)
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_scsi_modesense.bin",
|
|
|
|
|
"SCSI MODE SENSE", modeBuf);
|
2015-10-31 21:03:18 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
if(decMode.HasValue)
|
|
|
|
|
{
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyModeHeader(decMode.Value.Header, devType));
|
2015-11-02 21:08:38 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
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)
|
2015-10-31 21:03:18 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
case 0x00:
|
2015-10-31 21:03:18 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
if(devType == 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;
|
2015-10-31 21:03:18 +00:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
case 0x01:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
if(devType == 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;
|
2015-10-31 21:03:18 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x02:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_02(page.PageResponse));
|
|
|
|
|
else goto default;
|
2016-04-19 02:11:47 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x03:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_03(page.PageResponse));
|
|
|
|
|
else goto default;
|
2015-11-01 22:09:10 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x04:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_04(page.PageResponse));
|
|
|
|
|
else goto default;
|
2015-11-02 21:08:38 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x05:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_05(page.PageResponse));
|
|
|
|
|
else goto default;
|
2015-11-01 22:09:10 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x06:
|
2015-11-02 19:12:19 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_06(page.PageResponse));
|
|
|
|
|
else goto default;
|
2015-11-02 19:12:19 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x07:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
if(devType == 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;
|
2015-11-01 22:09:10 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x08:
|
2015-11-02 19:12:19 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_08(page.PageResponse));
|
|
|
|
|
else goto default;
|
|
|
|
|
|
|
|
|
|
break;
|
2015-11-02 19:12:19 +00:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
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;
|
2015-11-02 19:12:19 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x0B:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_0B(page.PageResponse));
|
|
|
|
|
else goto default;
|
2015-11-01 22:09:10 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x0D:
|
2015-11-01 22:09:10 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_0D(page.PageResponse));
|
|
|
|
|
else goto default;
|
|
|
|
|
|
|
|
|
|
break;
|
2015-11-01 22:09:10 +00:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
case 0x0E:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_0E(page.PageResponse));
|
|
|
|
|
else goto default;
|
2015-11-01 22:09:10 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x0F:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_0F(page.PageResponse));
|
|
|
|
|
else goto default;
|
2016-01-14 21:10:39 +00:00
|
|
|
|
2016-01-11 19:24:17 +00:00
|
|
|
break;
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
case 0x10:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
if(devType == 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 0x11:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_11(page.PageResponse));
|
|
|
|
|
else goto default;
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x12:
|
|
|
|
|
case 0x13:
|
|
|
|
|
case 0x14:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_12_13_14(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 == 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;
|
2016-01-14 21:10:39 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x1D:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_1D(page.PageResponse));
|
|
|
|
|
else goto default;
|
2016-01-14 21:10:39 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x21:
|
|
|
|
|
{
|
|
|
|
|
if(StringHandlers.CToString(inq.Value.VendorIdentification).Trim() == "CERTANCE"
|
|
|
|
|
)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyCertanceModePage_21(page
|
|
|
|
|
.PageResponse));
|
|
|
|
|
else goto default;
|
2016-01-14 21:10:39 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x22:
|
2016-01-14 21:10:39 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
if(StringHandlers.CToString(inq.Value.VendorIdentification).Trim() == "CERTANCE"
|
|
|
|
|
)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyCertanceModePage_22(page
|
|
|
|
|
.PageResponse));
|
|
|
|
|
else goto default;
|
|
|
|
|
|
|
|
|
|
break;
|
2016-01-14 21:10:39 +00:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
case 0x24:
|
2016-01-14 21:10:39 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
if(StringHandlers.CToString(inq.Value.VendorIdentification).Trim() == "IBM")
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyIBMModePage_24(page.PageResponse));
|
|
|
|
|
else goto default;
|
|
|
|
|
|
|
|
|
|
break;
|
2016-01-11 19:24:17 +00:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
case 0x2A:
|
|
|
|
|
{
|
|
|
|
|
if(page.Subpage == 0)
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyModePage_2A(page.PageResponse));
|
|
|
|
|
else goto default;
|
2016-01-11 19:24:17 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x2F:
|
2016-01-14 21:10:39 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
if(StringHandlers.CToString(inq.Value.VendorIdentification).Trim() == "IBM")
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyIBMModePage_2F(page.PageResponse));
|
|
|
|
|
else goto default;
|
|
|
|
|
|
|
|
|
|
break;
|
2016-01-14 21:10:39 +00:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
case 0x30:
|
|
|
|
|
{
|
|
|
|
|
if(Decoders.SCSI.Modes.IsAppleModePage_30(page.PageResponse))
|
|
|
|
|
DicConsole.WriteLine("Drive identifies as Apple OEM drive");
|
|
|
|
|
else goto default;
|
2016-01-14 21:10:39 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x3B:
|
2016-01-11 19:24:17 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
if(StringHandlers.CToString(inq.Value.VendorIdentification).Trim() == "HP")
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyHPModePage_3B(page.PageResponse));
|
|
|
|
|
else goto default;
|
2016-01-14 21:10:39 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x3C:
|
|
|
|
|
{
|
|
|
|
|
if(StringHandlers.CToString(inq.Value.VendorIdentification).Trim() == "HP")
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyHPModePage_3C(page.PageResponse));
|
|
|
|
|
else goto default;
|
2016-01-14 21:10:39 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 0x3D:
|
|
|
|
|
{
|
|
|
|
|
if(StringHandlers.CToString(inq.Value.VendorIdentification).Trim() == "IBM")
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyIBMModePage_3D(page.PageResponse));
|
|
|
|
|
else if(StringHandlers.CToString(inq.Value.VendorIdentification).Trim() == "HP")
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyHPModePage_3D(page.PageResponse));
|
|
|
|
|
else goto default;
|
2016-01-14 21:10:39 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
2016-01-11 19:24:17 +00:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
case 0x3E:
|
|
|
|
|
{
|
|
|
|
|
if(StringHandlers.CToString(inq.Value.VendorIdentification).Trim() == "FUJITSU")
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyFujitsuModePage_3E(page
|
|
|
|
|
.PageResponse));
|
|
|
|
|
else if(StringHandlers.CToString(inq.Value.VendorIdentification).Trim() == "HP")
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.Modes
|
|
|
|
|
.PrettifyHPModePage_3E(page.PageResponse));
|
|
|
|
|
else goto default;
|
2016-01-11 19:24:17 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default:
|
2016-01-14 21:10:39 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
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;
|
2016-01-14 21:10:39 +00:00
|
|
|
}
|
2016-01-11 19:24:17 +00:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
2016-01-11 19:24:17 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
switch(devType) {
|
|
|
|
|
case Decoders.SCSI.PeripheralDeviceTypes.MultiMediaDevice:
|
|
|
|
|
byte[] confBuf;
|
|
|
|
|
sense = dev.GetConfiguration(out confBuf, out senseBuf, dev.Timeout, out duration);
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
if(!sense)
|
2017-12-19 20:33:03 +00:00
|
|
|
{
|
2017-12-21 04:43:29 +00:00
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_mmc_getconfiguration.bin",
|
|
|
|
|
"MMC GET CONFIGURATION", confBuf);
|
|
|
|
|
|
|
|
|
|
Decoders.SCSI.MMC.Features.SeparatedFeatures ftr =
|
|
|
|
|
Decoders.SCSI.MMC.Features.Separate(confBuf);
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
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)
|
2017-12-19 20:33:03 +00:00
|
|
|
{
|
2017-12-21 04:43:29 +00:00
|
|
|
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;
|
|
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
2016-01-11 19:24:17 +00:00
|
|
|
}
|
2017-12-21 04:43:29 +00:00
|
|
|
else
|
|
|
|
|
DicConsole.DebugWriteLine("Device-Info command",
|
|
|
|
|
"GET CONFIGURATION returned no feature descriptors");
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
2016-01-11 19:24:17 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
// 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.
|
|
|
|
|
/*
|
2017-12-19 20:33:03 +00:00
|
|
|
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)
|
2016-01-11 19:24:17 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
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);
|
2016-01-11 19:24:17 +00:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
}
|
2016-01-11 19:24:17 +00:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
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)
|
2016-01-11 19:24:17 +00:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
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);
|
2016-01-11 19:24:17 +00:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
*/
|
2016-01-11 19:24:17 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
#region Plextor
|
|
|
|
|
if(dev.Manufacturer == "PLEXTOR")
|
2017-12-19 20:33:03 +00:00
|
|
|
{
|
2017-12-21 04:43:29 +00:00
|
|
|
bool plxtSense = true;
|
|
|
|
|
bool plxtDvd = false;
|
|
|
|
|
byte[] plxtBuf = null;
|
|
|
|
|
|
|
|
|
|
switch(dev.Model)
|
2016-01-14 21:10:39 +00:00
|
|
|
{
|
2017-12-21 04:43:29 +00:00
|
|
|
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":
|
2017-12-19 20:33:03 +00:00
|
|
|
{
|
2017-12-21 04:43:29 +00:00
|
|
|
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;
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
Array.Copy(plxtBufSmall, 0, plxtBuf, i * 256, 256);
|
|
|
|
|
}
|
2016-01-11 19:24:17 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
plxtDvd = true;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default:
|
|
|
|
|
{
|
|
|
|
|
if(dev.Model.StartsWith("CD-R ", StringComparison.Ordinal))
|
|
|
|
|
plxtSense = dev.PlextorReadEepromCdr(out plxtBuf, out senseBuf, dev.Timeout,
|
|
|
|
|
out duration);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
2016-01-11 19:24:17 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
if(!plxtSense)
|
|
|
|
|
{
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_plextor_eeprom.bin",
|
|
|
|
|
"PLEXTOR READ EEPROM", plxtBuf);
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
ushort discs;
|
|
|
|
|
uint cdReadTime, cdWriteTime, dvdReadTime = 0, dvdWriteTime = 0;
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
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);
|
|
|
|
|
}
|
2016-01-11 19:24:17 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
DicConsole.WriteLine("Drive has loaded a total of {0} discs", discs);
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole
|
2017-12-21 04:43:29 +00:00
|
|
|
.WriteLine("Drive has spent {0} hours, {1} minutes and {2} seconds reading CDs",
|
|
|
|
|
cdReadTime / 3600, cdReadTime / 60 % 60, cdReadTime % 60);
|
2017-12-19 20:33:03 +00:00
|
|
|
DicConsole
|
2017-12-21 04:43:29 +00:00
|
|
|
.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);
|
|
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
bool plxtPwrRecEnabled;
|
|
|
|
|
ushort plxtPwrRecSpeed;
|
|
|
|
|
plxtSense = dev.PlextorGetPoweRec(out senseBuf, out plxtPwrRecEnabled, out plxtPwrRecSpeed,
|
|
|
|
|
dev.Timeout, out duration);
|
|
|
|
|
if(!plxtSense)
|
2017-12-19 20:33:03 +00:00
|
|
|
{
|
2017-12-21 04:43:29 +00:00
|
|
|
DicConsole.Write("Drive supports PoweRec");
|
|
|
|
|
if(plxtPwrRecEnabled)
|
|
|
|
|
{
|
|
|
|
|
DicConsole.Write(", has it enabled");
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
if(plxtPwrRecSpeed > 0)
|
|
|
|
|
DicConsole.WriteLine(" and recommends {0} Kb/sec.", plxtPwrRecSpeed);
|
|
|
|
|
else DicConsole.WriteLine(".");
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
ushort plxtPwrRecSelected, plxtPwrRecMax, plxtPwrRecLast;
|
|
|
|
|
plxtSense = dev.PlextorGetSpeeds(out senseBuf, out plxtPwrRecSelected,
|
|
|
|
|
out plxtPwrRecMax, out plxtPwrRecLast, dev.Timeout,
|
|
|
|
|
out duration);
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
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);
|
|
|
|
|
}
|
2016-01-14 21:10:39 +00:00
|
|
|
}
|
2017-12-21 04:43:29 +00:00
|
|
|
else DicConsole.WriteLine("PoweRec is disabled");
|
2016-01-14 21:10:39 +00:00
|
|
|
}
|
2017-05-23 19:11:11 +01:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
// TODO: Check it with a drive
|
|
|
|
|
plxtSense = dev.PlextorGetSilentMode(out plxtBuf, out senseBuf, dev.Timeout, out duration);
|
|
|
|
|
if(!plxtSense)
|
2017-05-23 19:11:11 +01:00
|
|
|
{
|
2017-12-21 04:43:29 +00:00
|
|
|
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);
|
|
|
|
|
}
|
2017-05-23 19:11:11 +01:00
|
|
|
}
|
2016-01-11 19:24:17 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
plxtSense = dev.PlextorGetGigaRec(out plxtBuf, out senseBuf, dev.Timeout, out duration);
|
|
|
|
|
if(!plxtSense) DicConsole.WriteLine("Drive supports Plextor GigaRec");
|
2016-01-15 07:00:43 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
plxtSense = dev.PlextorGetSecuRec(out plxtBuf, out senseBuf, dev.Timeout, out duration);
|
|
|
|
|
if(!plxtSense) DicConsole.WriteLine("Drive supports Plextor SecuRec");
|
2016-01-15 07:00:43 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
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();
|
|
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
plxtSense = dev.PlextorGetHiding(out plxtBuf, out senseBuf, dev.Timeout, out duration);
|
|
|
|
|
if(!plxtSense)
|
|
|
|
|
{
|
|
|
|
|
DicConsole.WriteLine("Drive supports hiding CD-Rs and forcing single session");
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
if((plxtBuf[2] & 0x02) == 0x02) DicConsole.WriteLine("Drive currently hides CD-Rs");
|
|
|
|
|
if((plxtBuf[2] & 0x01) == 0x01)
|
|
|
|
|
DicConsole.WriteLine("Drive currently forces single session");
|
|
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
plxtSense = dev.PlextorGetVariRec(out plxtBuf, out senseBuf, false, dev.Timeout,
|
2017-12-19 20:33:03 +00:00
|
|
|
out duration);
|
2017-12-21 04:43:29 +00:00
|
|
|
if(!plxtSense) DicConsole.WriteLine("Drive supports Plextor VariRec");
|
|
|
|
|
|
|
|
|
|
if(plxtDvd)
|
|
|
|
|
{
|
|
|
|
|
plxtSense = dev.PlextorGetVariRec(out plxtBuf, out senseBuf, true, dev.Timeout,
|
|
|
|
|
out duration);
|
|
|
|
|
if(!plxtSense) DicConsole.WriteLine("Drive supports Plextor VariRec for DVDs");
|
|
|
|
|
|
|
|
|
|
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+");
|
|
|
|
|
}
|
2016-01-15 07:00:43 +00:00
|
|
|
}
|
2017-12-21 04:43:29 +00:00
|
|
|
#endregion Plextor
|
2016-01-15 07:00:43 +00:00
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
if(inq.Value.KreonPresent)
|
2017-12-19 20:33:03 +00:00
|
|
|
{
|
2017-12-21 04:43:29 +00:00
|
|
|
KreonFeatures krFeatures;
|
|
|
|
|
if(!dev.KreonGetFeatureList(out senseBuf, out krFeatures, dev.Timeout, out duration))
|
|
|
|
|
{
|
|
|
|
|
DicConsole.WriteLine("Drive has kreon firmware:");
|
|
|
|
|
if(krFeatures.HasFlag(KreonFeatures.ChallengeResponse))
|
|
|
|
|
DicConsole.WriteLine("\tCan do challenge/response with Xbox discs");
|
|
|
|
|
if(krFeatures.HasFlag(KreonFeatures.DecryptSs))
|
|
|
|
|
DicConsole.WriteLine("\tCan read and descrypt SS from Xbox discs");
|
|
|
|
|
if(krFeatures.HasFlag(KreonFeatures.XtremeUnlock))
|
|
|
|
|
DicConsole.WriteLine("\tCan set xtreme unlock state with Xbox discs");
|
|
|
|
|
if(krFeatures.HasFlag(KreonFeatures.WxripperUnlock))
|
|
|
|
|
DicConsole.WriteLine("\tCan set wxripper unlock state with Xbox discs");
|
|
|
|
|
if(krFeatures.HasFlag(KreonFeatures.ChallengeResponse360))
|
|
|
|
|
DicConsole.WriteLine("\tCan do challenge/response with Xbox 360 discs");
|
|
|
|
|
if(krFeatures.HasFlag(KreonFeatures.DecryptSs360))
|
|
|
|
|
DicConsole.WriteLine("\tCan read and descrypt SS from Xbox 360 discs");
|
|
|
|
|
if(krFeatures.HasFlag(KreonFeatures.XtremeUnlock360))
|
|
|
|
|
DicConsole.WriteLine("\tCan set xtreme unlock state with Xbox 360 discs");
|
|
|
|
|
if(krFeatures.HasFlag(KreonFeatures.WxripperUnlock360))
|
|
|
|
|
DicConsole.WriteLine("\tCan set wxripper unlock state with Xbox 360 discs");
|
|
|
|
|
if(krFeatures.HasFlag(KreonFeatures.Lock))
|
|
|
|
|
DicConsole.WriteLine("\tCan set locked state");
|
|
|
|
|
if(krFeatures.HasFlag(KreonFeatures.ErrorSkipping))
|
|
|
|
|
DicConsole.WriteLine("\tCan skip read errors");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 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
|
|
|
|
|
{
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_ssc_readblocklimits.bin",
|
|
|
|
|
"SSC READ BLOCK LIMITS", seqBuf);
|
|
|
|
|
DicConsole.WriteLine("Block limits for device:");
|
|
|
|
|
DicConsole.WriteLine(Decoders.SCSI.SSC.BlockLimits.Prettify(seqBuf));
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
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
|
2017-12-19 20:33:03 +00:00
|
|
|
{
|
2017-12-21 04:43:29 +00:00
|
|
|
DataFile.WriteTo("Device-Info command", 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));
|
|
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
|
2017-12-21 04:43:29 +00:00
|
|
|
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
|
2017-12-19 20:33:03 +00:00
|
|
|
{
|
2017-12-21 04:43:29 +00:00
|
|
|
DataFile.WriteTo("Device-Info command", 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));
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
2017-12-21 04:43:29 +00:00
|
|
|
break;
|
2017-09-28 21:13:09 +01:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2017-09-28 21:13:09 +01:00
|
|
|
break;
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|
|
|
|
|
case DeviceType.MMC:
|
|
|
|
|
{
|
|
|
|
|
bool noInfo = true;
|
|
|
|
|
|
2017-12-20 17:15:26 +00:00
|
|
|
bool sense = dev.ReadCid(out byte[] mmcBuf, out uint[] response, dev.Timeout, out double duration);
|
2017-12-19 20:33:03 +00:00
|
|
|
if(!sense)
|
2017-09-28 21:13:09 +01:00
|
|
|
{
|
2017-12-19 20:33:03 +00:00
|
|
|
noInfo = false;
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_mmc_cid.bin", "MMC CID",
|
|
|
|
|
mmcBuf);
|
|
|
|
|
DicConsole.WriteLine("{0}", Decoders.MMC.Decoders.PrettifyCID(mmcBuf));
|
|
|
|
|
}
|
2017-12-20 17:15:26 +00:00
|
|
|
sense = dev.ReadCsd(out mmcBuf, out response, dev.Timeout, out duration);
|
2017-12-19 20:33:03 +00:00
|
|
|
if(!sense)
|
|
|
|
|
{
|
|
|
|
|
noInfo = false;
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_mmc_csd.bin", "MMC CSD",
|
|
|
|
|
mmcBuf);
|
|
|
|
|
DicConsole.WriteLine("{0}", Decoders.MMC.Decoders.PrettifyCSD(mmcBuf));
|
|
|
|
|
}
|
2017-12-20 17:15:26 +00:00
|
|
|
sense = dev.ReadOcr(out mmcBuf, out response, dev.Timeout, out duration);
|
2017-12-19 20:33:03 +00:00
|
|
|
if(!sense)
|
|
|
|
|
{
|
|
|
|
|
noInfo = false;
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_mmc_ocr.bin", "MMC OCR",
|
|
|
|
|
mmcBuf);
|
|
|
|
|
DicConsole.WriteLine("{0}", Decoders.MMC.Decoders.PrettifyOCR(mmcBuf));
|
|
|
|
|
}
|
2017-12-20 17:15:26 +00:00
|
|
|
sense = dev.ReadExtendedCsd(out mmcBuf, out response, dev.Timeout, out duration);
|
2017-12-19 20:33:03 +00:00
|
|
|
if(!sense)
|
|
|
|
|
{
|
|
|
|
|
noInfo = false;
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_mmc_ecsd.bin",
|
|
|
|
|
"MMC Extended CSD", mmcBuf);
|
|
|
|
|
DicConsole.WriteLine("{0}", Decoders.MMC.Decoders.PrettifyExtendedCSD(mmcBuf));
|
|
|
|
|
}
|
2017-09-28 21:13:09 +01:00
|
|
|
|
2017-12-19 20:33:03 +00:00
|
|
|
if(noInfo) DicConsole.WriteLine("Could not get any kind of information from the device !!!");
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case DeviceType.SecureDigital:
|
|
|
|
|
{
|
|
|
|
|
bool noInfo = true;
|
2017-09-28 21:13:09 +01:00
|
|
|
|
2017-12-20 17:15:26 +00:00
|
|
|
bool sense = dev.ReadCid(out byte[] sdBuf, out uint[] response, dev.Timeout, out double duration);
|
2017-12-19 20:33:03 +00:00
|
|
|
if(!sense)
|
|
|
|
|
{
|
|
|
|
|
noInfo = false;
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_sd_cid.bin",
|
|
|
|
|
"SecureDigital CID", sdBuf);
|
|
|
|
|
DicConsole.WriteLine("{0}", Decoders.SecureDigital.Decoders.PrettifyCID(sdBuf));
|
2017-09-28 21:13:09 +01:00
|
|
|
}
|
2017-12-20 17:15:26 +00:00
|
|
|
sense = dev.ReadCsd(out sdBuf, out response, dev.Timeout, out duration);
|
2017-12-19 20:33:03 +00:00
|
|
|
if(!sense)
|
|
|
|
|
{
|
|
|
|
|
noInfo = false;
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_sd_csd.bin",
|
|
|
|
|
"SecureDigital CSD", sdBuf);
|
|
|
|
|
DicConsole.WriteLine("{0}", Decoders.SecureDigital.Decoders.PrettifyCSD(sdBuf));
|
|
|
|
|
}
|
2017-12-20 17:15:26 +00:00
|
|
|
sense = dev.ReadSdocr(out sdBuf, out response, dev.Timeout, out duration);
|
2017-12-19 20:33:03 +00:00
|
|
|
if(!sense)
|
|
|
|
|
{
|
|
|
|
|
noInfo = false;
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_sd_ocr.bin",
|
|
|
|
|
"SecureDigital OCR", sdBuf);
|
|
|
|
|
DicConsole.WriteLine("{0}", Decoders.SecureDigital.Decoders.PrettifyOCR(sdBuf));
|
|
|
|
|
}
|
2017-12-20 17:15:26 +00:00
|
|
|
sense = dev.ReadScr(out sdBuf, out response, dev.Timeout, out duration);
|
2017-12-19 20:33:03 +00:00
|
|
|
if(!sense)
|
|
|
|
|
{
|
|
|
|
|
noInfo = false;
|
|
|
|
|
DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_sd_scr.bin",
|
|
|
|
|
"SecureDigital SCR", sdBuf);
|
|
|
|
|
DicConsole.WriteLine("{0}", Decoders.SecureDigital.Decoders.PrettifySCR(sdBuf));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(noInfo) DicConsole.WriteLine("Could not get any kind of information from the device !!!");
|
|
|
|
|
}
|
2017-09-28 21:13:09 +01:00
|
|
|
break;
|
2015-10-19 05:11:28 +01:00
|
|
|
default:
|
|
|
|
|
DicConsole.ErrorWriteLine("Unknown device type {0}, cannot get information.", dev.Type);
|
|
|
|
|
break;
|
2015-10-19 04:32:16 +01:00
|
|
|
}
|
* 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
|
|
|
|
|
|
|
|
Core.Statistics.AddCommand("device-info");
|
2015-10-13 01:45:07 +01:00
|
|
|
}
|
|
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
}
|