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
94f40842f356d3851c54b3c930d8f06d40962090
Aaru/SCSI/Modes/Mode6.cs

235 lines
9.8 KiB
C#
Raw Normal View History

REFACTOR: Separate SCSI MODE decoders.
2017-12-21 02:03:21 +00:00
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : Modes.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Device structures decoders.
//
// --[ Description ] ----------------------------------------------------------
//
// Decodes and encodines SCSI modes in MODE SENSE/SELECT (6) format.
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2018 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
namespace DiscImageChef.Decoders.SCSI
{
public static partial class Modes
{
public static ModeHeader? DecodeModeHeader6(byte[] modeResponse, PeripheralDeviceTypes deviceType)
{
if(modeResponse == null || modeResponse.Length < 4 || modeResponse.Length < modeResponse[0] + 1)
return null;
ModeHeader header = new ModeHeader();
header.MediumType = (MediumTypes)modeResponse[1];
if(modeResponse[3] > 0)
{
header.BlockDescriptors = new BlockDescriptor[modeResponse[3] / 8];
for(int i = 0; i < header.BlockDescriptors.Length; i++)
{
header.BlockDescriptors[i].Density = (DensityType)modeResponse[0 + i * 8 + 4];
header.BlockDescriptors[i].Blocks += (ulong)(modeResponse[1 + i * 8 + 4] << 16);
header.BlockDescriptors[i].Blocks += (ulong)(modeResponse[2 + i * 8 + 4] << 8);
header.BlockDescriptors[i].Blocks += modeResponse[3 + i * 8 + 4];
header.BlockDescriptors[i].BlockLength += (uint)(modeResponse[5 + i * 8 + 4] << 16);
header.BlockDescriptors[i].BlockLength += (uint)(modeResponse[6 + i * 8 + 4] << 8);
header.BlockDescriptors[i].BlockLength += modeResponse[7 + i * 8 + 4];
}
}
if(deviceType == PeripheralDeviceTypes.DirectAccess || deviceType == PeripheralDeviceTypes.MultiMediaDevice)
{
header.WriteProtected = (modeResponse[2] & 0x80) == 0x80;
header.DPOFUA = (modeResponse[2] & 0x10) == 0x10;
}
if(deviceType == PeripheralDeviceTypes.SequentialAccess)
{
header.WriteProtected = (modeResponse[2] & 0x80) == 0x80;
header.Speed = (byte)(modeResponse[2] & 0x0F);
header.BufferedMode = (byte)((modeResponse[2] & 0x70) >> 4);
}
if(deviceType == PeripheralDeviceTypes.PrinterDevice)
header.BufferedMode = (byte)((modeResponse[2] & 0x70) >> 4);
if(deviceType == PeripheralDeviceTypes.OpticalDevice)
{
header.WriteProtected = (modeResponse[2] & 0x80) == 0x80;
header.EBC = (modeResponse[2] & 0x01) == 0x01;
header.DPOFUA = (modeResponse[2] & 0x10) == 0x10;
}
return header;
}
public static string PrettifyModeHeader6(byte[] modeResponse, PeripheralDeviceTypes deviceType)
{
return PrettifyModeHeader(DecodeModeHeader6(modeResponse, deviceType), deviceType);
}
public static DecodedMode? DecodeMode6(byte[] modeResponse, PeripheralDeviceTypes deviceType)
{
ModeHeader? hdr = DecodeModeHeader6(modeResponse, deviceType);
if(!hdr.HasValue) return null;
DecodedMode decoded = new DecodedMode();
decoded.Header = hdr.Value;
int blkDrLength = 0;
if(decoded.Header.BlockDescriptors != null) blkDrLength = decoded.Header.BlockDescriptors.Length;
int offset = 4 + blkDrLength * 8;
int length = modeResponse[0] + 1;
if(length != modeResponse.Length) return decoded;
List<ModePage> listpages = new List<ModePage>();
while(offset < modeResponse.Length)
{
bool isSubpage = (modeResponse[offset] & 0x40) == 0x40;
ModePage pg = new ModePage();
byte pageNo = (byte)(modeResponse[offset] & 0x3F);
if(pageNo == 0)
{
pg.PageResponse = new byte[modeResponse.Length - offset];
Array.Copy(modeResponse, offset, pg.PageResponse, 0, pg.PageResponse.Length);
pg.Page = 0;
pg.Subpage = 0;
offset += pg.PageResponse.Length;
}
else
{
if(isSubpage)
{
if(offset + 3 >= modeResponse.Length) break;
pg.PageResponse = new byte[(modeResponse[offset + 2] << 8) + modeResponse[offset + 3] + 4];
if(pg.PageResponse.Length + offset > modeResponse.Length) return decoded;
Array.Copy(modeResponse, offset, pg.PageResponse, 0, pg.PageResponse.Length);
pg.Page = (byte)(modeResponse[offset] & 0x3F);
pg.Subpage = modeResponse[offset + 1];
offset += pg.PageResponse.Length;
}
else
{
if(offset + 1 >= modeResponse.Length) break;
pg.PageResponse = new byte[modeResponse[offset + 1] + 2];
if(pg.PageResponse.Length + offset > modeResponse.Length) return decoded;
Array.Copy(modeResponse, offset, pg.PageResponse, 0, pg.PageResponse.Length);
pg.Page = (byte)(modeResponse[offset] & 0x3F);
pg.Subpage = 0;
offset += pg.PageResponse.Length;
}
}
listpages.Add(pg);
}
decoded.Pages = listpages.ToArray();
return decoded;
}
public static byte[] EncodeModeHeader6(ModeHeader header, PeripheralDeviceTypes deviceType)
{
byte[] hdr;
if(header.BlockDescriptors != null) hdr = new byte[4 + header.BlockDescriptors.Length * 8];
else hdr = new byte[4];
hdr[1] = (byte)header.MediumType;
if(deviceType == PeripheralDeviceTypes.DirectAccess || deviceType == PeripheralDeviceTypes.MultiMediaDevice)
{
if(header.WriteProtected) hdr[2] += 0x80;
if(header.DPOFUA) hdr[2] += 0x10;
}
if(deviceType == PeripheralDeviceTypes.SequentialAccess)
{
if(header.WriteProtected) hdr[2] += 0x80;
hdr[2] += (byte)(header.Speed & 0x0F);
hdr[2] += (byte)((header.BufferedMode << 4) & 0x70);
}
if(deviceType == PeripheralDeviceTypes.PrinterDevice) hdr[2] += (byte)((header.BufferedMode << 4) & 0x70);
if(deviceType == PeripheralDeviceTypes.OpticalDevice)
{
if(header.WriteProtected) hdr[2] += 0x80;
if(header.EBC) hdr[2] += 0x01;
if(header.DPOFUA) hdr[2] += 0x10;
}
if(header.BlockDescriptors != null)
{
hdr[3] = (byte)(header.BlockDescriptors.Length * 8);
for(int i = 0; i < header.BlockDescriptors.Length; i++)
{
hdr[0 + i * 8 + 4] = (byte)header.BlockDescriptors[i].Density;
hdr[1 + i * 8 + 4] = (byte)((header.BlockDescriptors[i].Blocks & 0xFF0000) >> 16);
hdr[2 + i * 8 + 4] = (byte)((header.BlockDescriptors[i].Blocks & 0xFF00) >> 8);
hdr[3 + i * 8 + 4] = (byte)(header.BlockDescriptors[i].Blocks & 0xFF);
hdr[5 + i * 8 + 4] = (byte)((header.BlockDescriptors[i].BlockLength & 0xFF0000) >> 16);
hdr[6 + i * 8 + 4] = (byte)((header.BlockDescriptors[i].BlockLength & 0xFF00) >> 8);
hdr[7 + i * 8 + 4] = (byte)(header.BlockDescriptors[i].BlockLength & 0xFF);
}
}
return hdr;
}
public static byte[] EncodeMode6(DecodedMode mode, PeripheralDeviceTypes deviceType)
{
int modeSize = 0;
if(mode.Pages != null) foreach(ModePage page in mode.Pages) modeSize += page.PageResponse.Length;
byte[] hdr = EncodeModeHeader6(mode.Header, deviceType);
modeSize += hdr.Length;
byte[] md = new byte[modeSize];
Array.Copy(hdr, 0, md, 0, hdr.Length);
if(mode.Pages != null)
{
int offset = hdr.Length;
foreach(ModePage page in mode.Pages)
{
Array.Copy(page.PageResponse, 0, md, offset, page.PageResponse.Length);
offset += page.PageResponse.Length;
}
}
return md;
}
}
}
Reference in New Issue Copy Permalink