//craited by hamuda shokree

unit uIdeDriveInfo;

interface


uses
Windows ,
SysUtils ,
Classes;


const
DFP_GET_VERSION = $00074080;
DFP_SEND_DRIVE_COMMAND = $0007C084;
DFP_RECEIVE_DRIVE_DATA = $0007C088;
IDE_IDENTIFY_DEVICE = $EC;


type
{$Z1}
TDevices = (dmIdePrimary0 , dmIdePrimary1 , dmIdeSecondary0 ,
dmIdeSecondary1 , dmAtapiPrimary0 , dmAtapiPrimary1 ,
dmAtapiSecondary0 , dmAtapiSecondary1);


TDeviceMap = set of TDevices;


TCapability = (cpIdeIdentify , cpAtapiIdentify , cpSmart ,
cpReserved03 , cpReserved04 , cpReserved05 , cpReserved06 ,
cpReserved07 , cpReserved08 , cpReserved09 , cpReserved10 ,
cpReserved11 , cpReserved12 , cpReserved13 , cpReserved14 ,
cpReserved15 , cpReserved16 , cpReserved17 , cpReserved18 ,
cpReserved19 , cpReserved20 , cpReserved21 , cpReserved22 ,
cpReserved23 , cpReserved24 , cpReserved25 , cpReserved26 ,
cpReserved27 , cpReserved28 , cpReserved29 , cpReserved30 ,
cpReserved31);


TCapabilities = set of TCapability;


PGetVersionOutParams = ^TGetVersionOutParams;
TGetVersionOutParams = packed record
Version: Byte;
Revision: Byte;
Reserved1: Byte;
IdeDeviceMap: TDeviceMap;
Capabilities: TCapabilities;
Reserved2: array[0..3] of DWord end;


PIdeRegs = ^TIdeRegs;
TIdeRegs = packed record
FeaturesReg: Byte;
SectorCount: Byte;
SectorNumber: Byte;
CylLow: Byte;
CylHigh: Byte;
DriveHead: Byte;
Command: Byte;
Reserved: Byte end;


PSendCmdInParams = ^TSendCmdInParams;
TSendCmdInParams = packed record
BufferSize: DWord;
DriveRegs: TIdeRegs;
DriveNumber: Byte;
Reserved1: array[1..3] of Byte;
Reserved2: array[0..3] of DWord end;


PDriverStatus = ^TDriverStatus;
TDriverStatus = packed record
DriverError: Byte;
IdeStatus: Byte;
Reserved1: array[2..3] of Byte;
Reserved2: array[0..1] of DWord end;


PSendCmdOutParams = ^TSendCmdOutParams;
TSendCmdOutParams = packed record
BufferSize: DWord;
DriverStatus: TDriverStatus;
Buffer: array[0..255] of Word end;


const
DriveNumberMin = 0;
DriveNumberMax = 3;


type
TDriveNumber = DriveNumberMin..DriveNumberMax;


TIdeDriveInfo = class(TComponent)
private
FCylinders: array[TDriveNumber] of Integer;
FFirmwareRevision: array[TDriveNumber] of String;
FHeads: array[TDriveNumber] of Integer;
FModelNumber: array[TDriveNumber] of String;
FRemovableMedia: array[TDriveNumber] of Boolean;
FSectorsPerTrack: array[TDriveNumber] of Integer;
FSerialNumber: array[TDriveNumber] of String;
protected
procedure CheckDriveNumber(Drive: TDriveNumber); virtual;
function GetCylinders(Drive: TDriveNumber): Integer; virtual;
function GetFirmwareRevision(Drive: TDriveNumber): String;
virtual;
function GetHeads(Drive: TDriveNumber): Integer; virtual;
function GetModelNumber(Drive: TDriveNumber): String; virtual;
function GetRemovableMedia(Drive: TDriveNumber): Boolean;
virtual;
function GetSectorsPerTrack(Drive: TDriveNumber): Integer;
virtual;
function GetSerialNumber(Drive: TDriveNumber): String; virtual;
procedure QueryDrive(Drive: TDriveNumber); virtual;
public
constructor Create(AOwner: TComponent); override;
property Cylinders[Drive: TDriveNumber]: Integer
read GetCylinders;
property FirmwareRevision[Drive: TDriveNumber]: String
read GetFirmwareRevision;
property Heads[Drive: TDriveNumber]: Integer read GetHeads;
property ModelNumber[Drive: TDriveNumber]: String
read GetModelNumber;
property RemovableMedia[Drive: TDriveNumber]: Boolean
read GetRemovableMedia;
property SectorsPerTrack[Drive: TDriveNumber]: Integer
read GetSectorsPerTrack;
property SerialNumber[Drive: TDriveNumber]: String
read GetSerialNumber; end;


EIdeDriveInfo = class(Exception);


procedure Register;


implementation


procedure Register;
begin
RegisterComponents( ' HAMUDA ' , [TIdeDriveInfo]) end;


constructor TIdeDriveInfo.Create(AOwner: TComponent);
var
I: TDriveNumber;
begin
inherited Create(AOwner);
for I : = DriveNumberMin to DriveNumberMax do
QueryDrive(I) end;


procedure TIdeDriveInfo.CheckDriveNumber(Drive: TDriveNumber);
begin
if (Drive < DriveNumberMin) or (Drive > DriveNumberMax) then
raise EIdeDriveInfo.CreateFmt( ' The drive number ( % d) is out ' +
' of range; the allowable range is % d to % d ' , [Drive ,
DriveNumberMin , DriveNumberMax]) end;


function TIdeDriveInfo.GetCylinders(Drive: TDriveNumber): Integer;
begin
CheckDriveNumber(Drive);
Result : = FCylinders[Drive] end;


function TIdeDriveInfo.GetFirmwareRevision(Drive: TDriveNumber):
String;
begin
CheckDriveNumber(Drive);
Result : = FFirmwareRevision[Drive] end;


function TIdeDriveInfo.GetHeads(Drive: TDriveNumber): Integer;
begin
CheckDriveNumber(Drive);
Result : = FHeads[Drive] end;


function TIdeDriveInfo.GetModelNumber(Drive: TDriveNumber): String;
begin
CheckDriveNumber(Drive);
Result : = FModelNumber[Drive] end;


function TIdeDriveInfo.GetRemovableMedia(Drive: TDriveNumber):
Boolean;
begin
CheckDriveNumber(Drive);
Result : = FRemovableMedia[Drive] end;


function TIdeDriveInfo.GetSectorsPerTrack(Drive: TDriveNumber):
Integer;
begin
CheckDriveNumber(Drive);
Result : = FSectorsPerTrack[Drive] end;


function TIdeDriveInfo.GetSerialNumber(Drive: TDriveNumber): String;
begin
CheckDriveNumber(Drive);
Result : = FSerialNumber[Drive]
end;


procedure TIdeDriveInfo.QueryDrive(Drive: TDriveNumber);
var
BytesReturned: DWord;
CmdIn: TSendCmdInParams;
CmdOut: TSendCmdOutParams;
DriveName: String;
H: THandle;
I: Integer;
VersionInfo: TGetVersionOutParams;
begin
FCylinders[Drive] : = 0;
FFirmwareRevision[Drive] : = ' ';
FHeads[Drive] : = 0;
FModelNumber[Drive] : = ' ';
FRemovableMedia[Drive] : = False;
FSectorsPerTrack[Drive] : = 0;
FSerialNumber[Drive] : = ' ';
DriveName : = Format( ' \\.\PHYSICALDRIVE % d ' , [Drive]);
H : = CreateFile(PChar(DriveName) , GENERIC_READ or GENERIC_WRITE , 0 ,
nil , OPEN_EXISTING , 0 , 0);
if H = INVALID_HANDLE_VALUE then
Exit;
try
FillChar(VersionInfo , SizeOf(VersionInfo) , 0);
BytesReturned : = 0;
if not DeviceIoControl(H , DFP_GET_VERSION , nil , 0 , @VersionInfo ,
SizeOf(VersionInfo) , BytesReturned , nil) then
Exit;
if not (cpIdeIdentify in VersionInfo.Capabilities) then
Exit;
FillChar(CmdIn , SizeOf(CmdIn) , 0);
CmdIn.BufferSize : = 0;
CmdIn.DriveRegs.Command : = IDE_IDENTIFY_DEVICE;
CmdIn.DriveNumber : = Drive;
FillChar(CmdOut , SizeOf(CmdOut) , 0);
CmdOut.BufferSize : = SizeOf(CmdOut.Buffer);
BytesReturned : = 0;
if not DeviceIoControl(H , DFP_RECEIVE_DRIVE_DATA , @CmdIn ,
SizeOf(CmdIn) , @CmdOut , SizeOf(CmdOut) , BytesReturned ,
nil) then
Exit;
with CmdOut do begin
for I : = 10 to 19 do
Buffer[I] : = (Lo(Buffer[I]) shl 8) + Hi(Buffer[I]);
for I : = 23 to 46 do
Buffer[I] : = (Lo(Buffer[I]) shl 8) + Hi(Buffer[I]);
FRemovableMedia[Drive] : = (Buffer[0] and $80) < > 0;
FCylinders[Drive] : = Buffer[1];
FHeads[Drive] : = Buffer[3];
FSectorsPerTrack[Drive] : = Buffer[6];
SetLength(FSerialNumber[Drive] , 20);
Move(Buffer[10] , FSerialNumber[Drive][1] ,
Length(FSerialNumber[Drive]));
FSerialNumber[Drive] : = Trim(FSerialNumber[Drive]);
SetLength(FFirmwareRevision[Drive] , 8);
Move(Buffer[23] , FFirmwareRevision[Drive][1] ,
Length(FFirmwareRevision[Drive]));
FFirmwareRevision[Drive] : = Trim(FFirmwareRevision[Drive]);
SetLength(FModelNumber[Drive] , 40);
Move(Buffer[27] , FModelNumber[Drive][1] ,
Length(FModelNumber[Drive]));
FModelNumber[Drive] : = Trim(FModelNumber[Drive]) end;
finally
CloseHandle(H) end end;


end.