using System;

using System.Text;

​

public interface IAdditionSubtraction<T> where T : IAdditionSubtraction<T>

{

}

​

public interface ISAS<T> where T: ISspIu

{

    void sendSsp(SspFrame<T> ssp);

    void sendAddr(Addrframe addr);

}

​

public class MySAS<T> : ISAS<T> where T: ISspIu

{

    void sendAddr(Addrframe addr)

    {

    }

    public void sendSsp(SspFrame<T> ssp)

    {

    }

}

​

public class MySAS : ISAS<DataFrameIU>

{

    void sendAddr(Addrframe addr)

    {

    }

    public void sendSsp(SspFrame<DataFrameIU> ssp)

    {

    }

}

​

public record Addrframe(int type);

​

public interface ISspIu

{

    SspFrameType FrameType { get; }

}

​

    public record SspFrame<T> (

        //SspFrameType FrameType,

        UInt32 HashedDestinationSASAddress,

        UInt32 HashedSourceSASAddress,

        UInt16 InitiatorPortTransferTag,

        T IU,

        UInt32 DataOffset = 0,

        SspTLRControl TLRControl = SspTLRControl.UseModePage,

        bool RetryDataFrames = false,

        bool Retransmit = false,

        bool ChangingDataPointer = false,

        UInt16 TargetPortTransferTag = 0,

        byte NumberOfFillBytes = 0,

        bool CRC = false)

        where T: ISspIu

{

    public SspFrameType FrameType => IU.FrameType;

}

    /// <summary>

    ///  Frame types

    /// </summary>

    public enum SspFrameType : byte

    {

        DATA = 0x01,

        XFER_RDY = 0x05,

        COMMAND = 0x06,

        RESPONSE = 0x07,

        TASK = 0x16,

    }

​

        /// <summary>

        /// TLR control field set for COMMAND frame

        /// </summary>

        public enum SspTLRControl : byte

        {

            UseModePage = 0b00, // TLR Control 0b00 and 0b11 description is same

            MayEnable = 0b01,

            Disable = 0b10,

            UseModePage_ = 0b11, // TLR Control 0b00 and 0b11 description is same

        }

​

        /// <summary>

        /// categorization of commands that helps in scheduling of a command

        /// </summary>

        public enum SspTaskAttribute : byte

        {

            SIMPLE = 0b000,

            HEAD_OF_QUEUE = 0b001,

            ORDERED = 0b010,

            RESERVED = 0b011,

            ACA = 0b100,

        }

​

        /// <summary>

        /// a field in TASK frame

        /// task manager or device server shall perform the specified task management function

        /// </summary>

        public enum SspTaskManagementFunction : byte

        {

            ABORT_TASK = 0x01,

            ABORT_TASK_SET = 0x02,

            CLEAR_TASK_SET = 0x04,

            LOGICAL_UNIT_RESET = 0x08,

            ITNEXUS_RESET = 0x10,

            CLEAR_ACA = 0x40,

            QUERY_TASK = 0x80,

            QUERY_TASK_SET = 0x81,

            QUERY_ASYNCHRONOUS_EVENT = 0x82,

        }

​

        /// <summary>

        ///  indicating the format and content of some fields within the RESPONSE frame

        /// </summary>

        public enum SspDataPres : byte

        {

            NO_DATA = 0b00,

            RESPONSE_DATA = 0b01,

            SENSE_DATA = 0b10,

        }

​

        /// <summary>

        /// specifies the error condition or the completion status of a task management function.

        /// </summary>

        public enum SspResponseCode : byte

        {

            TASK_MANAGEMENT_FUNCTION_COMPLETE = 0x00,

            INVALID_FRAME = 0x02,

            TASK_MANAGEMENT_FUNCTION_NOT_SUPPORTED = 0x04,

            TASK_MANAGEMENT_FUNCTION_FAILED = 0x05,

            TASK_MANAGEMENT_FUNCTION_SUCCEEDED = 0x08,

            INCORRECT_LOGICAL_UNIT_NUMBER = 0x09,

            OVERLAPPED_INITIATOR_PORT_TRANSFER_TAG_ATTEMPTED = 0x0A,

        }

​

        /// <summary>

        /// necessary details of COMMAND frame

        /// </summary>

        public record CommandFrameIU(

            ReadOnlyMemory<byte> CDB,

            ReadOnlyMemory<byte> EntireCDB,

            ReadOnlyMemory<byte> AdditionalCDBBytes,

            UInt64 LogicalUnitNumber = 0,

            byte EnableFirstBurst = 0,

            byte CommandPriority = 0,

            SspTaskAttribute TaskAttribute = 0,

            byte AdditionalCDBLength = 0 ) : ISspIu

    {

        public SspFrameType FrameType => SspFrameType.COMMAND;

    }

​

        /// <summary>

        /// necessary details of TASK frame

        /// </summary>

        public record TaskFrameIU(

            uint IntiatorPortTransferTagToManage,

            UInt64 LogicalUnitNumber = 0,

            SspTaskManagementFunction TaskManagementFunction = 0) : ISspIu

    {

        public SspFrameType FrameType => SspFrameType.TASK;

    }

​

        /// <summary>

        /// necessary details of XFER_RDY frame

        /// </summary>

        public record Xfer_RdyFrameIU(

            UInt32 RequestedOffset,

            UInt32 WriteDataLength) : ISspIu

    {

        public SspFrameType FrameType => SspFrameType.XFER_RDY;

    }

​

        /// <summary>

        /// necessary details of DATA frame

        /// </summary>

        public record DataFrameIU(ReadOnlyMemory<byte> Data) : ISspIu

    {

        public SspFrameType FrameType => SspFrameType.DATA;

    }

​

        /// <summary>

        /// necessary details of RESPONSE frame

        /// </summary>

        public record ResponseFrameIU(

            uint StatusQualifier,

            SspDataPres Datapres,

            byte Status,

            UInt32 SenseDataLength,

            UInt32 ResponseDataLength,

            ReadOnlyMemory<byte> ResponseData,

            ReadOnlyMemory<byte> SenseData,

            ReadOnlyMemory<byte> AdditionalResponseInformation,

            SspResponseCode ResponseCode) : ISspIu

    {

        public SspFrameType FrameType => SspFrameType.RESPONSE;

    }

​

​

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Hello World");

        var myCustomerData = Encoding.ASCII.GetBytes("My important Customer Data");

        var myDataIU = new DataFrameIU(myCustomerData);

        var myDataFrame = new SspFrame<DataFrameIU>(/*SspFrameType.DATA,*/ 1, 2, 0, myDataIU);

​

        var myXFer_RdyIU = new Xfer_RdyFrameIU(0,0x100);

        var myXferRdyframe = new SspFrame<Xfer_RdyFrameIU>(/*SspFrameType.XFER_RDY,*/ 1, 2, 1, myXFer_RdyIU, CRC: true);

        var myXferRdyframe1 = new SspFrame<Xfer_RdyFrameIU>(/*SspFrameType.XFER_RDY,*/ 1, 2, 2, new Xfer_RdyFrameIU(0,0x100));

​

        var responseData = new byte[] {0,1,2,3,4,5};

        var senseData = new byte[] {11,22,33,44,55};

        byte[] additionalResponseInfo = null;

        var myResponseIU = new ResponseFrameIU(0, SspDataPres.NO_DATA, 0, 0, 0, responseData, senseData, additionalResponseInfo, SspResponseCode.TASK_MANAGEMENT_FUNCTION_COMPLETE);

        var myResponseframe = new SspFrame<ResponseFrameIU>(/*SspFrameType.RESPONSE,*/ 1, 2, 3, myResponseIU);

        Console.WriteLine(myDataFrame);

        Console.WriteLine(myDataFrame.IU);

        Console.WriteLine(myXferRdyframe);

        Console.WriteLine(myXferRdyframe.IU);

        Console.WriteLine(myXferRdyframe1);

        Console.WriteLine(myXferRdyframe1.IU);

        Console.WriteLine(myResponseframe);

        Console.WriteLine(myResponseframe.IU);

    }

}