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

Move all localizable strings from Aaru.Decoders project to resources.

Browse Source
This commit is contained in:
Natalia Portillo
2022-11-27 13:33:47 +00:00
parent bc415e205f
commit d70fd34e2b
91 changed files with 34135 additions and 4541 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
SCSI/Modes/00_SFF.cs
View File

@@ -93,21 +93,21 @@ public static partial class Modes
ModePage_00_SFF page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Drive Operation Mode page:");
sb.AppendLine(Localization.SCSI_Drive_Operation_Mode_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.DVW)
sb.AppendLine("\tVerifying after writing is disabled");
sb.AppendLine("\t" + Localization.Verifying_after_writing_is_disabled);
if(page.DDE)
sb.AppendLine("\tDrive will abort when a writing error is detected");
sb.AppendLine("\t" + Localization.Drive_will_abort_when_a_writing_error_is_detected);
if(!page.SLM)
return sb.ToString();
sb.Append("\tDrive has two LUNs with rewritable being ");
sb.Append("\t" + Localization.Drive_has_two_LUNs_with_rewritable_being);
sb.AppendLine(page.SLR ? "LUN 1" : "LUN 0");
return sb.ToString();

40
SCSI/Modes/01.cs
View File

@@ -180,47 +180,51 @@ public static partial class Modes
ModePage_01 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Read-write error recovery page:");
sb.AppendLine(Localization.SCSI_Read_write_error_recovery_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.AWRE)
sb.AppendLine("\tAutomatic write reallocation is enabled");
sb.AppendLine("\t" + Localization.Automatic_write_reallocation_is_enabled);
if(page.ARRE)
sb.AppendLine("\tAutomatic read reallocation is enabled");
sb.AppendLine("\t" + Localization.Automatic_read_reallocation_is_enabled);
if(page.TB)
sb.AppendLine("\tData not recovered within limits shall be transferred back before a CHECK CONDITION");
sb.AppendLine("\t" + Localization.
Data_not_recovered_within_limits_shall_be_transferred_back_before_a_CHECK_CONDITION);
if(page.RC)
sb.AppendLine("\tDrive will transfer the entire requested length without delaying to perform error recovery");
sb.AppendLine("\t" + Localization.
Drive_will_transfer_the_entire_requested_length_without_delaying_to_perform_error_recovery);
if(page.EER)
sb.AppendLine("\tDrive will use the most expedient form of error recovery first");
sb.AppendLine("\t" + Localization.Drive_will_use_the_most_expedient_form_of_error_recovery_first);
if(page.PER)
sb.AppendLine("\tDrive shall report recovered errors");
sb.AppendLine("\t" + Localization.Drive_shall_report_recovered_errors);
if(page.DTE)
sb.AppendLine("\tTransfer will be terminated upon error detection");
sb.AppendLine("\t" + Localization.Transfer_will_be_terminated_upon_error_detection);
if(page.DCR)
sb.AppendLine("\tError correction is disabled");
sb.AppendLine("\t" + Localization.Error_correction_is_disabled);
if(page.ReadRetryCount > 0)
sb.AppendFormat("\tDrive will repeat read operations {0} times", page.ReadRetryCount).AppendLine();
if(page.WriteRetryCount > 0)
sb.AppendFormat("\tDrive will repeat write operations {0} times", page.WriteRetryCount).AppendLine();
if(page.RecoveryTimeLimit > 0)
sb.AppendFormat("\tDrive will employ a maximum of {0} ms to recover data", page.RecoveryTimeLimit).
sb.AppendFormat("\t" + Localization.Drive_will_repeat_read_operations_0_times, page.ReadRetryCount).
AppendLine();
if(page.WriteRetryCount > 0)
sb.AppendFormat("\t" + Localization.Drive_will_repeat_write_operations_0_times, page.WriteRetryCount).
AppendLine();
if(page.RecoveryTimeLimit > 0)
sb.AppendFormat("\t" + Localization.Drive_will_employ_a_maximum_of_0_ms_to_recover_data,
page.RecoveryTimeLimit).AppendLine();
if(page.LBPERE)
sb.AppendLine("Logical block provisioning error reporting is enabled");
sb.AppendLine(Localization.Logical_block_provisioning_error_reporting_is_enabled);
return sb.ToString();
}

47
SCSI/Modes/01_MMC.cs
View File

@@ -120,30 +120,34 @@ public static partial class Modes
ModePage_01_MMC page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Read error recovery page for MultiMedia Devices:");
sb.AppendLine(Localization.SCSI_Read_error_recovery_page_for_MultiMedia_Devices);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.ReadRetryCount > 0)
sb.AppendFormat("\tDrive will repeat read operations {0} times", page.ReadRetryCount).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_will_repeat_read_operations_0_times, page.ReadRetryCount).
AppendLine();
const string AllUsed = "\tAll available recovery procedures will be used.\n";
const string CIRCRetriesUsed = "\tOnly retries and CIRC are used.\n";
const string RetriesUsed = "\tOnly retries are used.\n";
const string RecoveredNotReported = "\tRecovered errors will not be reported.\n";
const string RecoveredReported = "\tRecovered errors will be reported.\n";
const string RecoveredAbort = "\tRecovered errors will be reported and aborted with CHECK CONDITION.\n";
const string UnrecECCAbort = "\tUnrecovered ECC errors will return CHECK CONDITION.";
const string UnrecCIRCAbort = "\tUnrecovered CIRC errors will return CHECK CONDITION.";
const string UnrecECCNotAbort = "\tUnrecovered ECC errors will not abort the transfer.";
const string UnrecCIRCNotAbort = "\tUnrecovered CIRC errors will not abort the transfer.";
string AllUsed = "\t" + Localization.All_available_recovery_procedures_will_be_used + "\n";
string CIRCRetriesUsed = "\t" + Localization.Only_retries_and_CIRC_are_used + "\n";
string RetriesUsed = "\t" + Localization.Only_retries_are_used + "\n";
string RecoveredNotReported = "\t" + Localization.Recovered_errors_will_not_be_reported + "\n";
string RecoveredReported = "\t" + Localization.Recovered_errors_will_be_reported + "\n";
const string UnrecECCAbortData =
"\tUnrecovered ECC errors will return CHECK CONDITION and the uncorrected data.";
string RecoveredAbort = "\t" + Localization.Recovered_errors_will_be_reported_and_aborted_with_CHECK_CONDITION +
"\n";
const string UnrecCIRCAbortData =
"\tUnrecovered CIRC errors will return CHECK CONDITION and the uncorrected data.";
string UnrecECCAbort = "\t" + Localization.Unrecovered_ECC_errors_will_return_CHECK_CONDITION;
string UnrecCIRCAbort = "\t" + Localization.Unrecovered_CIRC_errors_will_return_CHECK_CONDITION;
string UnrecECCNotAbort = "\t" + Localization.Unrecovered_ECC_errors_will_not_abort_the_transfer;
string UnrecCIRCNotAbort = "\t" + Localization.Unrecovered_CIRC_errors_will_not_abort_the_transfer;
string UnrecECCAbortData =
"\t" + Localization.Unrecovered_ECC_errors_will_return_CHECK_CONDITION_and_the_uncorrected_data;
string UnrecCIRCAbortData =
"\t" + Localization.Unrecovered_CIRC_errors_will_return_CHECK_CONDITION_and_the_uncorrected_data;
switch(page.Parameter)
{
@@ -216,17 +220,18 @@ public static partial class Modes
case 0x34: goto case 0x14;
case 0x35: goto case 0x15;
default:
sb.AppendFormat("Unknown recovery parameter 0x{0:X2}", page.Parameter).AppendLine();
sb.AppendFormat(Localization.Unknown_recovery_parameter_0, page.Parameter).AppendLine();
break;
}
if(page.WriteRetryCount > 0)
sb.AppendFormat("\tDrive will repeat write operations {0} times", page.WriteRetryCount).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_will_repeat_write_operations_0_times, page.WriteRetryCount).
AppendLine();
if(page.RecoveryTimeLimit > 0)
sb.AppendFormat("\tDrive will employ a maximum of {0} ms to recover data", page.RecoveryTimeLimit).
AppendLine();
sb.AppendFormat("\t" + Localization.Drive_will_employ_a_maximum_of_0_ms_to_recover_data,
page.RecoveryTimeLimit).AppendLine();
return sb.ToString();
}

45
SCSI/Modes/02.cs
View File

@@ -122,62 +122,69 @@ public static partial class Modes
ModePage_02 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Disconnect-Reconnect mode page:");
sb.AppendLine(Localization.SCSI_Disconnect_Reconnect_mode_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.BufferFullRatio > 0)
sb.AppendFormat("\t{0} ratio of buffer that shall be full prior to attempting a reselection",
sb.AppendFormat("\t" + Localization._0_ratio_of_buffer_that_shall_be_full_prior_to_attempting_a_reselection,
page.BufferFullRatio).AppendLine();
if(page.BufferEmptyRatio > 0)
sb.AppendFormat("\t{0} ratio of buffer that shall be empty prior to attempting a reselection",
page.BufferEmptyRatio).AppendLine();
sb.
AppendFormat("\t" + Localization._0_ratio_of_buffer_that_shall_be_empty_prior_to_attempting_a_reselection,
page.BufferEmptyRatio).AppendLine();
if(page.BusInactivityLimit > 0)
sb.AppendFormat("\t{0} µs maximum permitted to assert BSY without a REQ/ACK handshake",
sb.AppendFormat("\t" + Localization._0_µs_maximum_permitted_to_assert_BSY_without_a_REQ_ACK_handshake,
page.BusInactivityLimit * 100).AppendLine();
if(page.DisconnectTimeLimit > 0)
sb.AppendFormat("\t{0} µs maximum permitted wait after releasing the bus before attempting reselection",
page.DisconnectTimeLimit * 100).AppendLine();
sb.
AppendFormat("\t" + Localization._0_µs_maximum_permitted_wait_after_releasing_the_bus_before_attempting_reselection,
page.DisconnectTimeLimit * 100).AppendLine();
if(page.ConnectTimeLimit > 0)
sb.
AppendFormat("\t{0} µs allowed to use the bus before disconnecting, if granted the privilege and not restricted",
AppendFormat("\t" + Localization._0_µs_allowed_to_use_the_bus_before_disconnecting_if_granted_the_privilege_and_not_restricted,
page.ConnectTimeLimit * 100).AppendLine();
if(page.MaxBurstSize > 0)
sb.AppendFormat("\t{0} bytes maximum can be transferred before disconnecting", page.MaxBurstSize * 512).
AppendLine();
sb.AppendFormat("\t" + Localization._0_bytes_maximum_can_be_transferred_before_disconnecting,
page.MaxBurstSize * 512).AppendLine();
if(page.FirstBurstSize > 0)
sb.AppendFormat("\t{0} bytes maximum can be transferred for a command along with the disconnect command",
page.FirstBurstSize * 512).AppendLine();
sb.
AppendFormat("\t" + Localization._0_bytes_maximum_can_be_transferred_for_a_command_along_with_the_disconnect_command,
page.FirstBurstSize * 512).AppendLine();
if(page.DIMM)
sb.AppendLine("\tTarget shall not transfer data for a command during the same interconnect tenancy");
sb.AppendLine("\t" + Localization.
Target_shall_not_transfer_data_for_a_command_during_the_same_interconnect_tenancy);
if(page.EMDP)
sb.AppendLine("\tTarget is allowed to re-order the data transfer");
sb.AppendLine("\t" + Localization.Target_is_allowed_to_reorder_the_data_transfer);
switch(page.DTDC)
{
case 0:
sb.AppendLine("\tData transfer disconnect control is not used");
sb.AppendLine("\t" + Localization.Data_transfer_disconnect_control_is_not_used);
break;
case 1:
sb.AppendLine("\tAll data for a command shall be transferred within a single interconnect tenancy");
sb.AppendLine("\t" + Localization.
All_data_for_a_command_shall_be_transferred_within_a_single_interconnect_tenancy);
break;
case 3:
sb.AppendLine("\tAll data and the response for a command shall be transferred within a single interconnect tenancy");
sb.AppendLine("\t" + Localization.
All_data_and_the_response_for_a_command_shall_be_transferred_within_a_single_interconnect_tenancy);
break;
default:
sb.AppendFormat("\tReserved data transfer disconnect control value {0}", page.DTDC).AppendLine();
sb.AppendFormat("\t" + Localization.Reserved_data_transfer_disconnect_control_value_0, page.DTDC).
AppendLine();
break;
}

42
SCSI/Modes/03.cs
View File

@@ -121,46 +121,48 @@ public static partial class Modes
ModePage_03 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Format device page:");
sb.AppendLine(Localization.SCSI_Format_device_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
sb.
AppendFormat("\t{0} tracks per zone to use in dividing the capacity for the purpose of allocating alternate sectors",
AppendFormat("\t" + Localization._0_tracks_per_zone_to_use_in_dividing_the_capacity_for_the_purpose_of_allocating_alternate_sectors,
page.TracksPerZone).AppendLine();
sb.AppendFormat("\t{0} sectors per zone that shall be reserved for defect handling", page.AltSectorsPerZone).
AppendLine();
sb.AppendFormat("\t" + Localization._0_sectors_per_zone_that_shall_be_reserved_for_defect_handling,
page.AltSectorsPerZone).AppendLine();
sb.AppendFormat("\t{0} tracks per zone that shall be reserved for defect handling", page.AltTracksPerZone).
AppendLine();
sb.AppendFormat("\t" + Localization._0_tracks_per_zone_that_shall_be_reserved_for_defect_handling,
page.AltTracksPerZone).AppendLine();
sb.AppendFormat("\t{0} tracks per LUN that shall be reserved for defect handling", page.AltTracksPerLun).
AppendLine();
sb.AppendFormat("\t" + Localization._0_tracks_per_LUN_that_shall_be_reserved_for_defect_handling,
page.AltTracksPerLun).AppendLine();
sb.AppendFormat("\t{0} physical sectors per track", page.SectorsPerTrack).AppendLine();
sb.AppendFormat("\t{0} Bytes per physical sector", page.BytesPerSector).AppendLine();
sb.AppendFormat("\tTarget-dependent interleave value is {0}", page.Interleave).AppendLine();
sb.AppendFormat("\t" + Localization._0_physical_sectors_per_track, page.SectorsPerTrack).AppendLine();
sb.AppendFormat("\t" + Localization._0_Bytes_per_physical_sector, page.BytesPerSector).AppendLine();
sb.AppendFormat("\t" + Localization.Target_dependent_interleave_value_is_0, page.Interleave).AppendLine();
sb.AppendFormat("\t{0} sectors between last block of one track and first block of the next", page.TrackSkew).
AppendLine();
sb.AppendFormat("\t" + Localization._0_sectors_between_last_block_of_one_track_and_first_block_of_the_next,
page.TrackSkew).AppendLine();
sb.AppendFormat("\t{0} sectors between last block of a cylinder and first block of the next one",
sb.AppendFormat("\t" + Localization._0_sectors_between_last_block_of_a_cylinder_and_first_block_of_the_next_one,
page.CylinderSkew).AppendLine();
if(page.SSEC)
sb.AppendLine("\tDrive supports soft-sectoring format");
sb.AppendLine("\t" + Localization.Drive_supports_soft_sectoring_format);
if(page.HSEC)
sb.AppendLine("\tDrive supports hard-sectoring format");
sb.AppendLine("\t" + Localization.Drive_supports_hard_sectoring_format);
if(page.RMB)
sb.AppendLine("\tDrive media is removable");
sb.AppendLine("\t" + Localization.Drive_media_is_removable);
sb.AppendLine(page.SURF
? "\tSector addressing is progressively incremented in one surface before going to the next"
: "\tSector addressing is progressively incremented in one cylinder before going to the next");
? "\t" + Localization.
Sector_addressing_is_progressively_incremented_in_one_surface_before_going_to_the_next
: "\t" + Localization.
Sector_addressing_is_progressively_incremented_in_one_cylinder_before_going_to_the_next);
return sb.ToString();
}

28
SCSI/Modes/04.cs
View File

@@ -111,44 +111,46 @@ public static partial class Modes
ModePage_04 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Rigid disk drive geometry page:");
sb.AppendLine(Localization.SCSI_Rigid_disk_drive_geometry_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
sb.AppendFormat("\t{0} heads", page.Heads).AppendLine();
sb.AppendFormat("\t{0} cylinders", page.Cylinders).AppendLine();
sb.AppendFormat("\t" + Localization._0_heads, page.Heads).AppendLine();
sb.AppendFormat("\t" + Localization._0_cylinders, page.Cylinders).AppendLine();
if(page.WritePrecompCylinder < page.Cylinders)
sb.AppendFormat("\tWrite pre-compensation starts at cylinder {0}", page.WritePrecompCylinder).AppendLine();
sb.AppendFormat("\t" + Localization.Write_pre_compensation_starts_at_cylinder_0, page.WritePrecompCylinder).
AppendLine();
if(page.WriteReduceCylinder < page.Cylinders)
sb.AppendFormat("\tWrite current reduction starts at cylinder {0}", page.WriteReduceCylinder).AppendLine();
sb.AppendFormat("\t" + Localization.Write_current_reduction_starts_at_cylinder_0, page.WriteReduceCylinder).
AppendLine();
if(page.DriveStepRate > 0)
sb.AppendFormat("\tDrive steps in {0} ns", (uint)page.DriveStepRate * 100).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_steps_in_0_ns, (uint)page.DriveStepRate * 100).AppendLine();
sb.AppendFormat("\tHeads park in cylinder {0}", page.LandingCylinder).AppendLine();
sb.AppendFormat("\t" + Localization.Heads_park_in_cylinder_0, page.LandingCylinder).AppendLine();
if(page.MediumRotationRate > 0)
sb.AppendFormat("\tMedium rotates at {0} rpm", page.MediumRotationRate).AppendLine();
sb.AppendFormat("\t" + Localization.Medium_rotates_at_0_rpm, page.MediumRotationRate).AppendLine();
switch(page.RPL)
{
case 0:
sb.AppendLine("\tSpindle synchronization is disable or unsupported");
sb.AppendLine("\t" + Localization.Spindle_synchronization_is_disable_or_unsupported);
break;
case 1:
sb.AppendLine("\tTarget operates as a synchronized-spindle slave");
sb.AppendLine("\t" + Localization.Target_operates_as_a_synchronized_spindle_slave);
break;
case 2:
sb.AppendLine("\tTarget operates as a synchronized-spindle master");
sb.AppendLine("\t" + Localization.Target_operates_as_a_synchronized_spindle_master);
break;
case 3:
sb.AppendLine("\tTarget operates as a synchronized-spindle master control");
sb.AppendLine("\t" + Localization.Target_operates_as_a_synchronized_spindle_master_control);
break;
}

105
SCSI/Modes/05.cs
View File

@@ -157,89 +157,94 @@ public static partial class Modes
ModePage_05 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Flexible disk page:");
sb.AppendLine(Localization.SCSI_Flexible_disk_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
sb.AppendFormat("\tTransfer rate: {0} kbit/s", page.TransferRate).AppendLine();
sb.AppendFormat("\t{0} heads", page.Heads).AppendLine();
sb.AppendFormat("\t{0} cylinders", page.Cylinders).AppendLine();
sb.AppendFormat("\t{0} sectors per track", page.SectorsPerTrack).AppendLine();
sb.AppendFormat("\t{0} bytes per sector", page.BytesPerSector).AppendLine();
sb.AppendFormat("\t" + Localization.Transfer_rate_0_kbits, page.TransferRate).AppendLine();
sb.AppendFormat("\t" + Localization._0_heads, page.Heads).AppendLine();
sb.AppendFormat("\t" + Localization._0_cylinders, page.Cylinders).AppendLine();
sb.AppendFormat("\t" + Localization._0_sectors_per_track, page.SectorsPerTrack).AppendLine();
sb.AppendFormat("\t" + Localization._0_bytes_per_sector, page.BytesPerSector).AppendLine();
if(page.WritePrecompCylinder < page.Cylinders)
sb.AppendFormat("\tWrite pre-compensation starts at cylinder {0}", page.WritePrecompCylinder).AppendLine();
sb.AppendFormat("\t" + Localization.Write_pre_compensation_starts_at_cylinder_0, page.WritePrecompCylinder).
AppendLine();
if(page.WriteReduceCylinder < page.Cylinders)
sb.AppendFormat("\tWrite current reduction starts at cylinder {0}", page.WriteReduceCylinder).AppendLine();
sb.AppendFormat("\t" + Localization.Write_current_reduction_starts_at_cylinder_0, page.WriteReduceCylinder).
AppendLine();
if(page.DriveStepRate > 0)
sb.AppendFormat("\tDrive steps in {0} μs", (uint)page.DriveStepRate * 100).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_steps_in_0_μs, (uint)page.DriveStepRate * 100).AppendLine();
if(page.DriveStepPulse > 0)
sb.AppendFormat("\tEach step pulse is {0} ms", page.DriveStepPulse).AppendLine();
sb.AppendFormat("\t" + Localization.Each_step_pulse_is_0_ms, page.DriveStepPulse).AppendLine();
if(page.HeadSettleDelay > 0)
sb.AppendFormat("\tHeads settles in {0} μs", (uint)page.HeadSettleDelay * 100).AppendLine();
sb.AppendFormat("\t" + Localization.Heads_settles_in_0_μs, (uint)page.HeadSettleDelay * 100).AppendLine();
if(!page.TRDY)
sb.
AppendFormat("\tTarget shall wait {0} seconds before attempting to access the medium after motor on is asserted",
AppendFormat("\t" + Localization.Target_shall_wait_0_seconds_before_attempting_to_access_the_medium_after_motor_on_is_asserted,
(double)page.MotorOnDelay * 10).AppendLine();
else
sb.
AppendFormat("\tTarget shall wait {0} seconds after drive is ready before aborting medium access attempts",
AppendFormat("\t" + Localization.Target_shall_wait_0_seconds_after_drive_is_ready_before_aborting_medium_access_attempts,
(double)page.MotorOnDelay * 10).AppendLine();
if(page.MotorOffDelay != 0xFF)
sb.AppendFormat("\tTarget shall wait {0} seconds before releasing the motor on signal after becoming idle",
(double)page.MotorOffDelay * 10).AppendLine();
sb.
AppendFormat("\t" + Localization.Target_shall_wait_0_seconds_before_releasing_the_motor_on_signal_after_becoming_idle,
(double)page.MotorOffDelay * 10).AppendLine();
else
sb.AppendLine("\tTarget shall never release the motor on signal");
sb.AppendLine("\t" + Localization.Target_shall_never_release_the_motor_on_signal);
if(page.TRDY)
sb.AppendLine("\tThere is a drive ready signal");
sb.AppendLine("\t" + Localization.There_is_a_drive_ready_signal);
if(page.SSN)
sb.AppendLine("\tSectors start at 1");
sb.AppendLine("\t" + Localization.Sectors_start_at_1);
if(page.MO)
sb.AppendLine("\tThe motor on signal shall remain released");
sb.AppendLine("\t" + Localization.The_motor_on_signal_shall_remain_released);
sb.AppendFormat("\tDrive needs to do {0} step pulses per cylinder", page.SPC + 1).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_needs_to_do_0_step_pulses_per_cylinder, page.SPC + 1).AppendLine();
if(page.WriteCompensation > 0)
sb.AppendFormat("\tWrite pre-compensation is {0}", page.WriteCompensation).AppendLine();
sb.AppendFormat("\t" + Localization.Write_pre_compensation_is_0, page.WriteCompensation).AppendLine();
if(page.HeadLoadDelay > 0)
sb.AppendFormat("\tHead takes {0} ms to load", page.HeadLoadDelay).AppendLine();
sb.AppendFormat("\t" + Localization.Head_takes_0_ms_to_load, page.HeadLoadDelay).AppendLine();
if(page.HeadUnloadDelay > 0)
sb.AppendFormat("\tHead takes {0} ms to unload", page.HeadUnloadDelay).AppendLine();
sb.AppendFormat("\t" + Localization.Head_takes_0_ms_to_unload, page.HeadUnloadDelay).AppendLine();
if(page.MediumRotationRate > 0)
sb.AppendFormat("\tMedium rotates at {0} rpm", page.MediumRotationRate).AppendLine();
sb.AppendFormat("\t" + Localization.Medium_rotates_at_0_rpm, page.MediumRotationRate).AppendLine();
switch(page.Pin34 & 0x07)
{
case 0:
sb.AppendLine("\tPin 34 is unconnected");
sb.AppendLine("\t" + Localization.Pin_34_is_unconnected);
break;
case 1:
sb.Append("\tPin 34 indicates drive is ready when active ");
sb.Append((page.Pin34 & 0x08) == 0x08 ? "high" : "low");
sb.Append("\t" + ((page.Pin34 & 0x08) == 0x08
? Localization.Pin_34_indicates_drive_is_ready_when_active_high
: Localization.Pin_34_indicates_drive_is_ready_when_active_low));
break;
case 2:
sb.Append("\tPin 34 indicates disk has changed when active ");
sb.Append((page.Pin34 & 0x08) == 0x08 ? "high" : "low");
sb.Append("\t" + ((page.Pin34 & 0x08) == 0x08
? Localization.Pin_34_indicates_disk_has_changed_when_active_high
: Localization.Pin_34_indicates_disk_has_changed_when_active_low));
break;
default:
sb.AppendFormat("\tPin 34 indicates unknown function {0} when active ", page.Pin34 & 0x07);
sb.Append((page.Pin34 & 0x08) == 0x08 ? "high" : "low");
sb.AppendFormat("\t" + ((page.Pin34 & 0x08) == 0x08 ? Localization.Pin_34_indicates_unknown_function_0_when_active_high : Localization.Pin_34_indicates_unknown_function_0_when_active_low),
page.Pin34 & 0x07);
break;
}
@@ -247,27 +252,28 @@ public static partial class Modes
switch(page.Pin4 & 0x07)
{
case 0:
sb.AppendLine("\tPin 4 is unconnected");
sb.AppendLine("\t" + Localization.Pin_4_is_unconnected);
break;
case 1:
sb.Append("\tPin 4 indicates drive is in use when active ");
sb.Append((page.Pin4 & 0x08) == 0x08 ? "high" : "low");
sb.Append("\t" + ((page.Pin4 & 0x08) == 0x08
? Localization.Pin_4_indicates_drive_is_in_use_when_active_high
: Localization.Pin_4_indicates_drive_is_in_use_when_active_low));
break;
case 2:
sb.Append("\tPin 4 indicates eject when active ");
sb.Append((page.Pin4 & 0x08) == 0x08 ? "high" : "low");
sb.Append("\t" + ((page.Pin4 & 0x08) == 0x08 ? Localization.Pin_4_indicates_eject_when_active_high
: Localization.Pin_4_indicates_eject_when_active_low));
break;
case 3:
sb.Append("\tPin 4 indicates head load when active ");
sb.Append((page.Pin4 & 0x08) == 0x08 ? "high" : "low");
sb.Append("\t" + ((page.Pin4 & 0x08) == 0x08 ? Localization.Pin_4_indicates_head_load_when_active_high
: Localization.Pin_4_indicates_head_load_when_active_low));
break;
default:
sb.AppendFormat("\tPin 4 indicates unknown function {0} when active ", page.Pin4 & 0x07);
sb.Append((page.Pin4 & 0x08) == 0x08 ? "high" : "low");
sb.AppendFormat("\t" + ((page.Pin4 & 0x08) == 0x08 ? Localization.Pin_4_indicates_unknown_function_0_when_active_high : Localization.Pin_4_indicates_unknown_function_0_when_active_low),
page.Pin4 & 0x07);
break;
}
@@ -275,12 +281,12 @@ public static partial class Modes
switch(page.Pin2 & 0x07)
{
case 0:
sb.AppendLine("\tPin 2 is unconnected");
sb.AppendLine("\t" + Localization.Pin_2_is_unconnected);
break;
default:
sb.AppendFormat("\tPin 2 indicates unknown function {0} when active ", page.Pin2 & 0x07);
sb.Append((page.Pin2 & 0x08) == 0x08 ? "high" : "low");
sb.AppendFormat("\t" + ((page.Pin2 & 0x08) == 0x08 ? Localization.Pin_2_indicates_unknown_function_0_when_active_high : Localization.Pin_2_indicates_unknown_function_0_when_active_low),
page.Pin2 & 0x07);
break;
}
@@ -288,17 +294,18 @@ public static partial class Modes
switch(page.Pin1 & 0x07)
{
case 0:
sb.AppendLine("\tPin 1 is unconnected");
sb.AppendLine("\t" + Localization.Pin_1_is_unconnected);
break;
case 1:
sb.Append("\tPin 1 indicates disk change reset when active ");
sb.Append((page.Pin1 & 0x08) == 0x08 ? "high" : "low");
sb.Append("\t" + ((page.Pin1 & 0x08) == 0x08
? Localization.Pin_1_indicates_disk_change_reset_when_active_high
: Localization.Pin_1_indicates_disk_change_reset_when_active_low));
break;
default:
sb.AppendFormat("\tPin 1 indicates unknown function {0} when active ", page.Pin1 & 0x07);
sb.Append((page.Pin1 & 0x08) == 0x08 ? "high" : "low");
sb.AppendFormat("\t" + ((page.Pin1 & 0x08) == 0x08 ? Localization.Pin_1_indicates_unknown_function_0_when_active_high : Localization.Pin_1_indicates_unknown_function_0_when_active_low),
page.Pin1 & 0x07);
break;
}

6
SCSI/Modes/06.cs
View File

@@ -82,13 +82,13 @@ public static partial class Modes
ModePage_06 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI optical memory:");
sb.AppendLine(Localization.SCSI_optical_memory);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.RUBR)
sb.AppendLine("\tOn reading an updated block drive will return RECOVERED ERROR");
sb.AppendLine("\t" + Localization.On_reading_an_updated_block_drive_will_return_RECOVERED_ERROR);
return sb.ToString();
}

19
SCSI/Modes/07.cs
View File

@@ -101,29 +101,30 @@ public static partial class Modes
ModePage_07 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Verify error recovery page:");
sb.AppendLine(Localization.SCSI_Verify_error_recovery_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.EER)
sb.AppendLine("\tDrive will use the most expedient form of error recovery first");
sb.AppendLine("\t" + Localization.Drive_will_use_the_most_expedient_form_of_error_recovery_first);
if(page.PER)
sb.AppendLine("\tDrive shall report recovered errors");
sb.AppendLine("\t" + Localization.Drive_shall_report_recovered_errors);
if(page.DTE)
sb.AppendLine("\tTransfer will be terminated upon error detection");
sb.AppendLine("\t" + Localization.Transfer_will_be_terminated_upon_error_detection);
if(page.DCR)
sb.AppendLine("\tError correction is disabled");
sb.AppendLine("\t" + Localization.Error_correction_is_disabled);
if(page.VerifyRetryCount > 0)
sb.AppendFormat("\tDrive will repeat verify operations {0} times", page.VerifyRetryCount).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_will_repeat_verify_operations_0_times, page.VerifyRetryCount).
AppendLine();
if(page.RecoveryTimeLimit > 0)
sb.AppendFormat("\tDrive will employ a maximum of {0} ms to recover data", page.RecoveryTimeLimit).
AppendLine();
sb.AppendFormat("\t" + Localization.Drive_will_employ_a_maximum_of_0_ms_to_recover_data,
page.RecoveryTimeLimit).AppendLine();
return sb.ToString();
}

40
SCSI/Modes/07_MMC.cs
View File

@@ -85,30 +85,34 @@ public static partial class Modes
ModePage_07_MMC page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Verify error recovery page for MultiMedia Devices:");
sb.AppendLine(Localization.SCSI_Verify_error_recovery_page_for_MultiMedia_Devices);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.VerifyRetryCount > 0)
sb.AppendFormat("\tDrive will repeat verify operations {0} times", page.VerifyRetryCount).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_will_repeat_verify_operations_0_times, page.VerifyRetryCount).
AppendLine();
const string AllUsed = "\tAll available recovery procedures will be used.\n";
const string CIRCRetriesUsed = "\tOnly retries and CIRC are used.\n";
const string RetriesUsed = "\tOnly retries are used.\n";
const string RecoveredNotReported = "\tRecovered errors will not be reported.\n";
const string RecoveredReported = "\tRecovered errors will be reported.\n";
const string RecoveredAbort = "\tRecovered errors will be reported and aborted with CHECK CONDITION.\n";
const string UnrecECCAbort = "\tUnrecovered ECC errors will return CHECK CONDITION.";
const string UnrecCIRCAbort = "\tUnrecovered CIRC errors will return CHECK CONDITION.";
const string UnrecECCNotAbort = "\tUnrecovered ECC errors will not abort the transfer.";
const string UnrecCIRCNotAbort = "\tUnrecovered CIRC errors will not abort the transfer.";
string AllUsed = "\t" + Localization.All_available_recovery_procedures_will_be_used + "\n";
string CIRCRetriesUsed = "\t" + Localization.Only_retries_and_CIRC_are_used + "\n";
string RetriesUsed = "\t" + Localization.Only_retries_are_used + "\n";
string RecoveredNotReported = "\t" + Localization.Recovered_errors_will_not_be_reported + "\n";
string RecoveredReported = "\t" + Localization.Recovered_errors_will_be_reported + "\n";
const string UnrecECCAbortData =
"\tUnrecovered ECC errors will return CHECK CONDITION and the uncorrected data.";
string RecoveredAbort = "\t" + Localization.Recovered_errors_will_be_reported_and_aborted_with_CHECK_CONDITION +
"\n";
const string UnrecCIRCAbortData =
"\tUnrecovered CIRC errors will return CHECK CONDITION and the uncorrected data.";
string UnrecECCAbort = "\t" + Localization.Unrecovered_ECC_errors_will_return_CHECK_CONDITION;
string UnrecCIRCAbort = "\t" + Localization.Unrecovered_CIRC_errors_will_return_CHECK_CONDITION;
string UnrecECCNotAbort = "\t" + Localization.Unrecovered_ECC_errors_will_not_abort_the_transfer;
string UnrecCIRCNotAbort = "\t" + Localization.Unrecovered_CIRC_errors_will_not_abort_the_transfer;
string UnrecECCAbortData =
"\t" + Localization.Unrecovered_ECC_errors_will_return_CHECK_CONDITION_and_the_uncorrected_data;
string UnrecCIRCAbortData =
"\t" + Localization.Unrecovered_CIRC_errors_will_return_CHECK_CONDITION_and_the_uncorrected_data;
switch(page.Parameter)
{
@@ -181,7 +185,7 @@ public static partial class Modes
case 0x34: goto case 0x14;
case 0x35: goto case 0x15;
default:
sb.AppendFormat("Unknown recovery parameter 0x{0:X2}", page.Parameter).AppendLine();
sb.AppendFormat(Localization.Unknown_recovery_parameter_0, page.Parameter).AppendLine();
break;
}

77
SCSI/Modes/08.cs
View File

@@ -151,34 +151,36 @@ public static partial class Modes
ModePage_08 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Caching mode page:");
sb.AppendLine(Localization.SCSI_Caching_mode_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.RCD)
sb.AppendLine("\tRead-cache is enabled");
sb.AppendLine("\t" + Localization.Read_cache_is_enabled);
if(page.WCE)
sb.AppendLine("\tWrite-cache is enabled");
sb.AppendLine("\t" + Localization.Write_cache_is_enabled);
switch(page.DemandReadRetentionPrio)
{
case 0:
sb.AppendLine("\tDrive does not distinguish between cached read data");
sb.AppendLine("\t" + Localization.Drive_does_not_distinguish_between_cached_read_data);
break;
case 1:
sb.AppendLine("\tData put by READ commands should be evicted from cache sooner than data put in read cache by other means");
sb.AppendLine("\t" + Localization.
Data_put_by_READ_commands_should_be_evicted_from_cache_sooner_than_data_put_in_read_cache_by_other_means);
break;
case 0xF:
sb.AppendLine("\tData put by READ commands should not be evicted if there is data cached by other means that can be evicted");
sb.AppendLine("\t" + Localization.
Data_put_by_READ_commands_should_not_be_evicted_if_there_is_data_cached_by_other_means_that_can_be_evicted);
break;
default:
sb.AppendFormat("\tUnknown demand read retention priority value {0}", page.DemandReadRetentionPrio).
AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_demand_read_retention_priority_value_0,
page.DemandReadRetentionPrio).AppendLine();
break;
}
@@ -186,89 +188,96 @@ public static partial class Modes
switch(page.WriteRetentionPriority)
{
case 0:
sb.AppendLine("\tDrive does not distinguish between cached write data");
sb.AppendLine("\t" + Localization.Drive_does_not_distinguish_between_cached_write_data);
break;
case 1:
sb.AppendLine("\tData put by WRITE commands should be evicted from cache sooner than data put in write cache by other means");
sb.AppendLine("\t" + Localization.
Data_put_by_WRITE_commands_should_be_evicted_from_cache_sooner_than_data_put_in_write_cache_by_other_means);
break;
case 0xF:
sb.AppendLine("\tData put by WRITE commands should not be evicted if there is data cached by other means that can be evicted");
sb.AppendLine("\t" + Localization.
Data_put_by_WRITE_commands_should_not_be_evicted_if_there_is_data_cached_by_other_means_that_can_be_evicted);
break;
default:
sb.AppendFormat("\tUnknown demand write retention priority value {0}", page.DemandReadRetentionPrio).
AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_demand_write_retention_priority_value_0,
page.DemandReadRetentionPrio).AppendLine();
break;
}
if(page.DRA)
sb.AppendLine("\tRead-ahead is disabled");
sb.AppendLine("\t" + Localization.Read_ahead_is_disabled);
else
{
if(page.MF)
sb.AppendLine("\tPre-fetch values indicate a block multiplier");
sb.AppendLine("\t" + Localization.Pre_fetch_values_indicate_a_block_multiplier);
if(page.DisablePreFetch == 0)
sb.AppendLine("\tNo pre-fetch will be done");
sb.AppendLine("\t" + Localization.No_pre_fetch_will_be_done);
else
{
sb.AppendFormat("\tPre-fetch will be done for READ commands of {0} blocks or less",
sb.AppendFormat("\t" + Localization.Pre_fetch_will_be_done_for_READ_commands_of_0_blocks_or_less,
page.DisablePreFetch).AppendLine();
if(page.MinimumPreFetch > 0)
sb.AppendFormat("At least {0} blocks will be always pre-fetched", page.MinimumPreFetch).
sb.AppendFormat(Localization.At_least_0_blocks_will_be_always_pre_fetched, page.MinimumPreFetch).
AppendLine();
if(page.MaximumPreFetch > 0)
sb.AppendFormat("\tA maximum of {0} blocks will be pre-fetched", page.MaximumPreFetch).AppendLine();
sb.AppendFormat("\t" + Localization.A_maximum_of_0_blocks_will_be_pre_fetched,
page.MaximumPreFetch).AppendLine();
if(page.MaximumPreFetchCeiling > 0)
sb.
AppendFormat("\tA maximum of {0} blocks will be pre-fetched even if it is commanded to pre-fetch more",
AppendFormat("\t" + Localization.A_maximum_of_0_blocks_will_be_pre_fetched_even_if_it_is_commanded_to_pre_fetch_more,
page.MaximumPreFetchCeiling).AppendLine();
if(page.IC)
sb.AppendLine("\tDevice should use number of cache segments or cache segment size for caching");
sb.AppendLine("\t" + Localization.
Device_should_use_number_of_cache_segments_or_cache_segment_size_for_caching);
if(page.ABPF)
sb.AppendLine("\tPre-fetch should be aborted upon receiving a new command");
sb.AppendLine("\t" + Localization.Pre_fetch_should_be_aborted_upon_receiving_a_new_command);
if(page.CAP)
sb.AppendLine("\tCaching analysis is permitted");
sb.AppendLine("\t" + Localization.Caching_analysis_is_permitted);
if(page.Disc)
sb.AppendLine("\tPre-fetch can continue across discontinuities (such as cylinders or tracks)");
sb.AppendLine("\t" + Localization.
Pre_fetch_can_continue_across_discontinuities_such_as_cylinders_or_tracks);
}
}
if(page.FSW)
sb.AppendLine("\tDrive should not reorder the sequence of write commands to be faster");
sb.AppendLine("\t" + Localization.Drive_should_not_reorder_the_sequence_of_write_commands_to_be_faster);
if(page.Size)
{
if(page.CacheSegmentSize > 0)
if(page.LBCSS)
sb.AppendFormat("\tDrive cache segments should be {0} blocks long", page.CacheSegmentSize).
AppendLine();
sb.AppendFormat("\t" + Localization.Drive_cache_segments_should_be_0_blocks_long,
page.CacheSegmentSize).AppendLine();
else
sb.AppendFormat("\tDrive cache segments should be {0} bytes long", page.CacheSegmentSize).
AppendLine();
sb.AppendFormat("\t" + Localization.Drive_cache_segments_should_be_0_bytes_long,
page.CacheSegmentSize).AppendLine();
}
else
{
if(page.CacheSegments > 0)
sb.AppendFormat("\tDrive should have {0} cache segments", page.CacheSegments).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_should_have_0_cache_segments, page.CacheSegments).
AppendLine();
}
if(page.NonCacheSegmentSize > 0)
sb.AppendFormat("\tDrive shall allocate {0} bytes to buffer even when all cached data cannot be evicted",
page.NonCacheSegmentSize).AppendLine();
sb.
AppendFormat("\t" + Localization.Drive_shall_allocate_0_bytes_to_buffer_even_when_all_cached_data_cannot_be_evicted,
page.NonCacheSegmentSize).AppendLine();
if(page.NV_DIS)
sb.AppendLine("\tNon-Volatile cache is disabled");
sb.AppendLine("\t" + Localization.Non_Volatile_cache_is_disabled);
return sb.ToString();
}

126
SCSI/Modes/0A.cs
View File

@@ -183,77 +183,83 @@ public static partial class Modes
ModePage_0A page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Control mode page:");
sb.AppendLine(Localization.SCSI_Control_mode_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.RLEC)
sb.AppendLine("\tIf set, target shall report log exception conditions");
sb.AppendLine("\t" + Localization.If_set_target_shall_report_log_exception_conditions);
if(page.DQue)
sb.AppendLine("\tTagged queuing is disabled");
sb.AppendLine("\t" + Localization.Tagged_queuing_is_disabled);
if(page.EECA)
sb.AppendLine("\tExtended Contingent Allegiance is enabled");
sb.AppendLine("\t" + Localization.Extended_Contingent_Allegiance_is_enabled);
if(page.RAENP)
sb.AppendLine("\tTarget may issue an asynchronous event notification upon completing its initialization");
sb.AppendLine("\t" + Localization.
Target_may_issue_an_asynchronous_event_notification_upon_completing_its_initialization);
if(page.UAAENP)
sb.AppendLine("\tTarget may issue an asynchronous event notification instead of a unit attention condition");
sb.AppendLine("\t" + Localization.
Target_may_issue_an_asynchronous_event_notification_instead_of_a_unit_attention_condition);
if(page.EAENP)
sb.AppendLine("\tTarget may issue an asynchronous event notification instead of a deferred error");
sb.AppendLine("\t" + Localization.
Target_may_issue_an_asynchronous_event_notification_instead_of_a_deferred_error);
if(page.GLTSD)
sb.AppendLine("\tGlobal logging target save disabled");
sb.AppendLine("\t" + Localization.Global_logging_target_save_disabled);
if(page.RAC)
sb.AppendLine("\tCHECK CONDITION should be reported rather than a long busy condition");
sb.AppendLine("\t" + Localization.CHECK_CONDITION_should_be_reported_rather_than_a_long_busy_condition);
if(page.SWP)
sb.AppendLine("\tSoftware write protect is active");
sb.AppendLine("\t" + Localization.Software_write_protect_is_active);
if(page.TAS)
sb.AppendLine("\tTasks aborted by other initiator's actions should be terminated with TASK ABORTED");
sb.AppendLine("\t" + Localization.
Tasks_aborted_by_other_initiator_s_actions_should_be_terminated_with_TASK_ABORTED);
if(page.TMF_ONLY)
sb.AppendLine("\tAll tasks received in nexus with ACA ACTIVE is set and an ACA condition is established shall terminate");
sb.AppendLine("\t" + Localization.
All_tasks_received_in_nexus_with_ACA_ACTIVE_is_set_and_an_ACA_condition_is_established_shall_terminate);
if(page.D_SENSE)
sb.AppendLine("\tDevice shall return descriptor format sense data when returning sense data in the same transactions as a CHECK CONDITION");
sb.AppendLine("\t" + Localization.
Device_shall_return_descriptor_format_sense_data_when_returning_sense_data_in_the_same_transactions_as_a_CHECK_CONDITION);
if(page.ATO)
sb.AppendLine("\tLOGICAL BLOCK APPLICATION TAG should not be modified");
sb.AppendLine("\t" + Localization.LOGICAL_BLOCK_APPLICATION_TAG_should_not_be_modified);
if(page.DPICZ)
sb.AppendLine("\tProtector information checking is disabled");
sb.AppendLine("\t" + Localization.Protector_information_checking_is_disabled);
if(page.NUAR)
sb.AppendLine("\tNo unit attention on release");
sb.AppendLine("\t" + Localization.No_unit_attention_on_release);
if(page.ATMPE)
sb.AppendLine("\tApplication Tag mode page is enabled");
sb.AppendLine("\t" + Localization.Application_Tag_mode_page_is_enabled);
if(page.RWWP)
sb.AppendLine("\tAbort any write command without protection information");
sb.AppendLine("\t" + Localization.Abort_any_write_command_without_protection_information);
if(page.SBLP)
sb.AppendLine("\tSupports block lengths and protection information");
sb.AppendLine("\t" + Localization.Supports_block_lengths_and_protection_information);
switch(page.TST)
{
case 0:
sb.AppendLine("\tThe logical unit maintains one task set for all nexuses");
sb.AppendLine("\t" + Localization.The_logical_unit_maintains_one_task_set_for_all_nexuses);
break;
case 1:
sb.AppendLine("\tThe logical unit maintains separate task sets for each nexus");
sb.AppendLine("\t" + Localization.The_logical_unit_maintains_separate_task_sets_for_each_nexus);
break;
default:
sb.AppendFormat("\tUnknown Task set type {0}", page.TST).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_Task_set_type_0, page.TST).AppendLine();
break;
}
@@ -261,15 +267,16 @@ public static partial class Modes
switch(page.QueueAlgorithm)
{
case 0:
sb.AppendLine("\tCommands should be sent strictly ordered");
sb.AppendLine("\t" + Localization.Commands_should_be_sent_strictly_ordered);
break;
case 1:
sb.AppendLine("\tCommands can be reordered in any manner");
sb.AppendLine("\t" + Localization.Commands_can_be_reordered_in_any_manner);
break;
default:
sb.AppendFormat("\tUnknown Queue Algorithm Modifier {0}", page.QueueAlgorithm).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_Queue_Algorithm_Modifier_0, page.QueueAlgorithm).
AppendLine();
break;
}
@@ -277,19 +284,22 @@ public static partial class Modes
switch(page.QErr)
{
case 0:
sb.AppendLine("\tIf ACA is established, the task set commands shall resume after it is cleared, otherwise they shall terminate with CHECK CONDITION");
sb.AppendLine("\t" + Localization.
If_ACA_is_established_the_task_set_commands_shall_resume_after_it_is_cleared_otherwise_they_shall_terminate_with_CHECK_CONDITION);
break;
case 1:
sb.AppendLine("\tAll the affected commands in the task set shall be aborted when CHECK CONDITION is returned");
sb.AppendLine("\t" + Localization.
All_the_affected_commands_in_the_task_set_shall_be_aborted_when_CHECK_CONDITION_is_returned);
break;
case 3:
sb.AppendLine("\tAffected commands in the task set belonging with the CHECK CONDITION nexus shall be aborted");
sb.AppendLine("\t" + Localization.
Affected_commands_in_the_task_set_belonging_with_the_CHECK_CONDITION_nexus_shall_be_aborted);
break;
default:
sb.AppendLine("\tReserved QErr value 2 is set");
sb.AppendLine("\t" + Localization.Reserved_QErr_value_2_is_set);
break;
}
@@ -297,19 +307,21 @@ public static partial class Modes
switch(page.UA_INTLCK_CTRL)
{
case 0:
sb.AppendLine("\tLUN shall clear unit attention condition reported in the same nexus");
sb.AppendLine("\t" + Localization.LUN_shall_clear_unit_attention_condition_reported_in_the_same_nexus);
break;
case 2:
sb.AppendLine("\tLUN shall not clear unit attention condition reported in the same nexus");
sb.AppendLine("\t" + Localization.
LUN_shall_not_clear_unit_attention_condition_reported_in_the_same_nexus);
break;
case 3:
sb.AppendLine("\tLUN shall not clear unit attention condition reported in the same nexus and shall establish a unit attention condition for the initiator");
sb.AppendLine("\t" + Localization.
LUN_shall_not_clear_unit_attention_condition_reported_in_the_same_nexus_and_shall_establish_a_unit_attention_condition_for_the_initiator);
break;
default:
sb.AppendLine("\tReserved UA_INTLCK_CTRL value 1 is set");
sb.AppendLine("\t" + Localization.Reserved_UA_INTLCK_CTRL_value_1_is_set);
break;
}
@@ -317,36 +329,39 @@ public static partial class Modes
switch(page.AutoloadMode)
{
case 0:
sb.AppendLine("\tOn medium insertion, it shall be loaded for full access");
sb.AppendLine("\t" + Localization.On_medium_insertion_it_shall_be_loaded_for_full_access);
break;
case 1:
sb.AppendLine("\tOn medium insertion, it shall be loaded for auxiliary memory access only");
sb.AppendLine("\t" + Localization.
On_medium_insertion_it_shall_be_loaded_for_auxiliary_memory_access_only);
break;
case 2:
sb.AppendLine("\tOn medium insertion, it shall not be loaded");
sb.AppendLine("\t" + Localization.On_medium_insertion_it_shall_not_be_loaded);
break;
default:
sb.AppendFormat("\tReserved autoload mode {0} set", page.AutoloadMode).AppendLine();
sb.AppendFormat("\t" + Localization.Reserved_autoload_mode_0_set, page.AutoloadMode).AppendLine();
break;
}
if(page.ReadyAENHoldOffPeriod > 0)
sb.AppendFormat("\t{0} ms before attempting asynchronous event notifications after initialization",
page.ReadyAENHoldOffPeriod).AppendLine();
sb.
AppendFormat("\t" + Localization._0_ms_before_attempting_asynchronous_event_notifications_after_initialization,
page.ReadyAENHoldOffPeriod).AppendLine();
if(page.BusyTimeoutPeriod > 0)
if(page.BusyTimeoutPeriod == 0xFFFF)
sb.AppendLine("\tThere is no limit on the maximum time that is allowed to remain busy");
sb.AppendLine("\t" + Localization.There_is_no_limit_on_the_maximum_time_that_is_allowed_to_remain_busy);
else
sb.AppendFormat("\tA maximum of {0} ms are allowed to remain busy", page.BusyTimeoutPeriod * 100).
AppendLine();
sb.AppendFormat("\t" + Localization.A_maximum_of_0_ms_are_allowed_to_remain_busy,
page.BusyTimeoutPeriod * 100).AppendLine();
if(page.ExtendedSelfTestCompletionTime > 0)
sb.AppendFormat("\t{0} seconds to complete extended self-test", page.ExtendedSelfTestCompletionTime);
sb.AppendFormat("\t" + Localization._0_seconds_to_complete_extended_self_test,
page.ExtendedSelfTestCompletionTime);
return sb.ToString();
}
@@ -414,31 +429,32 @@ public static partial class Modes
ModePage_0A_S01 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Control extension page:");
sb.AppendLine(Localization.SCSI_Control_extension_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.TCMOS)
{
sb.Append("\tTimestamp can be initialized by methods outside of the SCSI standards");
if(page.SCSIP)
sb.Append(", but SCSI's SET TIMESTAMP shall take precedence over them");
sb.AppendLine();
sb.AppendLine("\t" + Localization.
S01_Timestamp_can_be_initialized_by_methods_outside_of_the_SCSI_standards_but_SCSI_SET_TIMESTAMP_shall_take_precedence_over_them);
else
sb.AppendLine("\t" + Localization.
Timestamp_can_be_initialized_by_methods_outside_of_the_SCSI_standards);
}
if(page.IALUAE)
sb.AppendLine("\tImplicit Asymmetric Logical Unit Access is enabled");
sb.AppendLine("\t" + Localization.Implicit_Asymmetric_Logical_Unit_Access_is_enabled);
sb.AppendFormat("\tInitial priority is {0}", page.InitialPriority).AppendLine();
sb.AppendFormat("\t" + Localization.Initial_priority_is_0, page.InitialPriority).AppendLine();
if(page.DLC)
sb.AppendLine("\tDevice will not degrade performance to extend its life");
sb.AppendLine("\t" + Localization.Device_will_not_degrade_performance_to_extend_its_life);
if(page.MaximumSenseLength > 0)
sb.AppendFormat("\tMaximum sense data would be {0} bytes", page.MaximumSenseLength).AppendLine();
sb.AppendFormat("\t" + Localization.Maximum_sense_data_would_be_0_bytes, page.MaximumSenseLength).
AppendLine();
return sb.ToString();
}

15
SCSI/Modes/0B.cs
View File

@@ -87,23 +87,26 @@ public static partial class Modes
ModePage_0B page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Medium types supported page:");
sb.AppendLine(Localization.SCSI_Medium_types_supported_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.MediumType1 != MediumTypes.Default)
sb.AppendFormat("Supported medium type one: {0}", GetMediumTypeDescription(page.MediumType1)).AppendLine();
sb.AppendFormat(Localization.Supported_medium_type_one_0, GetMediumTypeDescription(page.MediumType1)).
AppendLine();
if(page.MediumType2 != MediumTypes.Default)
sb.AppendFormat("Supported medium type two: {0}", GetMediumTypeDescription(page.MediumType2)).AppendLine();
sb.AppendFormat(Localization.Supported_medium_type_two_0, GetMediumTypeDescription(page.MediumType2)).
AppendLine();
if(page.MediumType3 != MediumTypes.Default)
sb.AppendFormat("Supported medium type three: {0}", GetMediumTypeDescription(page.MediumType3)).
sb.AppendFormat(Localization.Supported_medium_type_three_0, GetMediumTypeDescription(page.MediumType3)).
AppendLine();
if(page.MediumType4 != MediumTypes.Default)
sb.AppendFormat("Supported medium type four: {0}", GetMediumTypeDescription(page.MediumType4)).AppendLine();
sb.AppendFormat(Localization.Supported_medium_type_four_0, GetMediumTypeDescription(page.MediumType4)).
AppendLine();
return sb.ToString();
}

45
SCSI/Modes/0D.cs
View File

@@ -88,84 +88,89 @@ public static partial class Modes
ModePage_0D page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI CD-ROM parameters page:");
sb.AppendLine(Localization.SCSI_CD_ROM_parameters_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
switch(page.InactivityTimerMultiplier)
{
case 0:
sb.AppendLine("\tDrive will remain in track hold state a vendor-specified time after a seek or read");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_track_hold_state_a_vendor_specified_time_after_a_seek_or_read);
break;
case 1:
sb.AppendLine("\tDrive will remain in track hold state 125 ms after a seek or read");
sb.AppendLine("\t" + Localization.Drive_will_remain_in_track_hold_state_125_ms_after_a_seek_or_read);
break;
case 2:
sb.AppendLine("\tDrive will remain in track hold state 250 ms after a seek or read");
sb.AppendLine("\t" + Localization.Drive_will_remain_in_track_hold_state_250_ms_after_a_seek_or_read);
break;
case 3:
sb.AppendLine("\tDrive will remain in track hold state 500 ms after a seek or read");
sb.AppendLine("\t" + Localization.Drive_will_remain_in_track_hold_state_500_ms_after_a_seek_or_read);
break;
case 4:
sb.AppendLine("\tDrive will remain in track hold state 1 second after a seek or read");
sb.AppendLine("\t" + Localization.Drive_will_remain_in_track_hold_state_1_second_after_a_seek_or_read);
break;
case 5:
sb.AppendLine("\tDrive will remain in track hold state 2 seconds after a seek or read");
sb.AppendLine("\t" + Localization.Drive_will_remain_in_track_hold_state_2_seconds_after_a_seek_or_read);
break;
case 6:
sb.AppendLine("\tDrive will remain in track hold state 4 seconds after a seek or read");
sb.AppendLine("\t" + Localization.Drive_will_remain_in_track_hold_state_4_seconds_after_a_seek_or_read);
break;
case 7:
sb.AppendLine("\tDrive will remain in track hold state 8 seconds after a seek or read");
sb.AppendLine("\t" + Localization.Drive_will_remain_in_track_hold_state_8_seconds_after_a_seek_or_read);
break;
case 8:
sb.AppendLine("\tDrive will remain in track hold state 16 seconds after a seek or read");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_track_hold_state_16_seconds_after_a_seek_or_read);
break;
case 9:
sb.AppendLine("\tDrive will remain in track hold state 32 seconds after a seek or read");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_track_hold_state_32_seconds_after_a_seek_or_read);
break;
case 10:
sb.AppendLine("\tDrive will remain in track hold state 1 minute after a seek or read");
sb.AppendLine("\t" + Localization.Drive_will_remain_in_track_hold_state_1_minute_after_a_seek_or_read);
break;
case 11:
sb.AppendLine("\tDrive will remain in track hold state 2 minutes after a seek or read");
sb.AppendLine("\t" + Localization.Drive_will_remain_in_track_hold_state_2_minutes_after_a_seek_or_read);
break;
case 12:
sb.AppendLine("\tDrive will remain in track hold state 4 minutes after a seek or read");
sb.AppendLine("\t" + Localization.Drive_will_remain_in_track_hold_state_4_minutes_after_a_seek_or_read);
break;
case 13:
sb.AppendLine("\tDrive will remain in track hold state 8 minutes after a seek or read");
sb.AppendLine("\t" + Localization.Drive_will_remain_in_track_hold_state_8_minutes_after_a_seek_or_read);
break;
case 14:
sb.AppendLine("\tDrive will remain in track hold state 16 minutes after a seek or read");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_track_hold_state_16_minutes_after_a_seek_or_read);
break;
case 15:
sb.AppendLine("\tDrive will remain in track hold state 32 minutes after a seek or read");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_track_hold_state_32_minutes_after_a_seek_or_read);
break;
}
if(page.SecondsPerMinute > 0)
sb.AppendFormat("\tEach minute has {0} seconds", page.SecondsPerMinute).AppendLine();
sb.AppendFormat("\t" + Localization.Each_minute_has_0_seconds, page.SecondsPerMinute).AppendLine();
if(page.FramesPerSecond > 0)
sb.AppendFormat("\tEach second has {0} frames", page.FramesPerSecond).AppendLine();
sb.AppendFormat("\t" + Localization.Each_second_has_0_frames, page.FramesPerSecond).AppendLine();
return sb.ToString();
}

44
SCSI/Modes/0E.cs
View File

@@ -118,16 +118,16 @@ public static partial class Modes
ModePage_0E page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI CD-ROM audio control parameters page:");
sb.AppendLine(Localization.SCSI_CD_ROM_audio_control_parameters_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
sb.AppendLine(page.Immed ? "\tDrive will return from playback command immediately"
: "\tDrive will return from playback command when playback ends");
sb.AppendLine(page.Immed ? "\t" + Localization.Drive_will_return_from_playback_command_immediately
: "\t" + Localization.Drive_will_return_from_playback_command_when_playback_ends);
if(page.SOTC)
sb.AppendLine("\tDrive will stop playback on track end");
sb.AppendLine("\t" + Localization.Drive_will_stop_playback_on_track_end);
if(page.APRVal)
{
@@ -138,12 +138,12 @@ public static partial class Modes
else
blocks = page.BlocksPerSecondOfAudio;
sb.AppendFormat("\tThere are {0} blocks per each second of audio", blocks).AppendLine();
sb.AppendFormat("\t" + Localization.There_are_0_blocks_per_each_second_of_audio, blocks).AppendLine();
}
if(page.OutputPort0ChannelSelection > 0)
{
sb.Append("\tOutput port 0 has channels ");
sb.Append("\t" + Localization.Output_port_0_has_channels);
if((page.OutputPort0ChannelSelection & 0x01) == 0x01)
sb.Append("0 ");
@@ -160,15 +160,15 @@ public static partial class Modes
switch(page.OutputPort0Volume)
{
case 0:
sb.AppendLine("muted");
sb.AppendLine(Localization.muted);
break;
case 0xFF:
sb.AppendLine("at maximum volume");
sb.AppendLine(Localization.at_maximum_volume);
break;
default:
sb.AppendFormat("at volume {0}", page.OutputPort0Volume).AppendLine();
sb.AppendFormat(Localization.at_volume_0, page.OutputPort0Volume).AppendLine();
break;
}
@@ -176,7 +176,7 @@ public static partial class Modes
if(page.OutputPort1ChannelSelection > 0)
{
sb.Append("\tOutput port 1 has channels ");
sb.Append("\t" + Localization.Output_port_1_has_channels);
if((page.OutputPort1ChannelSelection & 0x01) == 0x01)
sb.Append("0 ");
@@ -193,15 +193,15 @@ public static partial class Modes
switch(page.OutputPort1Volume)
{
case 0:
sb.AppendLine("muted");
sb.AppendLine(Localization.muted);
break;
case 0xFF:
sb.AppendLine("at maximum volume");
sb.AppendLine(Localization.at_maximum_volume);
break;
default:
sb.AppendFormat("at volume {0}", page.OutputPort1Volume).AppendLine();
sb.AppendFormat(Localization.at_volume_0, page.OutputPort1Volume).AppendLine();
break;
}
@@ -209,7 +209,7 @@ public static partial class Modes
if(page.OutputPort2ChannelSelection > 0)
{
sb.Append("\tOutput port 2 has channels ");
sb.Append("\t" + Localization.Output_port_2_has_channels);
if((page.OutputPort2ChannelSelection & 0x01) == 0x01)
sb.Append("0 ");
@@ -226,15 +226,15 @@ public static partial class Modes
switch(page.OutputPort2Volume)
{
case 0:
sb.AppendLine("muted");
sb.AppendLine(Localization.muted);
break;
case 0xFF:
sb.AppendLine("at maximum volume");
sb.AppendLine(Localization.at_maximum_volume);
break;
default:
sb.AppendFormat("at volume {0}", page.OutputPort2Volume).AppendLine();
sb.AppendFormat(Localization.at_volume_0, page.OutputPort2Volume).AppendLine();
break;
}
@@ -243,7 +243,7 @@ public static partial class Modes
if(page.OutputPort3ChannelSelection <= 0)
return sb.ToString();
sb.Append("\tOutput port 3 has channels ");
sb.Append("\t" + Localization.Output_port_3_has_channels);
if((page.OutputPort3ChannelSelection & 0x01) == 0x01)
sb.Append("0 ");
@@ -260,15 +260,15 @@ public static partial class Modes
switch(page.OutputPort3Volume)
{
case 0:
sb.AppendLine("muted");
sb.AppendLine(Localization.muted);
break;
case 0xFF:
sb.AppendLine("at maximum volume");
sb.AppendLine(Localization.at_maximum_volume);
break;
default:
sb.AppendFormat("at volume {0}", page.OutputPort3Volume).AppendLine();
sb.AppendFormat(Localization.at_volume_0, page.OutputPort3Volume).AppendLine();
break;
}

47
SCSI/Modes/0F.cs
View File

@@ -102,47 +102,47 @@ public static partial class Modes
ModePage_0F page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Data compression page:");
sb.AppendLine(Localization.SCSI_Data_compression_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.DCC)
{
sb.AppendLine("\tDrive supports data compression");
sb.AppendLine("\t" + Localization.Drive_supports_data_compression);
if(page.DCE)
{
sb.Append("\tData compression is enabled with ");
sb.Append("\t" + Localization.Data_compression_is_enabled_with);
switch(page.CompressionAlgo)
{
case 3:
sb.AppendLine("IBM ALDC with 512 byte buffer");
sb.AppendLine(Localization.IBM_ALDC_with_512_byte_buffer);
break;
case 4:
sb.AppendLine("IBM ALDC with 1024 byte buffer");
sb.AppendLine(Localization.IBM_ALDC_with_1024_byte_buffer);
break;
case 5:
sb.AppendLine("IBM ALDC with 2048 byte buffer");
sb.AppendLine(Localization.IBM_ALDC_with_2048_byte_buffer);
break;
case 0x10:
sb.AppendLine("IBM IDRC");
sb.AppendLine(Localization.IBM_IDRC);
break;
case 0x20:
sb.AppendLine("DCLZ");
sb.AppendLine(Localization.DCLZ);
break;
case 0xFF:
sb.AppendLine("an unregistered compression algorithm");
sb.AppendLine(Localization.an_unregistered_compression_algorithm);
break;
default:
sb.AppendFormat("an unknown algorithm coded {0}", page.CompressionAlgo).AppendLine();
sb.AppendFormat(Localization.an_unknown_algorithm_coded_0, page.CompressionAlgo).AppendLine();
break;
}
@@ -150,52 +150,53 @@ public static partial class Modes
if(page.DDE)
{
sb.AppendLine("\tData decompression is enabled");
sb.AppendLine("\t" + Localization.Data_decompression_is_enabled);
if(page.DecompressionAlgo == 0)
sb.AppendLine("\tLast data read was uncompressed");
sb.AppendLine("\t" + Localization.Last_data_read_was_uncompressed);
else
{
sb.Append("\tLast data read was compressed with ");
sb.Append("\t" + Localization.Last_data_read_was_compressed_with_);
switch(page.CompressionAlgo)
{
case 3:
sb.AppendLine("IBM ALDC with 512 byte buffer");
sb.AppendLine(Localization.IBM_ALDC_with_512_byte_buffer);
break;
case 4:
sb.AppendLine("IBM ALDC with 1024 byte buffer");
sb.AppendLine(Localization.IBM_ALDC_with_1024_byte_buffer);
break;
case 5:
sb.AppendLine("IBM ALDC with 2048 byte buffer");
sb.AppendLine(Localization.IBM_ALDC_with_2048_byte_buffer);
break;
case 0x10:
sb.AppendLine("IBM IDRC");
sb.AppendLine(Localization.IBM_IDRC);
break;
case 0x20:
sb.AppendLine("DCLZ");
sb.AppendLine(Localization.DCLZ);
break;
case 0xFF:
sb.AppendLine("an unregistered compression algorithm");
sb.AppendLine(Localization.an_unregistered_compression_algorithm);
break;
default:
sb.AppendFormat("an unknown algorithm coded {0}", page.CompressionAlgo).AppendLine();
sb.AppendFormat(Localization.an_unknown_algorithm_coded_0, page.CompressionAlgo).
AppendLine();
break;
}
}
}
sb.AppendFormat("\tReport exception on compression is set to {0}", page.RED).AppendLine();
sb.AppendFormat("\t" + Localization.Report_exception_on_compression_is_set_to_0, page.RED).AppendLine();
}
else
sb.AppendLine("\tDrive does not support data compression");
sb.AppendLine("\t" + Localization.Drive_does_not_support_data_compression);
return sb.ToString();
}

19
SCSI/Modes/10.cs
View File

@@ -102,29 +102,30 @@ public static partial class Modes
ModePage_10 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI XOR control mode page:");
sb.AppendLine(Localization.SCSI_XOR_control_mode_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.XORDIS)
sb.AppendLine("\tXOR operations are disabled");
sb.AppendLine("\t" + Localization.XOR_operations_are_disabled);
else
{
if(page.MaxXorWrite > 0)
sb.AppendFormat("\tDrive accepts a maximum of {0} blocks in a single XOR WRITE command",
sb.AppendFormat("\t" + Localization.Drive_accepts_a_maximum_of_0_blocks_in_a_single_XOR_WRITE_command,
page.MaxXorWrite).AppendLine();
if(page.MaxRegenSize > 0)
sb.AppendFormat("\tDrive accepts a maximum of {0} blocks in a REGENERATE command", page.MaxRegenSize).
AppendLine();
sb.AppendFormat("\t" + Localization.Drive_accepts_a_maximum_of_0_blocks_in_a_REGENERATE_command,
page.MaxRegenSize).AppendLine();
if(page.MaxRebuildRead > 0)
sb.AppendFormat("\tDrive accepts a maximum of {0} blocks in a READ command during rebuild",
page.MaxRebuildRead).AppendLine();
sb.
AppendFormat("\t" + Localization.Drive_accepts_a_maximum_of_0_blocks_in_a_READ_command_during_rebuild,
page.MaxRebuildRead).AppendLine();
if(page.RebuildDelay > 0)
sb.AppendFormat("\tDrive needs a minimum of {0} ms between READ commands during rebuild",
sb.AppendFormat("\t" + Localization.Drive_needs_a_minimum_of_0_ms_between_READ_commands_during_rebuild,
page.RebuildDelay).AppendLine();
}

78
SCSI/Modes/10_SSC.cs
View File

@@ -170,71 +170,72 @@ public static partial class Modes
ModePage_10_SSC page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Device configuration page:");
sb.AppendLine(Localization.SCSI_Device_configuration_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
sb.AppendFormat("\tActive format: {0}", page.ActiveFormat).AppendLine();
sb.AppendFormat("\tActive partition: {0}", page.ActivePartition).AppendLine();
sb.AppendFormat("\t" + Localization.Active_format_0, page.ActiveFormat).AppendLine();
sb.AppendFormat("\t" + Localization.Active_partition_0, page.ActivePartition).AppendLine();
sb.AppendFormat("\tWrite buffer shall have a full ratio of {0} before being flushed to medium",
sb.AppendFormat("\t" + Localization.Write_buffer_shall_have_a_full_ratio_of_0_before_being_flushed_to_medium,
page.WriteBufferFullRatio).AppendLine();
sb.AppendFormat("\tRead buffer shall have an empty ratio of {0} before more data is read from medium",
page.ReadBufferEmptyRatio).AppendLine();
sb.
AppendFormat("\t" + Localization.Read_buffer_shall_have_an_empty_ratio_of_0_before_more_data_is_read_from_medium,
page.ReadBufferEmptyRatio).AppendLine();
sb.
AppendFormat("\tDrive will delay {0} ms before buffered data is forcefully written to the medium even before buffer is full",
AppendFormat("\t" + Localization.Drive_will_delay_0_ms_before_buffered_data_is_forcefully_written_to_the_medium_even_before_buffer_is_full,
page.WriteDelayTime * 100).AppendLine();
if(page.DBR)
{
sb.AppendLine("\tDrive supports recovering data from buffer");
sb.AppendLine("\t" + Localization.Drive_supports_recovering_data_from_buffer);
sb.AppendLine(page.RBO ? "\tRecovered buffer data comes in LIFO order"
: "\tRecovered buffer data comes in FIFO order");
sb.AppendLine(page.RBO ? "\t" + Localization.Recovered_buffer_data_comes_in_LIFO_order
: "\t" + Localization.Recovered_buffer_data_comes_in_FIFO_order);
}
if(page.BIS)
sb.AppendLine("\tMedium supports block IDs");
sb.AppendLine("\t" + Localization.Medium_supports_block_IDs);
if(page.RSmk)
sb.AppendLine("\tDrive reports setmarks");
sb.AppendLine("\t" + Localization.Drive_reports_setmarks);
switch(page.SOCF)
{
case 0:
sb.AppendLine("\tDrive will pre-read until buffer is full");
sb.AppendLine("\t" + Localization.Drive_will_pre_read_until_buffer_is_full);
break;
case 1:
sb.AppendLine("\tDrive will pre-read until one filemark is detected");
sb.AppendLine("\t" + Localization.Drive_will_pre_read_until_one_filemark_is_detected);
break;
case 2:
sb.AppendLine("\tDrive will pre-read until two filemark is detected");
sb.AppendLine("\t" + Localization.Drive_will_pre_read_until_two_filemark_is_detected);
break;
case 3:
sb.AppendLine("\tDrive will pre-read until three filemark is detected");
sb.AppendLine("\t" + Localization.Drive_will_pre_read_until_three_filemark_is_detected);
break;
}
if(page.REW)
{
sb.AppendLine("\tDrive reports early warnings");
sb.AppendLine("\t" + Localization.Drive_reports_early_warnings);
if(page.SEW)
sb.AppendLine("\tDrive will synchronize buffer to medium on early warnings");
sb.AppendLine("\t" + Localization.Drive_will_synchronize_buffer_to_medium_on_early_warnings);
}
switch(page.GapSize)
{
case 0: break;
case 1:
sb.AppendLine("\tInter-block gap is long enough to support update in place");
sb.AppendLine("\t" + Localization.Inter_block_gap_is_long_enough_to_support_update_in_place);
break;
case 2:
@@ -251,59 +252,60 @@ public static partial class Modes
case 13:
case 14:
case 15:
sb.AppendFormat("\tInter-block gap is {0} times the device's defined gap size", page.GapSize).
AppendLine();
sb.AppendFormat("\t" + Localization.Inter_block_gap_is_0_times_the_device_defined_gap_size,
page.GapSize).AppendLine();
break;
default:
sb.AppendFormat("\tInter-block gap is unknown value {0}", page.GapSize).AppendLine();
sb.AppendFormat("\t" + Localization.Inter_block_gap_is_unknown_value_0, page.GapSize).AppendLine();
break;
}
if(page.EEG)
sb.AppendLine("\tDrive generates end-of-data");
sb.AppendLine("\t" + Localization.Drive_generates_end_of_data);
switch(page.SelectedCompression)
{
case 0:
sb.AppendLine("\tDrive does not use compression");
sb.AppendLine("\t" + Localization.Drive_does_not_use_compression);
break;
case 1:
sb.AppendLine("\tDrive uses default compression");
sb.AppendLine("\t" + Localization.Drive_uses_default_compression);
break;
default:
sb.AppendFormat("\tDrive uses unknown compression {0}", page.SelectedCompression).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_uses_unknown_compression_0, page.SelectedCompression).
AppendLine();
break;
}
if(page.SWP)
sb.AppendLine("\tSoftware write protect is enabled");
sb.AppendLine("\t" + Localization.Software_write_protect_is_enabled);
if(page.ASOCWP)
sb.AppendLine("\tAssociated write protect is enabled");
sb.AppendLine("\t" + Localization.Associated_write_protect_is_enabled);
if(page.PERSWP)
sb.AppendLine("\tPersistent write protect is enabled");
sb.AppendLine("\t" + Localization.Persistent_write_protect_is_enabled);
if(page.PRMWP)
sb.AppendLine("\tPermanent write protect is enabled");
sb.AppendLine("\t" + Localization.Permanent_write_protect_is_enabled);
if(page.BAML)
sb.AppendLine(page.BAM ? "\tDrive operates using explicit address mode"
: "\tDrive operates using implicit address mode");
sb.AppendLine(page.BAM ? "\t" + Localization.Drive_operates_using_explicit_address_mode
: "\t" + Localization.Drive_operates_using_implicit_address_mode);
switch(page.RewindOnReset)
{
case 1:
sb.AppendLine("\tDrive shall position to beginning of default data partition on reset");
sb.AppendLine("\t" + Localization.Drive_shall_position_to_beginning_of_default_data_partition_on_reset);
break;
case 2:
sb.AppendLine("\tDrive shall maintain its position on reset");
sb.AppendLine("\t" + Localization.Drive_shall_maintain_its_position_on_reset);
break;
}
@@ -311,17 +313,17 @@ public static partial class Modes
switch(page.WTRE)
{
case 1:
sb.AppendLine("\tDrive will do nothing on WORM tampered medium");
sb.AppendLine("\t" + Localization.Drive_will_do_nothing_on_WORM_tampered_medium);
break;
case 2:
sb.AppendLine("\tDrive will return CHECK CONDITION on WORM tampered medium");
sb.AppendLine("\t" + Localization.Drive_will_return_CHECK_CONDITION_on_WORM_tampered_medium);
break;
}
if(page.OIR)
sb.AppendLine("\tDrive will only respond to commands if it has received a reservation");
sb.AppendLine("\t" + Localization.Drive_will_only_respond_to_commands_if_it_has_received_a_reservation);
return sb.ToString();
}

75
SCSI/Modes/11.cs
View File

@@ -143,42 +143,49 @@ public static partial class Modes
ModePage_11 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI medium partition page:");
sb.AppendLine(Localization.SCSI_medium_partition_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
sb.AppendFormat("\t{0} maximum additional partitions", page.MaxAdditionalPartitions).AppendLine();
sb.AppendFormat("\t{0} additional partitions defined", page.AdditionalPartitionsDefined).AppendLine();
sb.AppendFormat("\t" + Localization._0_maximum_additional_partitions, page.MaxAdditionalPartitions).
AppendLine();
sb.AppendFormat("\t" + Localization._0_additional_partitions_defined, page.AdditionalPartitionsDefined).
AppendLine();
if(page.FDP)
sb.AppendLine("\tPartitions are fixed under device definitions");
sb.AppendLine("\t" + Localization.Partitions_are_fixed_under_device_definitions);
if(page.SDP)
sb.AppendLine("\tNumber of partitions can be defined but their size is defined by the device");
sb.AppendLine("\t" + Localization.
Number_of_partitions_can_be_defined_but_their_size_is_defined_by_the_device);
if(page.IDP)
sb.AppendLine("\tNumber and size of partitions can be manually defined");
sb.AppendLine("\t" + Localization.Number_and_size_of_partitions_can_be_manually_defined);
if(page.POFM)
sb.AppendLine("\tPartition parameters will not be applied until a FORMAT MEDIUM command is received");
sb.AppendLine("\t" + Localization.
Partition_parameters_will_not_be_applied_until_a_FORMAT_MEDIUM_command_is_received);
switch(page.CLEAR)
{
case false when !page.ADDP:
sb.AppendLine("\tDevice may erase any or all partitions on MODE SELECT for partitioning");
sb.AppendLine("\t" + Localization.
Device_may_erase_any_or_all_partitions_on_MODE_SELECT_for_partitioning);
break;
case true when !page.ADDP:
sb.AppendLine("\tDevice shall erase all partitions on MODE SELECT for partitioning");
sb.AppendLine("\t" + Localization.Device_shall_erase_all_partitions_on_MODE_SELECT_for_partitioning);
break;
case false:
sb.AppendLine("\tDevice shall not erase any partition on MODE SELECT for partitioning");
sb.AppendLine("\t" + Localization.Device_shall_not_erase_any_partition_on_MODE_SELECT_for_partitioning);
break;
default:
sb.AppendLine("\tDevice shall erase all partitions differing on size on MODE SELECT for partitioning");
sb.AppendLine("\t" + Localization.
Device_shall_erase_all_partitions_differing_on_size_on_MODE_SELECT_for_partitioning);
break;
}
@@ -188,30 +195,30 @@ public static partial class Modes
switch(page.PSUM)
{
case PartitionSizeUnitOfMeasures.Bytes:
sb.AppendLine("\tPartitions are defined in bytes");
measure = "bytes";
sb.AppendLine("\t" + Localization.Partitions_are_defined_in_bytes);
measure = Localization.bytes;
break;
case PartitionSizeUnitOfMeasures.Kilobytes:
sb.AppendLine("\tPartitions are defined in kilobytes");
measure = "kilobytes";
sb.AppendLine("\t" + Localization.Partitions_are_defined_in_kilobytes);
measure = Localization.kilobytes;
break;
case PartitionSizeUnitOfMeasures.Megabytes:
sb.AppendLine("\tPartitions are defined in megabytes");
measure = "megabytes";
sb.AppendLine("\t" + Localization.Partitions_are_defined_in_megabytes);
measure = Localization.megabytes;
break;
case PartitionSizeUnitOfMeasures.Exponential:
sb.AppendFormat("\tPartitions are defined in units of {0} bytes", Math.Pow(10, page.PartitionUnits)).
AppendLine();
sb.AppendFormat("\t" + Localization.Partitions_are_defined_in_units_of_0_bytes,
Math.Pow(10, page.PartitionUnits)).AppendLine();
measure = $"units of {Math.Pow(10, page.PartitionUnits)} bytes";
measure = string.Format(Localization.units_of_0_bytes, Math.Pow(10, page.PartitionUnits));
break;
default:
sb.AppendFormat("\tUnknown partition size unit code {0}", (byte)page.PSUM).AppendLine();
measure = "units";
sb.AppendFormat("\t" + Localization.Unknown_partition_size_unit_code_0, (byte)page.PSUM).AppendLine();
measure = Localization.units;
break;
}
@@ -219,38 +226,40 @@ public static partial class Modes
switch(page.MediumFormatRecognition)
{
case MediumFormatRecognitionValues.Capable:
sb.AppendLine("\tDevice is capable of recognizing both medium partitions and format");
sb.AppendLine("\t" + Localization.Device_is_capable_of_recognizing_both_medium_partitions_and_format);
break;
case MediumFormatRecognitionValues.FormatCapable:
sb.AppendLine("\tDevice is capable of recognizing medium format");
sb.AppendLine("\t" + Localization.Device_is_capable_of_recognizing_medium_format);
break;
case MediumFormatRecognitionValues.PartitionCapable:
sb.AppendLine("\tDevice is capable of recognizing medium partitions");
sb.AppendLine("\t" + Localization.Device_is_capable_of_recognizing_medium_partitions);
break;
case MediumFormatRecognitionValues.Incapable:
sb.AppendLine("\tDevice is not capable of recognizing neither medium partitions nor format");
sb.AppendLine("\t" + Localization.
Device_is_not_capable_of_recognizing_neither_medium_partitions_nor_format);
break;
default:
sb.AppendFormat("\tUnknown medium recognition code {0}", (byte)page.MediumFormatRecognition).
AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_medium_recognition_code_0,
(byte)page.MediumFormatRecognition).AppendLine();
break;
}
sb.AppendFormat("\tMedium has defined {0} partitions", page.PartitionSizes.Length).AppendLine();
sb.AppendFormat("\t" + Localization.Medium_has_defined_0_partitions, page.PartitionSizes.Length).AppendLine();
for(int i = 0; i < page.PartitionSizes.Length; i++)
if(page.PartitionSizes[i] == 0)
if(page.PartitionSizes.Length == 1)
sb.AppendLine("\tDevice recognizes one single partition spanning whole medium");
sb.AppendLine("\t" + Localization.Device_recognizes_one_single_partition_spanning_whole_medium);
else
sb.AppendFormat("\tPartition {0} runs for rest of medium", i).AppendLine();
sb.AppendFormat("\t" + Localization.Partition_0_runs_for_rest_of_medium, i).AppendLine();
else
sb.AppendFormat("\tPartition {0} is {1} {2} long", i, page.PartitionSizes[i], measure).AppendLine();
sb.AppendFormat("\t" + Localization.Partition_0_is_1_2_long, i, page.PartitionSizes[i], measure).
AppendLine();
return sb.ToString();
}

8
SCSI/Modes/12_13_14.cs
View File

@@ -94,15 +94,15 @@ public static partial class Modes
ModePage_12_13_14 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI medium partition page (extra):");
sb.AppendLine(Localization.SCSI_medium_partition_page_extra);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
sb.AppendFormat("\tMedium has defined {0} partitions", page.PartitionSizes.Length).AppendLine();
sb.AppendFormat("\t" + Localization.Medium_has_defined_0_partitions, page.PartitionSizes.Length).AppendLine();
for(int i = 0; i < page.PartitionSizes.Length; i++)
sb.AppendFormat("\tPartition {0} is {1} units long", i, page.PartitionSizes[i]).AppendLine();
sb.AppendFormat("\t" + Localization.Partition_0_is_1_units_long, i, page.PartitionSizes[i]).AppendLine();
return sb.ToString();
}

37
SCSI/Modes/1A.cs
View File

@@ -138,45 +138,47 @@ public static partial class Modes
sb.AppendLine("SCSI Power condition page:");
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page is { Standby : true, StandbyTimer : > 0 } ||
page is { Standby_Y: true, StandbyTimer_Y: > 0 })
{
if(page is { Standby: true, StandbyTimer: > 0 })
sb.AppendFormat("\tStandby timer Z is set to {0} ms", page.StandbyTimer * 100).AppendLine();
sb.AppendFormat("\t" + "Standby timer Z is set to {0} ms", page.StandbyTimer * 100).AppendLine();
if(page is { Standby_Y: true, StandbyTimer_Y: > 0 })
sb.AppendFormat("\tStandby timer Y is set to {0} ms", page.StandbyTimer_Y * 100).AppendLine();
sb.AppendFormat("\t" + "Standby timer Y is set to {0} ms", page.StandbyTimer_Y * 100).AppendLine();
}
else
sb.AppendLine("\tDrive will not enter standby mode");
sb.AppendLine("\t" + "Drive will not enter standby mode");
if(page is { Idle : true, IdleTimer : > 0 } ||
page is { Idle_B: true, IdleTimer_B: > 0 } ||
page is { Idle_C: true, IdleTimer_C: > 0 })
{
if(page is { Idle: true, IdleTimer: > 0 })
sb.AppendFormat("\tIdle timer A is set to {0} ms", page.IdleTimer * 100).AppendLine();
sb.AppendFormat("\t" + "Idle timer A is set to {0} ms", page.IdleTimer * 100).AppendLine();
if(page is { Idle_B: true, IdleTimer_B: > 0 })
sb.AppendFormat("\tIdle timer B is set to {0} ms", page.IdleTimer_B * 100).AppendLine();
sb.AppendFormat("\t" + "Idle timer B is set to {0} ms", page.IdleTimer_B * 100).AppendLine();
if(page is { Idle_C: true, IdleTimer_C: > 0 })
sb.AppendFormat("\tIdle timer C is set to {0} ms", page.IdleTimer_C * 100).AppendLine();
sb.AppendFormat("\t" + "Idle timer C is set to {0} ms", page.IdleTimer_C * 100).AppendLine();
}
else
sb.AppendLine("\tDrive will not enter idle mode");
sb.AppendLine("\t" + "Drive will not enter idle mode");
switch(page.PM_BG_Precedence)
{
case 0: break;
case 1:
sb.AppendLine("\tPerforming background functions take precedence over maintaining low power conditions");
sb.AppendLine("\t" +
"Performing background functions take precedence over maintaining low power conditions");
break;
case 2:
sb.AppendLine("\tMaintaining low power conditions take precedence over performing background functions");
sb.AppendLine("\t" +
"Maintaining low power conditions take precedence over performing background functions");
break;
}
@@ -234,28 +236,29 @@ public static partial class Modes
ModePage_1A_S01 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Power Consumption page:");
sb.AppendLine(Localization.SCSI_Power_Consumption_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
switch(page.ActiveLevel)
{
case 0:
sb.AppendFormat("\tDevice power consumption is dictated by identifier {0} of Power Consumption VPD",
page.PowerConsumptionIdentifier).AppendLine();
sb.
AppendFormat("\t" + Localization.Device_power_consumption_is_dictated_by_identifier_0_of_Power_Consumption_VPD,
page.PowerConsumptionIdentifier).AppendLine();
break;
case 1:
sb.AppendLine("\tDevice is in highest relative power consumption level");
sb.AppendLine("\t" + Localization.Device_is_in_highest_relative_power_consumption_level);
break;
case 2:
sb.AppendLine("\tDevice is in intermediate relative power consumption level");
sb.AppendLine("\t" + Localization.Device_is_in_intermediate_relative_power_consumption_level);
break;
case 3:
sb.AppendLine("\tDevice is in lowest relative power consumption level");
sb.AppendLine("\t" + Localization.Device_is_in_lowest_relative_power_consumption_level);
break;
}

14
SCSI/Modes/1B.cs
View File

@@ -95,25 +95,25 @@ public static partial class Modes
ModePage_1B page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Removable Block Access Capabilities page:");
sb.AppendLine(Localization.SCSI_Removable_Block_Access_Capabilities_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.SFLP)
sb.AppendLine("\tDrive can be used as a system floppy device");
sb.AppendLine("\t" + Localization.Drive_can_be_used_as_a_system_floppy_device);
if(page.SRFP)
sb.AppendLine("\tDrive supports reporting progress of format");
sb.AppendLine("\t" + Localization.Drive_supports_reporting_progress_of_format);
if(page.NCD)
sb.AppendLine("\tDrive is a Non-CD Optical Device");
sb.AppendLine("\t" + Localization.Drive_is_a_Non_CD_Optical_Device);
if(page.SML)
sb.AppendLine("\tDevice is a dual device supporting CD and Non-CD Optical");
sb.AppendLine("\t" + Localization.Device_is_a_dual_device_supporting_CD_and_Non_CD_Optical);
if(page.TLUN > 0)
sb.AppendFormat("\tDrive supports {0} LUNs", page.TLUN).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_supports_0_LUNs, page.TLUN).AppendLine();
return sb.ToString();
}

71
SCSI/Modes/1C.cs
View File

@@ -120,81 +120,84 @@ public static partial class Modes
ModePage_1C page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Informational exceptions control page:");
sb.AppendLine(Localization.SCSI_Informational_exceptions_control_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.DExcpt)
sb.AppendLine("\tInformational exceptions are disabled");
sb.AppendLine("\t" + Localization.Informational_exceptions_are_disabled);
else
{
sb.AppendLine("\tInformational exceptions are enabled");
sb.AppendLine("\t" + Localization.Informational_exceptions_are_enabled);
switch(page.MRIE)
{
case 0:
sb.AppendLine("\tNo reporting of informational exception condition");
sb.AppendLine("\t" + Localization.No_reporting_of_informational_exception_condition);
break;
case 1:
sb.AppendLine("\tAsynchronous event reporting of informational exceptions");
sb.AppendLine("\t" + Localization.Asynchronous_event_reporting_of_informational_exceptions);
break;
case 2:
sb.AppendLine("\tGenerate unit attention on informational exceptions");
sb.AppendLine("\t" + Localization.Generate_unit_attention_on_informational_exceptions);
break;
case 3:
sb.AppendLine("\tConditionally generate recovered error on informational exceptions");
sb.AppendLine("\t" + Localization.
Conditionally_generate_recovered_error_on_informational_exceptions);
break;
case 4:
sb.AppendLine("\tUnconditionally generate recovered error on informational exceptions");
sb.AppendLine("\t" + Localization.
Unconditionally_generate_recovered_error_on_informational_exceptions);
break;
case 5:
sb.AppendLine("\tGenerate no sense on informational exceptions");
sb.AppendLine("\t" + Localization.Generate_no_sense_on_informational_exceptions);
break;
case 6:
sb.AppendLine("\tOnly report informational exception condition on request");
sb.AppendLine("\t" + Localization.Only_report_informational_exception_condition_on_request);
break;
default:
sb.AppendFormat("\tUnknown method of reporting {0}", page.MRIE).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_method_of_reporting_0, page.MRIE).AppendLine();
break;
}
if(page.Perf)
sb.AppendLine("\tInformational exceptions reporting should not affect drive performance");
sb.AppendLine("\t" + Localization.
Informational_exceptions_reporting_should_not_affect_drive_performance);
if(page.Test)
sb.AppendLine("\tA test informational exception will raise on next timer");
sb.AppendLine("\t" + Localization.A_test_informational_exception_will_raise_on_next_timer);
if(page.LogErr)
sb.AppendLine("\tDrive shall log informational exception conditions");
sb.AppendLine("\t" + Localization.Drive_shall_log_informational_exception_conditions);
if(page.IntervalTimer > 0)
if(page.IntervalTimer == 0xFFFFFFFF)
sb.AppendLine("\tTimer interval is vendor-specific");
sb.AppendLine("\t" + Localization.Timer_interval_is_vendor_specific);
else
sb.AppendFormat("\tTimer interval is {0} ms", page.IntervalTimer * 100).AppendLine();
sb.AppendFormat("\t" + Localization.Timer_interval_is_0_ms, page.IntervalTimer * 100).AppendLine();
if(page.ReportCount > 0)
sb.AppendFormat("\tInformational exception conditions will be reported a maximum of {0} times",
sb.AppendFormat("\t" + Localization.Informational_exception_conditions_will_be_reported_a_maximum_of_0_times,
page.ReportCount);
}
if(page.EWasc)
sb.AppendLine("\tWarning reporting is enabled");
sb.AppendLine("\t" + Localization.Warning_reporting_is_enabled);
if(page.EBF)
sb.AppendLine("\tBackground functions are enabled");
sb.AppendLine("\t" + Localization.Background_functions_are_enabled);
if(page.EBACKERR)
sb.AppendLine("\tDrive will report background self-test errors");
sb.AppendLine("\t" + Localization.Drive_will_report_background_self_test_errors);
return sb.ToString();
}
@@ -269,38 +272,40 @@ public static partial class Modes
ModePage_1C_S01 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Background Control page:");
sb.AppendLine(Localization.SCSI_Background_Control_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.S_L_Full)
sb.AppendLine("\tBackground scans will be halted if log is full");
sb.AppendLine("\t" + Localization.Background_scans_will_be_halted_if_log_is_full);
if(page.LOWIR)
sb.AppendLine("\tBackground scans will only be logged if they require intervention");
sb.AppendLine("\t" + Localization.Background_scans_will_only_be_logged_if_they_require_intervention);
if(page.En_Bms)
sb.AppendLine("\tBackground medium scans are enabled");
sb.AppendLine("\t" + Localization.Background_medium_scans_are_enabled);
if(page.En_Ps)
sb.AppendLine("\tBackground pre-scans are enabled");
sb.AppendLine("\t" + Localization.Background_pre_scans_are_enabled);
if(page.BackgroundScanInterval > 0)
sb.AppendFormat("\t{0} hours shall be between the start of a background scan operation and the next",
page.BackgroundScanInterval).AppendLine();
sb.
AppendFormat("\t" + Localization._0__hours_shall_be_between_the_start_of_a_background_scan_operation_and_the_next,
page.BackgroundScanInterval).AppendLine();
if(page.BackgroundPrescanTimeLimit > 0)
sb.AppendFormat("\tBackground pre-scan operations can take a maximum of {0} hours",
sb.AppendFormat("\t" + Localization.Background_pre_scan_operations_can_take_a_maximum_of_0_hours,
page.BackgroundPrescanTimeLimit).AppendLine();
if(page.MinIdleBeforeBgScan > 0)
sb.AppendFormat("\tAt least {0} ms must be idle before resuming a suspended background scan operation",
page.MinIdleBeforeBgScan).AppendLine();
sb.
AppendFormat("\t" + Localization.At_least_0_ms_must_be_idle_before_resuming_a_suspended_background_scan_operation,
page.MinIdleBeforeBgScan).AppendLine();
if(page.MaxTimeSuspendBgScan > 0)
sb.
AppendFormat("\tAt most {0} ms must be before suspending a background scan operation and processing received commands",
AppendFormat("\t" + Localization.At_most_0_ms_must_be_before_suspending_a_background_scan_operation_and_processing_received_commands,
page.MaxTimeSuspendBgScan).AppendLine();
return sb.ToString();

56
SCSI/Modes/1C_SFF.cs
View File

@@ -89,81 +89,97 @@ public static partial class Modes
ModePage_1C_SFF page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Timer & Protect page:");
sb.AppendLine(Localization.SCSI_Timer_Protect_page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.DISP)
sb.AppendLine("\tDrive is disabled until power is cycled");
sb.AppendLine("\t" + Localization.Drive_is_disabled_until_power_is_cycled);
if(page.SWPP)
sb.AppendLine("\tDrive is software write-protected until powered down");
sb.AppendLine("\t" + Localization.Drive_is_software_write_protected_until_powered_down);
switch(page.InactivityTimeMultiplier)
{
case 0:
sb.AppendLine("\tDrive will remain in same status a vendor-specified time after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_a_vendor_specified_time_after_a_seek_read_or_write_operation);
break;
case 1:
sb.AppendLine("\tDrive will remain in same status 125 ms after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_125_ms_after_a_seek_read_or_write_operation);
break;
case 2:
sb.AppendLine("\tDrive will remain in same status 250 ms after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_250_ms_after_a_seek_read_or_write_operation);
break;
case 3:
sb.AppendLine("\tDrive will remain in same status 500 ms after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_500_ms_after_a_seek_read_or_write_operation);
break;
case 4:
sb.AppendLine("\tDrive will remain in same status 1 second after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_1_second_after_a_seek_read_or_write_operation);
break;
case 5:
sb.AppendLine("\tDrive will remain in same status 2 seconds after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_2_seconds_after_a_seek_read_or_write_operation);
break;
case 6:
sb.AppendLine("\tDrive will remain in same status 4 seconds after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_4_seconds_after_a_seek_read_or_write_operation);
break;
case 7:
sb.AppendLine("\tDrive will remain in same status 8 seconds after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_8_seconds_after_a_seek_read_or_write_operation);
break;
case 8:
sb.AppendLine("\tDrive will remain in same status 16 seconds after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_16_seconds_after_a_seek_read_or_write_operation);
break;
case 9:
sb.AppendLine("\tDrive will remain in same status 32 seconds after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_32_seconds_after_a_seek_read_or_write_operation);
break;
case 10:
sb.AppendLine("\tDrive will remain in same status 1 minute after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_1_minute_after_a_seek_read_or_write_operation);
break;
case 11:
sb.AppendLine("\tDrive will remain in same status 2 minutes after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_2_minutes_after_a_seek_read_or_write_operation);
break;
case 12:
sb.AppendLine("\tDrive will remain in same status 4 minutes after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_4_minutes_after_a_seek_read_or_write_operation);
break;
case 13:
sb.AppendLine("\tDrive will remain in same status 8 minutes after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_8_minutes_after_a_seek_read_or_write_operation);
break;
case 14:
sb.AppendLine("\tDrive will remain in same status 16 minutes after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_16_minutes_after_a_seek_read_or_write_operation);
break;
case 15:
sb.AppendLine("\tDrive will remain in same status 32 minutes after a seek, read or write operation");
sb.AppendLine("\t" + Localization.
Drive_will_remain_in_same_status_32_minutes_after_a_seek_read_or_write_operation);
break;
}

26
SCSI/Modes/1D.cs
View File

@@ -84,31 +84,31 @@ public static partial class Modes
ModePage_1D page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("SCSI Medium Configuration Mode Page:");
sb.AppendLine(Localization.SCSI_Medium_Configuration_Mode_Page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.WORMM)
sb.AppendLine("\tDrive is operating in WORM mode");
sb.AppendLine("\t" + Localization.Drive_is_operating_in_WORM_mode);
switch(page.WormModeLabelRestrictions)
{
case 0:
sb.AppendLine("\tDrive does not allow any logical blocks to be overwritten");
sb.AppendLine("\t" + Localization.Drive_does_not_allow_any_logical_blocks_to_be_overwritten);
break;
case 1:
sb.AppendLine("\tDrive allows a tape header to be overwritten");
sb.AppendLine("\t" + Localization.Drive_allows_a_tape_header_to_be_overwritten);
break;
case 2:
sb.AppendLine("\tDrive allows all format labels to be overwritten");
sb.AppendLine("\t" + Localization.Drive_allows_all_format_labels_to_be_overwritten);
break;
default:
sb.AppendFormat("\tUnknown WORM mode label restrictions code {0}", page.WormModeLabelRestrictions).
AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_WORM_mode_label_restrictions_code_0,
page.WormModeLabelRestrictions).AppendLine();
break;
}
@@ -116,16 +116,18 @@ public static partial class Modes
switch(page.WormModeFilemarkRestrictions)
{
case 2:
sb.AppendLine("\tDrive allows any number of filemarks immediately preceding EOD to be overwritten except filemark closes to BOP");
sb.AppendLine("\t" +
"Drive allows any number of filemarks immediately preceding EOD to be overwritten except filemark closes to BOP");
break;
case 3:
sb.AppendLine("\tDrive allows any number of filemarks immediately preceding EOD to be overwritten");
sb.AppendLine("\t" +
"Drive allows any number of filemarks immediately preceding EOD to be overwritten");
break;
default:
sb.AppendFormat("\tUnknown WORM mode filemark restrictions code {0}", page.WormModeLabelRestrictions).
AppendLine();
sb.AppendFormat("\t" + "Unknown WORM mode filemark restrictions code {0}",
page.WormModeLabelRestrictions).AppendLine();
break;
}

50
SCSI/Modes/21_Certance.cs
View File

@@ -94,20 +94,20 @@ public static partial class Modes
Certance_ModePage_21 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("Certance Drive Capabilities Control Mode Page:");
sb.AppendLine(Localization.Certance_Drive_Capabilities_Control_Mode_Page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
switch(page.OperatingSystemsSupport)
{
case 0:
sb.AppendLine("\tOperating systems support is standard LTO");
sb.AppendLine("\t" + Localization.Operating_systems_support_is_standard_LTO);
break;
default:
sb.AppendFormat("\tOperating systems support is unknown code {0}", page.OperatingSystemsSupport).
AppendLine();
sb.AppendFormat("\t" + Localization.Operating_systems_support_is_unknown_code_0,
page.OperatingSystemsSupport).AppendLine();
break;
}
@@ -116,19 +116,20 @@ public static partial class Modes
switch(page.FirmwareTestControl)
{
case 0:
sb.AppendLine("\tFactory test code is disabled");
sb.AppendLine("\t" + Localization.Factory_test_code_is_disabled);
break;
case 1:
sb.AppendLine("\tFactory test code 1 is disabled");
sb.AppendLine("\t" + Localization.Factory_test_code_1_is_disabled);
break;
case 2:
sb.AppendLine("\tFactory test code 2 is disabled");
sb.AppendLine("\t" + Localization.Factory_test_code_2_is_disabled);
break;
default:
sb.AppendFormat("\tUnknown factory test code {0}", page.FirmwareTestControl).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_factory_test_code_0, page.FirmwareTestControl).
AppendLine();
break;
}
@@ -136,15 +137,16 @@ public static partial class Modes
switch(page.ExtendedPOSTMode)
{
case 0:
sb.AppendLine("\tPower-On Self-Test is enabled");
sb.AppendLine("\t" + Localization.Power_On_Self_Test_is_enabled);
break;
case 1:
sb.AppendLine("\tPower-On Self-Test is disable");
sb.AppendLine("\t" + Localization.Power_On_Self_Test_is_disable);
break;
default:
sb.AppendFormat("\tUnknown Power-On Self-Test code {0}", page.ExtendedPOSTMode).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_Power_On_Self_Test_code_0, page.ExtendedPOSTMode).
AppendLine();
break;
}
@@ -152,48 +154,50 @@ public static partial class Modes
switch(page.DataCompressionControl)
{
case 0:
sb.AppendLine("\tCompression is controlled using mode pages 0Fh and 10h");
sb.AppendLine("\t" + Localization.Compression_is_controlled_using_mode_pages_0Fh_and_10h);
break;
case 1:
sb.AppendLine("\tCompression is enabled and not controllable");
sb.AppendLine("\t" + Localization.Compression_is_enabled_and_not_controllable);
break;
case 2:
sb.AppendLine("\tCompression is disabled and not controllable");
sb.AppendLine("\t" + Localization.Compression_is_disabled_and_not_controllable);
break;
default:
sb.AppendFormat("\tUnknown compression control code {0}", page.DataCompressionControl).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_compression_control_code_0, page.DataCompressionControl).
AppendLine();
break;
}
if(page.HostUnloadOverride)
sb.AppendLine("\tSCSI UNLOAD command will not eject the cartridge");
sb.AppendLine("\t" + Localization.SCSI_UNLOAD_command_will_not_eject_the_cartridge);
sb.Append("\tHow should tapes be unloaded in a power cycle, tape incompatibility, firmware download or cleaning end: ");
sb.Append("\t" + Localization.
How_should_tapes_be_unloaded_in_a_power_cycle_tape_incompatibility_firmware_download_or_cleaning_end);
switch(page.AutoUnloadMode)
{
case 0:
sb.AppendLine("\tTape will stay threaded at beginning");
sb.AppendLine("\t" + Localization.Tape_will_stay_threaded_at_beginning);
break;
case 1:
sb.AppendLine("\tTape will be unthreaded");
sb.AppendLine("\t" + Localization.Tape_will_be_unthreaded);
break;
case 2:
sb.AppendLine("\tTape will be unthreaded and unloaded");
sb.AppendLine("\t" + Localization.Tape_will_be_unthreaded_and_unloaded);
break;
case 3:
sb.AppendLine("\tData tapes will be threaded at beginning, rest will be unloaded");
sb.AppendLine("\t" + Localization.Data_tapes_will_be_threaded_at_beginning_rest_will_be_unloaded);
break;
default:
sb.AppendFormat("\tUnknown auto unload code {0}", page.AutoUnloadMode).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_auto_unload_code_0, page.AutoUnloadMode).AppendLine();
break;
}

48
SCSI/Modes/22_Certance.cs
View File

@@ -100,56 +100,57 @@ public static partial class Modes
Certance_ModePage_22 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("Certance Interface Control Mode Page:");
sb.AppendLine(Localization.Certance_Interface_Control_Mode_Page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
switch(page.BaudRate)
{
case 0:
case 1:
case 2:
sb.AppendLine("\tLibrary interface will operate at 9600 baud on next reset");
sb.AppendLine("\t" + Localization.Library_interface_will_operate_at_9600_baud_on_next_reset);
break;
case 3:
sb.AppendLine("\tLibrary interface will operate at 19200 baud on next reset");
sb.AppendLine("\t" + Localization.Library_interface_will_operate_at_19200_baud_on_next_reset);
break;
case 4:
sb.AppendLine("\tLibrary interface will operate at 38400 baud on next reset");
sb.AppendLine("\t" + Localization.Library_interface_will_operate_at_38400_baud_on_next_reset);
break;
case 5:
sb.AppendLine("\tLibrary interface will operate at 57600 baud on next reset");
sb.AppendLine("\t" + Localization.Library_interface_will_operate_at_57600_baud_on_next_reset);
break;
case 6:
sb.AppendLine("\tLibrary interface will operate at 115200 baud on next reset");
sb.AppendLine("\t" + Localization.Library_interface_will_operate_at_115200_baud_on_next_reset);
break;
default:
sb.AppendFormat("\tUnknown library interface baud rate code {0}", page.BaudRate).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_library_interface_baud_rate_code_0, page.BaudRate).
AppendLine();
break;
}
sb.AppendLine(page.StopBits ? "Library interface transmits 2 stop bits per byte"
: "Library interface transmits 1 stop bits per byte");
sb.AppendLine(page.StopBits ? Localization.Library_interface_transmits_2_stop_bits_per_byte
: Localization.Library_interface_transmits_1_stop_bits_per_byte);
switch(page.CmdFwd)
{
case 0:
sb.AppendLine("\tCommand forwarding is disabled");
sb.AppendLine("\t" + Localization.Command_forwarding_is_disabled);
break;
case 1:
sb.AppendLine("\tCommand forwarding is enabled");
sb.AppendLine("\t" + Localization.Command_forwarding_is_enabled);
break;
default:
sb.AppendFormat("\tUnknown command forwarding code {0}", page.CmdFwd).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_command_forwarding_code_0, page.CmdFwd).AppendLine();
break;
}
@@ -157,30 +158,33 @@ public static partial class Modes
switch(page.PortATransportType)
{
case 0:
sb.AppendLine("\tPort A link is down");
sb.AppendLine("\t" + Localization.Port_A_link_is_down);
break;
case 3:
sb.AppendLine("\tPort A uses Parallel SCSI Ultra-160 interface");
sb.AppendLine("\t" + Localization.Port_A_uses_Parallel_SCSI_Ultra160_interface);
break;
default:
sb.AppendFormat("\tUnknown port A transport type code {0}", page.PortATransportType).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_port_A_transport_type_code_0, page.PortATransportType).
AppendLine();
break;
}
if(page.PortATransportType > 0)
sb.AppendFormat("\tDrive responds to SCSI ID {0}", page.PortAPresentSelectionID).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_responds_to_SCSI_ID_0, page.PortAPresentSelectionID).AppendLine();
sb.AppendFormat("\tDrive will respond to SCSI ID {0} on Port A enabling", page.NextSelectionID).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_will_respond_to_SCSI_ID_0_on_Port_A_enabling, page.NextSelectionID).
AppendLine();
sb.AppendFormat("\tDrive jumpers choose SCSI ID {0}", page.JumperedSelectionID).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_jumpers_choose_SCSI_ID_0, page.JumperedSelectionID).AppendLine();
sb.AppendLine(page.PortAEnabled ? "\tSCSI port is enabled" : "\tSCSI port is disabled");
sb.AppendLine(page.PortAEnabled ? "\t" + Localization.SCSI_port_is_enabled
: "\t" + Localization.SCSI_port_is_disabled);
sb.AppendLine(page.PortAEnabledOnPower ? "\tSCSI port will be enabled on next power up"
: "\tSCSI port will be disabled on next power up");
sb.AppendLine(page.PortAEnabledOnPower ? "\t" + Localization.SCSI_port_will_be_enabled_on_next_power_up
: "\t" + Localization.SCSI_port_will_be_disabled_on_next_power_up);
return sb.ToString();
}

12
SCSI/Modes/24_IBM.cs
View File

@@ -86,21 +86,21 @@ public static partial class Modes
IBM_ModePage_24 page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("IBM Vendor-Specific Control Mode Page:");
sb.AppendLine(Localization.IBM_Vendor_Specific_Control_Mode_Page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
sb.AppendFormat("\tVendor-specific mode control: {0}", page.ModeControl);
sb.AppendFormat("\tVendor-specific velocity setting: {0}", page.VelocitySetting);
sb.AppendFormat("\t" + Localization.Vendor_specific_mode_control_0, page.ModeControl);
sb.AppendFormat("\t" + Localization.Vendor_specific_velocity_setting_0, page.VelocitySetting);
if(!page.EncryptionCapable)
return sb.ToString();
sb.AppendLine("\tDrive supports encryption");
sb.AppendLine("\t" + Localization.Drive_supports_encryption);
if(page.EncryptionEnabled)
sb.AppendLine("\tDrive has encryption enabled");
sb.AppendLine("\t" + Localization.Drive_has_encryption_enabled);
return sb.ToString();
}

120
SCSI/Modes/2A.cs
View File

@@ -52,151 +52,159 @@ public static partial class Modes
var sb = new StringBuilder();
sb.AppendLine("SCSI CD-ROM capabilities page:");
sb.AppendLine(Localization.SCSI_CD_ROM_capabilities_page);
if(modePage.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(modePage.AudioPlay)
sb.AppendLine("\tDrive can play audio");
sb.AppendLine("\t" + Localization.Drive_can_play_audio);
if(modePage.Mode2Form1)
sb.AppendLine("\tDrive can read sectors in Mode 2 Form 1 format");
sb.AppendLine("\t" + Localization.Drive_can_read_sectors_in_Mode_2_Form_1_format);
if(modePage.Mode2Form2)
sb.AppendLine("\tDrive can read sectors in Mode 2 Form 2 format");
sb.AppendLine("\t" + Localization.Drive_can_read_sectors_in_Mode_2_Form_2_format);
if(modePage.MultiSession)
sb.AppendLine("\tDrive supports multi-session discs and/or Photo-CD");
sb.AppendLine("\t" + Localization.Drive_supports_multi_session_discs_and_or_Photo_CD);
if(modePage.CDDACommand)
sb.AppendLine("\tDrive can read digital audio");
sb.AppendLine("\t" + Localization.Drive_can_read_digital_audio);
if(modePage.AccurateCDDA)
sb.AppendLine("\tDrive can continue from streaming loss");
sb.AppendLine("\t" + Localization.Drive_can_continue_from_streaming_loss);
if(modePage.Subchannel)
sb.AppendLine("\tDrive can read uncorrected and interleaved R-W subchannels");
sb.AppendLine("\t" + Localization.Drive_can_read_uncorrected_and_interleaved_R_W_subchannels);
if(modePage.DeinterlaveSubchannel)
sb.AppendLine("\tDrive can read, deinterleave and correct R-W subchannels");
sb.AppendLine("\t" + Localization.Drive_can_read__deinterleave_and_correct_R_W_subchannels);
if(modePage.C2Pointer)
sb.AppendLine("\tDrive supports C2 pointers");
sb.AppendLine("\t" + Localization.Drive_supports_C2_pointers);
if(modePage.UPC)
sb.AppendLine("\tDrive can read Media Catalogue Number");
sb.AppendLine("\t" + Localization.Drive_can_read_Media_Catalogue_Number);
if(modePage.ISRC)
sb.AppendLine("\tDrive can read ISRC");
sb.AppendLine("\t" + Localization.Drive_can_read_ISRC);
switch(modePage.LoadingMechanism)
{
case 0:
sb.AppendLine("\tDrive uses media caddy");
sb.AppendLine("\t" + Localization.Drive_uses_media_caddy);
break;
case 1:
sb.AppendLine("\tDrive uses a tray");
sb.AppendLine("\t" + Localization.Drive_uses_a_tray);
break;
case 2:
sb.AppendLine("\tDrive is pop-up");
sb.AppendLine("\t" + Localization.Drive_is_pop_up);
break;
case 4:
sb.AppendLine("\tDrive is a changer with individually changeable discs");
sb.AppendLine("\t" + Localization.Drive_is_a_changer_with_individually_changeable_discs);
break;
case 5:
sb.AppendLine("\tDrive is a changer using cartridges");
sb.AppendLine("\t" + Localization.Drive_is_a_changer_using_cartridges);
break;
default:
sb.AppendFormat("\tDrive uses unknown loading mechanism type {0}", modePage.LoadingMechanism).
AppendLine();
sb.AppendFormat("\t" + Localization.Drive_uses_unknown_loading_mechanism_type__0_,
modePage.LoadingMechanism).AppendLine();
break;
}
if(modePage.Lock)
sb.AppendLine("\tDrive can lock media");
sb.AppendLine("\t" + Localization.Drive_can_lock_media);
if(modePage.PreventJumper)
{
sb.AppendLine("\tDrive power ups locked");
sb.AppendLine("\t" + Localization.Drive_power_ups_locked);
sb.AppendLine(modePage.LockState ? "\tDrive is locked, media cannot be ejected or inserted"
: "\tDrive is not locked, media can be ejected and inserted");
sb.AppendLine(modePage.LockState ? "\t" + Localization.Drive_is_locked__media_cannot_be_ejected_or_inserted
: "\t" + Localization.Drive_is_not_locked__media_can_be_ejected_and_inserted);
}
else
sb.AppendLine(modePage.LockState
? "\tDrive is locked, media cannot be ejected, but if empty, can be inserted"
: "\tDrive is not locked, media can be ejected and inserted");
? "\t" + Localization.
Drive_is_locked__media_cannot_be_ejected__but_if_empty__can_be_inserted
: "\t" + Localization.Drive_is_not_locked__media_can_be_ejected_and_inserted);
if(modePage.Eject)
sb.AppendLine("\tDrive can eject media");
sb.AppendLine("\t" + Localization.Drive_can_eject_media);
if(modePage.SeparateChannelMute)
sb.AppendLine("\tEach channel can be muted independently");
sb.AppendLine("\t" + Localization.Each_channel_can_be_muted_independently);
if(modePage.SeparateChannelVolume)
sb.AppendLine("\tEach channel's volume can be controlled independently");
sb.AppendLine("\t" + Localization.Each_channel_s_volume_can_be_controlled_independently);
if(modePage.SupportedVolumeLevels > 0)
sb.AppendFormat("\tDrive supports {0} volume levels", modePage.SupportedVolumeLevels).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_supports_0_volume_levels, modePage.SupportedVolumeLevels).
AppendLine();
if(modePage.BufferSize > 0)
sb.AppendFormat("\tDrive has {0} Kbyte of buffer", modePage.BufferSize).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_has_0_Kbyte_of_buffer, modePage.BufferSize).AppendLine();
if(modePage.MaximumSpeed > 0)
sb.AppendFormat("\tDrive's maximum reading speed is {0} Kbyte/sec.", modePage.MaximumSpeed).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_maximum_reading_speed_is_0_Kbyte_sec, modePage.MaximumSpeed).
AppendLine();
if(modePage.CurrentSpeed > 0)
sb.AppendFormat("\tDrive's current reading speed is {0} Kbyte/sec.", modePage.CurrentSpeed).AppendLine();
sb.AppendFormat("\t" + Localization.Drive_current_reading_speed_is_0_Kbyte_sec, modePage.CurrentSpeed).
AppendLine();
if(modePage.ReadCDR)
{
sb.AppendLine(modePage.WriteCDR ? "\tDrive can read and write CD-R" : "\tDrive can read CD-R");
sb.AppendLine(modePage.WriteCDR ? "\t" + Localization.Drive_can_read_and_write_CD_R
: "\t" + Localization.Drive_can_read_CD_R);
if(modePage.Method2)
sb.AppendLine("\tDrive supports reading CD-R packet media");
sb.AppendLine("\t" + Localization.Drive_supports_reading_CD_R_packet_media);
}
if(modePage.ReadCDRW)
sb.AppendLine(modePage.WriteCDRW ? "\tDrive can read and write CD-RW" : "\tDrive can read CD-RW");
sb.AppendLine(modePage.WriteCDRW ? "\t" + Localization.Drive_can_read_and_write_CD_RW
: "\t" + Localization.Drive_can_read_CD_RW);
if(modePage.ReadDVDROM)
sb.AppendLine("\tDrive can read DVD-ROM");
sb.AppendLine("\t" + Localization.Drive_can_read_DVD_ROM);
if(modePage.ReadDVDR)
sb.AppendLine(modePage.WriteDVDR ? "\tDrive can read and write DVD-R" : "\tDrive can read DVD-R");
sb.AppendLine(modePage.WriteDVDR ? "\t" + Localization.Drive_can_read_and_write_DVD_R
: "\t" + Localization.Drive_can_read_DVD_R);
if(modePage.ReadDVDRAM)
sb.AppendLine(modePage.WriteDVDRAM ? "\tDrive can read and write DVD-RAM" : "\tDrive can read DVD-RAM");
sb.AppendLine(modePage.WriteDVDRAM ? "\t" + Localization.Drive_can_read_and_write_DVD_RAM
: "\t" + Localization.Drive_can_read_DVD_RAM);
if(modePage.Composite)
sb.AppendLine("\tDrive can deliver a composite audio and video data stream");
sb.AppendLine("\t" + Localization.Drive_can_deliver_a_composite_audio_and_video_data_stream);
if(modePage.DigitalPort1)
sb.AppendLine("\tDrive supports IEC-958 digital output on port 1");
sb.AppendLine("\t" + Localization.Drive_supports_IEC_958_digital_output_on_port_1);
if(modePage.DigitalPort2)
sb.AppendLine("\tDrive supports IEC-958 digital output on port 2");
sb.AppendLine("\t" + Localization.Drive_supports_IEC_958_digital_output_on_port_2);
if(modePage.SDP)
sb.AppendLine("\tDrive contains a changer that can report the exact contents of the slots");
sb.AppendLine("\t" + Localization.Drive_contains_a_changer_that_can_report_the_exact_contents_of_the_slots);
if(modePage.CurrentWriteSpeedSelected > 0)
switch(modePage.RotationControlSelected)
{
case 0:
sb.AppendFormat("\tDrive's current writing speed is {0} Kbyte/sec. in CLV mode",
sb.AppendFormat("\t" + Localization.Drive_current_writing_speed_is_0_Kbyte_sec_in_CLV_mode,
modePage.CurrentWriteSpeedSelected).AppendLine();
break;
case 1:
sb.AppendFormat("\tDrive's current writing speed is {0} Kbyte/sec. in pure CAV mode",
sb.AppendFormat("\t" + Localization.Drive_current_writing_speed_is_0_Kbyte_sec_in_pure_CAV_mode,
modePage.CurrentWriteSpeedSelected).AppendLine();
break;
@@ -204,12 +212,12 @@ public static partial class Modes
else
{
if(modePage.MaxWriteSpeed > 0)
sb.AppendFormat("\tDrive's maximum writing speed is {0} Kbyte/sec.", modePage.MaxWriteSpeed).
sb.AppendFormat("\t" + Localization.Drive_maximum_writing_speed_is_0_Kbyte_sec, modePage.MaxWriteSpeed).
AppendLine();
if(modePage.CurrentWriteSpeed > 0)
sb.AppendFormat("\tDrive's current writing speed is {0} Kbyte/sec.", modePage.CurrentWriteSpeed).
AppendLine();
sb.AppendFormat("\t" + Localization.Drive_current_writing_speed_is_0_Kbyte_sec,
modePage.CurrentWriteSpeed).AppendLine();
}
if(modePage.WriteSpeedPerformanceDescriptors != null)
@@ -218,34 +226,34 @@ public static partial class Modes
switch(descriptor.RotationControl)
{
case 0:
sb.AppendFormat("\tDrive supports writing at {0} Kbyte/sec. in CLV mode",
sb.AppendFormat("\t" + Localization.Drive_supports_writing_at_0_Kbyte_sec_in_CLV_mode,
descriptor.WriteSpeed).AppendLine();
break;
case 1:
sb.AppendFormat("\tDrive supports writing at is {0} Kbyte/sec. in pure CAV mode",
sb.AppendFormat("\t" + Localization.Drive_supports_writing_at_is_0_Kbyte_sec_in_pure_CAV_mode,
descriptor.WriteSpeed).AppendLine();
break;
}
if(modePage.TestWrite)
sb.AppendLine("\tDrive supports test writing");
sb.AppendLine("\t" + Localization.Drive_supports_test_writing);
if(modePage.ReadBarcode)
sb.AppendLine("\tDrive can read barcode");
sb.AppendLine("\t" + Localization.Drive_can_read_barcode);
if(modePage.SCC)
sb.AppendLine("\tDrive can read both sides of a disc");
sb.AppendLine("\t" + Localization.Drive_can_read_both_sides_of_a_disc);
if(modePage.LeadInPW)
sb.AppendLine("\tDrive an read raw R-W subchannel from the Lead-In");
sb.AppendLine("\t" + Localization.Drive_an_read_raw_R_W_subchannel_from_the_Lead_In);
if(modePage.CMRSupported == 1)
sb.AppendLine("\tDrive supports DVD CSS and/or DVD CPPM");
sb.AppendLine("\t" + Localization.Drive_supports_DVD_CSS_and_or_DVD_CPPM);
if(modePage.BUF)
sb.AppendLine("\tDrive supports buffer under-run free recording");
sb.AppendLine("\t" + Localization.Drive_supports_buffer_under_run_free_recording);
return sb.ToString();
}

44
SCSI/Modes/2F_IBM.cs
View File

@@ -98,23 +98,23 @@ public static partial class Modes
IBM_ModePage_2F page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("IBM Behaviour Configuration Mode Page:");
sb.AppendLine(Localization.IBM_Behaviour_Configuration_Mode_Page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
switch(page.FenceBehaviour)
{
case 0:
sb.AppendLine("\tFence behaviour is normal");
sb.AppendLine("\t" + Localization.Fence_behaviour_is_normal);
break;
case 1:
sb.AppendLine("\tPanic fence behaviour is enabled");
sb.AppendLine("\t" + Localization.Panic_fence_behaviour_is_enabled);
break;
default:
sb.AppendFormat("\tUnknown fence behaviour code {0}", page.FenceBehaviour).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_fence_behaviour_code_0, page.FenceBehaviour).AppendLine();
break;
}
@@ -122,15 +122,16 @@ public static partial class Modes
switch(page.CleanBehaviour)
{
case 0:
sb.AppendLine("\tCleaning behaviour is normal");
sb.AppendLine("\t" + Localization.Cleaning_behaviour_is_normal);
break;
case 1:
sb.AppendLine("\tDrive will periodically request cleaning");
sb.AppendLine("\t" + Localization.Drive_will_periodically_request_cleaning);
break;
default:
sb.AppendFormat("\tUnknown cleaning behaviour code {0}", page.CleanBehaviour).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_cleaning_behaviour_code_0, page.CleanBehaviour).
AppendLine();
break;
}
@@ -138,15 +139,15 @@ public static partial class Modes
switch(page.WORMEmulation)
{
case 0:
sb.AppendLine("\tWORM emulation is disabled");
sb.AppendLine("\t" + Localization.WORM_emulation_is_disabled);
break;
case 1:
sb.AppendLine("\tWORM emulation is enabled");
sb.AppendLine("\t" + Localization.WORM_emulation_is_enabled);
break;
default:
sb.AppendFormat("\tUnknown WORM emulation code {0}", page.WORMEmulation).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_WORM_emulation_code_0, page.WORMEmulation).AppendLine();
break;
}
@@ -154,39 +155,40 @@ public static partial class Modes
switch(page.SenseDataBehaviour)
{
case 0:
sb.AppendLine("\tUses 35-bytes sense data");
sb.AppendLine("\t" + Localization.Uses_35_bytes_sense_data);
break;
case 1:
sb.AppendLine("\tUses 96-bytes sense data");
sb.AppendLine("\t" + Localization.Uses_96_bytes_sense_data);
break;
default:
sb.AppendFormat("\tUnknown sense data behaviour code {0}", page.WORMEmulation).AppendLine();
sb.AppendFormat("\t" + Localization.Unknown_sense_data_behaviour_code_0, page.WORMEmulation).
AppendLine();
break;
}
if(page.CLNCHK)
sb.AppendLine("\tDrive will set Check Condition when cleaning is needed");
sb.AppendLine("\t" + Localization.Drive_will_set_Check_Condition_when_cleaning_is_needed);
if(page.DDEOR)
sb.AppendLine("\tNo deferred error will be reported to a rewind command");
sb.AppendLine("\t" + Localization.No_deferred_error_will_be_reported_to_a_rewind_command);
if(page.CCDM)
sb.AppendLine("\tDrive will set Check Condition when the criteria for Dead Media is met");
sb.AppendLine("\t" + Localization.Drive_will_set_Check_Condition_when_the_criteria_for_Dead_Media_is_met);
if(page.FirmwareUpdateBehaviour > 0)
sb.AppendLine("\tDrive will not accept downlevel firmware via an FMR tape");
sb.AppendLine("\t" + Localization.Drive_will_not_accept_downlevel_firmware_via_an_FMR_tape);
if(page.UOE_C == 1)
sb.AppendLine("\tDrive will eject cleaning cartridges on error");
sb.AppendLine("\t" + Localization.Drive_will_eject_cleaning_cartridges_on_error);
if(page.UOE_F == 1)
sb.AppendLine("\tDrive will eject firmware cartridges on error");
sb.AppendLine("\t" + Localization.Drive_will_eject_firmware_cartridges_on_error);
if(page.UOE_D == 1)
sb.AppendLine("\tDrive will eject data cartridges on error");
sb.AppendLine("\t" + Localization.Drive_will_eject_data_cartridges_on_error);
return sb.ToString();
}

10
SCSI/Modes/3B_HP.cs
View File

@@ -85,24 +85,24 @@ public static partial class Modes
HP_ModePage_3B page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("HP Serial Number Override Mode Page:");
sb.AppendLine(Localization.HP_Serial_Number_Override_Mode_Page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
switch(page.MSN)
{
case 1:
sb.AppendLine("\tSerial number is the manufacturer's default value");
sb.AppendLine("\t" + Localization.Serial_number_is_the_manufacturer_default_value);
break;
case 3:
sb.AppendLine("\tSerial number is not the manufacturer's default value");
sb.AppendLine("\t" + Localization.Serial_number_is_not_the_manufacturer_default_value);
break;
}
sb.AppendFormat("\tSerial number: {0}", StringHandlers.CToString(page.SerialNumber)).AppendLine();
sb.AppendFormat("\t" + Localization.Serial_number_0, StringHandlers.CToString(page.SerialNumber)).AppendLine();
return sb.ToString();
}

24
SCSI/Modes/3C_HP.cs
View File

@@ -112,36 +112,36 @@ public static partial class Modes
HP_ModePage_3C page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("HP Device Time Mode Page:");
sb.AppendLine(Localization.HP_Device_Time_Mode_Page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.PT)
{
sb.AppendFormat("\tDrive has been powered up {0} times", page.CurrentPowerOn);
sb.AppendFormat("\t" + Localization.Drive_has_been_powered_up_0_times, page.CurrentPowerOn);
sb.AppendFormat("\tDrive has been powered up since {0} this time", TimeSpan.FromSeconds(page.PowerOnTime)).
AppendLine();
sb.AppendFormat("\t" + Localization.Drive_has_been_powered_up_since_0_seconds_ago_this_time,
TimeSpan.FromSeconds(page.PowerOnTime)).AppendLine();
sb.AppendFormat("\tDrive has been powered up a total of {0}", TimeSpan.FromSeconds(page.CumulativePowerOn)).
AppendLine();
sb.AppendFormat("\t" + Localization.Drive_has_been_powered_up_a_total_of_0_seconds,
TimeSpan.FromSeconds(page.CumulativePowerOn)).AppendLine();
}
if(page.WT)
{
sb.AppendFormat("\tDrive's date/time is: {0}", DateHandlers.UnixUnsignedToDateTime(page.WorldTime)).
AppendLine();
sb.AppendFormat("\t" + Localization.Drive_date_time_is_0,
DateHandlers.UnixUnsignedToDateTime(page.WorldTime)).AppendLine();
if(page.UTC)
sb.AppendLine("\tDrive's time is UTC");
sb.AppendLine("\t" + Localization.Drive_time_is_UTC);
if(page.NTP)
sb.AppendLine("\tDrive's time is synchronized with a NTP source");
sb.AppendLine("\t" + Localization.Drive_time_is_synchronized_with_a_NTP_source);
}
if(page.LT)
sb.AppendFormat("\tLibrary time is {0}",
sb.AppendFormat("\t" + Localization.Library_time_is_0,
new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, page.LibraryHours,
page.LibraryMinutes, page.LibrarySeconds)).AppendLine();

10
SCSI/Modes/3D_HP.cs
View File

@@ -80,23 +80,23 @@ public static partial class Modes
HP_ModePage_3D page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("HP Extended Reset Mode Page:");
sb.AppendLine(Localization.HP_Extended_Reset_Mode_Page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
switch(page.ResetBehaviour)
{
case 0:
sb.AppendLine("\tNormal reset behaviour");
sb.AppendLine("\t" + Localization.Normal_reset_behaviour);
break;
case 1:
sb.AppendLine("\tDrive will flush and position itself on a LUN or target reset");
sb.AppendLine("\t" + Localization.Drive_will_flush_and_position_itself_on_a_LUN_or_target_reset);
break;
case 2:
sb.AppendLine("\tDrive will maintain position on a LUN or target reset");
sb.AppendLine("\t" + Localization.Drive_will_maintain_position_on_a_LUN_or_target_reset);
break;
}

6
SCSI/Modes/3D_IBM.cs
View File

@@ -80,12 +80,12 @@ public static partial class Modes
IBM_ModePage_3D page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("IBM LEOT Mode Page:");
sb.AppendLine(Localization.IBM_LEOT_Mode_Page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
sb.AppendFormat("\t{0} wraps", page.NumberOfWraps).AppendLine();
sb.AppendFormat("\t" + Localization._0_wraps, page.NumberOfWraps).AppendLine();
return sb.ToString();
}

18
SCSI/Modes/3E_Fujitsu.cs
View File

@@ -112,35 +112,35 @@ public static partial class Modes
Fujitsu_ModePage_3E page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("Fujitsu Verify Control Page:");
sb.AppendLine(Localization.Fujitsu_Verify_Control_Page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
if(page.audioVisualMode)
sb.AppendLine("\tAudio/Visual data support mode is applied");
sb.AppendLine("\t" + Localization.Audio_Visual_data_support_mode_is_applied);
if(page.streamingMode)
sb.AppendLine("\tTest write operation is restricted during read or write operations.");
sb.AppendLine("\t" + Localization.Test_write_operation_is_restricted_during_read_or_write_operations);
switch(page.verifyMode)
{
case Fujitsu_VerifyModes.Always:
sb.AppendLine("\tAlways apply the verify operation");
sb.AppendLine("\t" + Localization.Always_apply_the_verify_operation);
break;
case Fujitsu_VerifyModes.Never:
sb.AppendLine("\tNever apply the verify operation");
sb.AppendLine("\t" + Localization.Never_apply_the_verify_operation);
break;
case Fujitsu_VerifyModes.Depends:
sb.AppendLine("\tApply the verify operation depending on the condition");
sb.AppendLine("\t" + Localization.Apply_the_verify_operation_depending_on_the_condition);
break;
}
sb.AppendFormat("\tThe device type that would be provided in the INQUIRY response is {0}", page.devType).
AppendLine();
sb.AppendFormat("\t" + Localization.The_device_type_that_would_be_provided_in_the_INQUIRY_response_is_0,
page.devType).AppendLine();
return sb.ToString();
}

9
SCSI/Modes/3E_HP.cs
View File

@@ -82,15 +82,16 @@ public static partial class Modes
HP_ModePage_3E page = modePage.Value;
var sb = new StringBuilder();
sb.AppendLine("HP CD-ROM Emulation/Disaster Recovery Mode Page:");
sb.AppendLine(Localization.HP_CD_ROM_Emulation_Disaster_Recovery_Mode_Page);
if(page.PS)
sb.AppendLine("\tParameters can be saved");
sb.AppendLine("\t" + Localization.Parameters_can_be_saved);
sb.AppendLine(page.CDmode ? "\tDrive is emulating a CD-ROM drive" : "\tDrive is not emulating a CD-ROM drive");
sb.AppendLine(page.CDmode ? "\t" + Localization.Drive_is_emulating_a_CD_ROM_drive
: "\t" + Localization.Drive_is_not_emulating_a_CD_ROM_drive);
if(page.NonAuto)
sb.AppendLine("\tDrive will not exit emulation automatically");
sb.AppendLine("\t" + Localization.Drive_will_not_exit_emulation_automatically);
return sb.ToString();
}

869
SCSI/Modes/Headers.cs
View File

File diff suppressed because it is too large Load Diff