Projekte > Optische Laufwerke > Merkmale

Random Readable

GET CONFIGURATION Command - Operation Code $46
RANDOM READABLE FEATURE - Feature Number $0010

Im Kapitel Feature wurde die Feature List ermittelt. Das Random Readable Feature ist in den Multimedia Commands 6 in Kapitel 5.3.6 beschreiben. Es gibt an, ob das Laufwerk Daten in zufälliger Folge von logischen Blöcken, welche durch logische Blockadressen angegeben werden, lesen kann.

Der Command Descriptor Block:

  7 6 5 4 3 2 1 0
0 Operation Code = $46
1 Reserviert RT = 10b
2 Starting Feature Number = $0010
3
4 Reserviert
5
6
7 Allocation Length = $0014
8
9 Control

 

Die Werte:

Byte 0 Operation Code - $46 GET CONFIGURATION Command

Byte 1 Request Type (RT) - 10b Feature Header, auch wenn das Feature nicht unterstützt wird.

Wert Beschreibung
00b Das Laufwerk soll den Feature Header und alle durch das Laufwerk unterstützten Feature Beschreibungen zurückgeben ohne Rücksicht auf Geltung.
01b Das Laufwerk soll den Feature Header und nur die gewählte Feature Beschreibung zurückgeben.
10b Das Laufwerk soll den Feature Header und nur die gewählte Feature Beschreibung zurückgeben. Wird das Feature nicht unterstützt, soll nur der Feature Header zurückgegeben werden.
11b Reserviert

 
Byte 2 und 3 Starting Feature Number - $0010: Die Nummer des Random Readable Features, welches ausgegeben werden soll.

Byte 7 und 8 Allocation Length - $0014: Länge der Antwortstruktur. Die Antwort besteht aus dem Feature Header (acht Byte) und der RANDOM READABLE Feature Beschreibung (zwölf Byte), also 20 Byte.

Byte 9: Control - ?
 

Antwortstruktur

Der Feature Header:

  7 6 5 4 3 2 1 0
0 Data Length
1
2
3
4 Reserviert
5
6 Current Profile
7

 
Data Length - Die Datenlänge im Header gibt die Länge des noch folgenden Headerrestes und der Feature Beschreibungen an. Der Wert ist ein Vielfaches von vier und beträgt 16 wenn das Feature vorhanden ist.

Current Profile - Gibt das aktive Profil an. Das Profil ist vom Laufwerk und dem eingelegten Datenträger abhängig. Sind mehrere Profile aktiv wird das Profil mit der höchsten Nummer angegeben. (Liste der Profile in einem Fenster öffnen.)

Die Feature Beschreibung:

  7 6 5 4 3 2 1 0
0 Feature Code = $0010
1
2 Reserviert Version = 0000b Persistent Current
3 Additional Length = $08
4 Logical Block Size
5
6
7
8 Blocking
9
10 Reserviert PP
11 Reserviert

 
Feature Code - Gibt die Nummer des abgerufenen Features an. Wird es unterstützt folgt die Beschreibung.

Version - Die Versionsnummer ist von unterstützten Standard und dem Feature abhängig.

Persistent - Gibt an, ob der Status geändert werden kann oder ob das Feature ständig aktiv ist.

Current - Gibt an, ob das Feature gegenwärtig aktiv ist und featureabhängige Daten vorhanden sind.

Additional Length - Wird das Feature unterstützt ist der Wert acht, anderenfalls null.

Logical Block Size - Die Größe eines logischen Blockes in Bytes. Diesen Wert erhält man auch mit dem READ CAPACITY command.

Blocking - Die Anzahl der logischen Blöcke, welche auf einmal eingelesen werden können. Der Wert ist vom eingelegten Medium abhängig. Für CD $01, für DVD $10 und BD $20.

PP (Page Present) - Gibt an, ob die Read/Write Error Recovery mode page vorhanden ist. Die Flags für TB, RC, PER, DTE und DCR des Read/Write Error Recovery mode page Descriptor werden dann unterstützt.

Wenn das RANDOM READABLE Feature unterstützt wird, werden auch diese Commands und Mode Pages unterstützt:

  • $25 - READ CAPACITY Command
  • $28 - READ (10) Command
  • $01 - Read/Write Error Recovery Mode Page mit den Command TB, RC, PER, DTE und DCR Flags (wenn PP gesetzt ist).

 

Deklarationen

Zusätzlich zu den Deklarationen im Kapitel Feature werden diese vorgenommen:

 
  const
    FEATURE_RANDOM_READABLE  = $0010;
 
  type
    TGET_CONFIGURATION_RANDOM_READABLE = record
      Header : array[0..$07] of Byte;
      Data   : array[0..$0B] of Byte;
    end;
    PGET_CONFIGURATION_RANDOM_READABLE = ^TGET_CONFIGURATION_RANDOM_READABLE;
 
  type
    TFeatureRandomReadable = record
      FeatureCode      : Word;
      Version          : Byte;
      Persistent       : Boolean;
      Current          : Boolean;
      AdditionalLength : Byte;
      LogicalBlockSize : Cardinal;
      Blocking         : Word;
      PP               : Boolean;
    end;
        

 

Ausführung

Nach der Ausführung wird die Antwortstruktur ausgewertet. Beispiel einer Funktion:

 
  function TOptDrives.ReadConfigRandomReadable(aDevice: THandle): Boolean;
  {*******************************************************************************
  *  Random Readable Feature
  }
  var
    GET_CONFIGURATION_CDB : TGET_CONFIGURATION_CDB;
    pConfigRandomReadable : PGET_CONFIGURATION_RANDOM_READABLE;
    aCDB                  : Array of Byte;
    DataLength            : Cardinal;
  begin
    Result := False;
    {
    *  Random Readable Feature initialisieren.
    }
    FillChar(FDrive[FActive].RandomReadable, SizeOf(TFeatureRandomReadable), $00);
    {
    *  Den Command Descriptor Block füllen.
    }
    ZeroMemory(@GET_CONFIGURATION_CDB, SizeOf(TGET_CONFIGURATION_CDB));
    GET_CONFIGURATION_CDB.OperationCode         := SCSIOP_GET_CONFIGURATION;
    GET_CONFIGURATION_CDB.RequestType           := RT_Identified;
    GET_CONFIGURATION_CDB.StartingFeatureNumber := FEATURE_RANDOM_READABLE;
    GET_CONFIGURATION_CDB.AllocationLength      :=
                                        SizeOf(TGET_CONFIGURATION_RANDOM_READABLE);
    {
    *  Den Command Descriptor Block übertragen.
    }
    SetLength(aCDB, 10);
    aCDB[0] := GET_CONFIGURATION_CDB.OperationCode;
    aCDB[1] := GET_CONFIGURATION_CDB.RequestType;
    aCDB[2] := HiByte(GET_CONFIGURATION_CDB.StartingFeatureNumber);
    aCDB[3] := LoByte(GET_CONFIGURATION_CDB.StartingFeatureNumber);
    aCDB[7] := HiByte(GET_CONFIGURATION_CDB.AllocationLength);
    aCDB[8] := LoByte(GET_CONFIGURATION_CDB.AllocationLength);
    {
    *  Befehl ausführen
    }
    GetMem(pConfigRandomReadable, SizeOf(TGET_CONFIGURATION_RANDOM_READABLE));
    if GET_SCSI_PASS_THROUGH_DIRECT(aDevice, aCDB, pConfigRandomReadable,
                                    SizeOf(TGET_CONFIGURATION_RANDOM_READABLE))
    then begin
      {
      *  Wenn die Ausführung erfolgreich war ...
      }
      DataLength := pConfigRandomReadable.Header[0] shl 24 or
                    pConfigRandomReadable.Header[1] shl 16 or
                    pConfigRandomReadable.Header[2] shl  8 or
                    pConfigRandomReadable.Header[3];
      {
       *  Wenn das Random Readable Feature existiert.
      }
      if DataLength >= 4 then
      with FDrive[FActive].RandomReadable
      do begin
        FeatureCode      := pConfigRandomReadable.Data[0] shl 8 or
                            pConfigRandomReadable.Data[1];
        Version          := pConfigRandomReadable.Data[2] and $3C shr 2;
        Persistent       := pConfigRandomReadable.Data[2] and $02 > 0;
        Current          := pConfigRandomReadable.Data[2] and $01 > 0;
        AdditionalLength := pConfigRandomReadable.Data[3];
        {
        *  Wenn Daten existieren.
        }
        if AdditionalLength = 8
        then begin
          LogicalBlockSize := pConfigRandomReadable.Data[4] shl 24 or
                              pConfigRandomReadable.Data[5] shl 16 or
                              pConfigRandomReadable.Data[6] shl 8 or
                              pConfigRandomReadable.Data[7];
          Blocking         := pConfigRandomReadable.Data[8] shl 8 or
                              pConfigRandomReadable.Data[9];
          PagePresent      := pConfigRandomReadable.Data[10] and $01 > 0;
        end;
        {
        *  Ergebnis
        }
        Result := FeatureCode = FEATURE_RANDOM_READABLE;
      end;
    end;
  end;
          

 

Demo, welche diese Funktion nutzt:

Random Readable (podRandomReadalbe.7z - 252 kb) MD5 (1 kb). Stand: 2. Juni 2013

Änderungen an der Demo

Datum Beschreibung
02.06.2013Kleine Überarbeitung und neuer Name.