sptilib.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	ATA_PASSTHROUGH_PROTOCOL_HARDWARE_RESET   0x0
#define	ATA_PASSTHROUGH_PROTOCOL_SOFTWARE_RESET   0x1
#define	ATA_PASSTHROUGH_PROTOCOL_NON_DATA   0x3
#define	ATA_PASSTHROUGH_PROTOCOL_PIO_DATA_IN   0x4
#define	ATA_PASSTHROUGH_PROTOCOL_PIO_DATA_OUT   0x5
#define	ATA_PASSTHROUGH_PROTOCOL_DMA   0x6
#define	ATA_PASSTHROUGH_PROTOCOL_DEVICE_DIAG   0x8
#define	ATA_PASSTHROUGH_PROTOCOL_DEVICE_RESET   0x9
#define	ATA_PASSTHROUGH_PROTOCOL_UDMA_DATA_IN   0xA
#define	ATA_PASSTHROUGH_PROTOCOL_UDMA_DATA_OUT   0xB
#define	ATA_PASSTHROUGH_PROTOCOL_NCQ   0xC
#define	ATA_PASSTHROUGH_PROTOCOL_RETURN_RESPONSE   0xF
#define	SCSI_SENSEQ_ATA_PASS_THROUGH_INFORMATION_AVAILABLE   0x1D

Functions
NTSTATUS	SptiHandleAtaPassthru (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _In_ ULONG MaximumTransferLength, _In_ ULONG MaximumPhysicalPages)
	Handler for the IOCTL_ATA_PASS_THROUGH and IOCTL_ATA_PASS_THROUGH_DIRECT requests.
NTSTATUS	SptiHandleScsiPassthru (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _In_ ULONG MaximumTransferLength, _In_ ULONG MaximumPhysicalPages)
	Handler for the IOCTL_SCSI_PASS_THROUGH and IOCTL_SCSI_PASS_THROUGH_DIRECT requests.

Macro Definition Documentation

ATA_PASSTHROUGH_PROTOCOL_DEVICE_DIAG

#define ATA_PASSTHROUGH_PROTOCOL_DEVICE_DIAG   0x8

Definition at line 21 of file sptilib.h.

ATA_PASSTHROUGH_PROTOCOL_DEVICE_RESET

#define ATA_PASSTHROUGH_PROTOCOL_DEVICE_RESET   0x9

Definition at line 22 of file sptilib.h.

ATA_PASSTHROUGH_PROTOCOL_DMA

#define ATA_PASSTHROUGH_PROTOCOL_DMA   0x6

Definition at line 20 of file sptilib.h.

ATA_PASSTHROUGH_PROTOCOL_HARDWARE_RESET

#define ATA_PASSTHROUGH_PROTOCOL_HARDWARE_RESET   0x0

ATA Protocol field definitions for the ATA passthrough commands (SCSIOP_ATA_PASSTHROUGH12 and SCSIOP_ATA_PASSTHROUGH16).

Definition at line 15 of file sptilib.h.

ATA_PASSTHROUGH_PROTOCOL_NCQ

#define ATA_PASSTHROUGH_PROTOCOL_NCQ   0xC

Definition at line 25 of file sptilib.h.

ATA_PASSTHROUGH_PROTOCOL_NON_DATA

#define ATA_PASSTHROUGH_PROTOCOL_NON_DATA   0x3

Definition at line 17 of file sptilib.h.

ATA_PASSTHROUGH_PROTOCOL_PIO_DATA_IN

#define ATA_PASSTHROUGH_PROTOCOL_PIO_DATA_IN   0x4

Definition at line 18 of file sptilib.h.

ATA_PASSTHROUGH_PROTOCOL_PIO_DATA_OUT

#define ATA_PASSTHROUGH_PROTOCOL_PIO_DATA_OUT   0x5

Definition at line 19 of file sptilib.h.

ATA_PASSTHROUGH_PROTOCOL_RETURN_RESPONSE

#define ATA_PASSTHROUGH_PROTOCOL_RETURN_RESPONSE   0xF

Definition at line 26 of file sptilib.h.

ATA_PASSTHROUGH_PROTOCOL_SOFTWARE_RESET

#define ATA_PASSTHROUGH_PROTOCOL_SOFTWARE_RESET   0x1

Definition at line 16 of file sptilib.h.

ATA_PASSTHROUGH_PROTOCOL_UDMA_DATA_IN

#define ATA_PASSTHROUGH_PROTOCOL_UDMA_DATA_IN   0xA

Definition at line 23 of file sptilib.h.

ATA_PASSTHROUGH_PROTOCOL_UDMA_DATA_OUT

#define ATA_PASSTHROUGH_PROTOCOL_UDMA_DATA_OUT   0xB

Definition at line 24 of file sptilib.h.

SCSI_SENSEQ_ATA_PASS_THROUGH_INFORMATION_AVAILABLE

#define SCSI_SENSEQ_ATA_PASS_THROUGH_INFORMATION_AVAILABLE   0x1D

Additional sense code for the successfully completed ATA passthrough commands with check condition enabled.

Definition at line 33 of file sptilib.h.

Function Documentation

SptiHandleAtaPassthru()

NTSTATUS SptiHandleAtaPassthru	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp,
		_In_ ULONG	MaximumTransferLength,
		_In_ ULONG	MaximumPhysicalPages
	)

Handler for the IOCTL_ATA_PASS_THROUGH and IOCTL_ATA_PASS_THROUGH_DIRECT requests.

Parameters

[in]	DeviceObject	PDO device object.
[in,out]	Irp	Pointer to the IOCTL request.
[in]	MaximumTransferLength	Maximum size of data transfer for a device.
[in]	MaximumPhysicalPages	Maximum number of physical pages per data transfer for a device.

Returns

Status.

Definition at line 782 of file sptilib.c.

{
    PATA_PASS_THROUGH_EX Apt = Irp->AssociatedIrp.SystemBuffer;
    PIO_STACK_LOCATION IoStack;
    BOOLEAN IsDirectMemoryAccess;
    PASSTHROUGH_DATA AptData;
    PUCHAR TaskFile;
    NTSTATUS Status;
    PVOID DataBuffer;
    PPASSTHROUGH_IRP_CONTEXT IrpContext;
    PSCSI_REQUEST_BLOCK Srb;
 
    PAGED_CODE();
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    ASSERT(GET_IOCTL(IoStack) == IOCTL_ATA_PASS_THROUGH ||
           GET_IOCTL(IoStack) == IOCTL_ATA_PASS_THROUGH_DIRECT);
 
    IsDirectMemoryAccess = (GET_IOCTL(IoStack) == IOCTL_ATA_PASS_THROUGH_DIRECT);
 
    Status = SptiInitializeApt(DeviceObject,
                               Irp,
                               IoStack,
                               IsDirectMemoryAccess,
                               MaximumTransferLength,
                               MaximumPhysicalPages,
                               Apt,
                               &AptData,
                               &TaskFile,
                               &DataBuffer);
    if (!NT_SUCCESS(Status))
        return Status;
 
    DPRINT("APT: Flags %x DTL %lu\n", Apt->AtaFlags, Apt->DataTransferLength);
    DPRINT("APT: Curr %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
           TaskFile[8 + 0], TaskFile[8 + 1], TaskFile[8 + 2], TaskFile[8 + 3],
           TaskFile[8 + 4], TaskFile[8 + 5], TaskFile[8 + 6],
           Apt->AtaFlags,
           Apt->DataTransferLength);
    if (Apt->AtaFlags & ATA_FLAGS_48BIT_COMMAND)
    {
        DPRINT("APT: Prev %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
               TaskFile[0], TaskFile[1], TaskFile[2], TaskFile[3],
               TaskFile[4], TaskFile[5], TaskFile[6]);
    }
 
    IrpContext = SptiCreateIrpContext(DeviceObject,
                                      Irp,
                                      DataBuffer,
                                      Apt->DataTransferLength,
                                      IsDirectMemoryAccess,
                                      !!(Apt->AtaFlags & ATA_FLAGS_DATA_OUT));
    if (!IrpContext)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    Status = SptiTranslateAptToSrb(&IrpContext->Srb, Apt, TaskFile);
    if (!NT_SUCCESS(Status))
        goto Cleanup;
 
    Status = SptiCallDriver(DeviceObject, IrpContext);
 
    Srb = &IrpContext->Srb;
 
    if (SptiTranslateAtaStatusReturnToTaskFile(Srb, Srb->SenseInfoBuffer, TaskFile))
        Status = STATUS_SUCCESS;
 
    /* Update the output buffer size */
    Apt->DataTransferLength = Srb->DataTransferLength;
    if (IsDirectMemoryAccess)
    {
        Irp->IoStatus.Information = Apt->Length;
    }
    else
    {
        if ((Apt->AtaFlags & ATA_FLAGS_DATA_IN) && (AptData.BufferOffset != 0))
            Irp->IoStatus.Information = AptData.BufferOffset + Apt->DataTransferLength;
        else
            Irp->IoStatus.Information = Apt->Length;
    }
 
    DPRINT("APT: Return %lx, DTL %lu, %lu bytes\n",
           Status,
           Apt->DataTransferLength,
           (ULONG)Irp->IoStatus.Information);
    DPRINT("APT: Return curr %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
           TaskFile[8 + 0], TaskFile[8 + 1], TaskFile[8 + 2], TaskFile[8 + 3],
           TaskFile[8 + 4], TaskFile[8 + 5], TaskFile[8 + 6]);
    if (Apt->AtaFlags & ATA_FLAGS_48BIT_COMMAND)
    {
        DPRINT("APT: Return prev %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
               TaskFile[0], TaskFile[1], TaskFile[2], TaskFile[3],
               TaskFile[4], TaskFile[5], TaskFile[6]);
    }
 
Cleanup:
    SptiFreeIrpContext(IrpContext);
    return Status;
}

SptiHandleScsiPassthru()

NTSTATUS SptiHandleScsiPassthru	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp,
		_In_ ULONG	MaximumTransferLength,
		_In_ ULONG	MaximumPhysicalPages
	)

Handler for the IOCTL_SCSI_PASS_THROUGH and IOCTL_SCSI_PASS_THROUGH_DIRECT requests.

Parameters

[in]	DeviceObject	PDO device object.
[in,out]	Irp	Pointer to the IOCTL request.
[in]	MaximumTransferLength	Maximum size of data transfer for a device.
[in]	MaximumPhysicalPages	Maximum number of physical pages per data transfer for a device.

Returns

Status.

Definition at line 888 of file sptilib.c.

{
    PSCSI_PASS_THROUGH Spt = Irp->AssociatedIrp.SystemBuffer;
    PIO_STACK_LOCATION IoStack;
    BOOLEAN IsDirectMemoryAccess;
    PASSTHROUGH_DATA SptData;
    ULONG SenseInfoOffset;
    PUCHAR Cdb;
    NTSTATUS Status;
    PVOID DataBuffer;
    PPASSTHROUGH_IRP_CONTEXT IrpContext;
    PSCSI_REQUEST_BLOCK Srb;
 
    PAGED_CODE();
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    ASSERT(GET_IOCTL(IoStack) == IOCTL_SCSI_PASS_THROUGH ||
           GET_IOCTL(IoStack) == IOCTL_SCSI_PASS_THROUGH_DIRECT);
 
    IsDirectMemoryAccess = (GET_IOCTL(IoStack) == IOCTL_SCSI_PASS_THROUGH_DIRECT);
 
    Status = SptiInitializeSpt(DeviceObject,
                               Irp,
                               IoStack,
                               IsDirectMemoryAccess,
                               MaximumTransferLength,
                               MaximumPhysicalPages,
                               Spt,
                               &SptData,
                               &SenseInfoOffset,
                               &Cdb,
                               &DataBuffer);
    if (!NT_SUCCESS(Status))
        return Status;
 
    DPRINT("SPT: Flags %u, DTL %lu, sense len %u\n",
           Spt->DataIn,
           Spt->DataTransferLength,
           Spt->SenseInfoLength);
    DPRINT("SPT: CDB %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
           Cdb[0], Cdb[1], Cdb[2], Cdb[3], Cdb[4], Cdb[5], Cdb[6], Cdb[7], Cdb[8], Cdb[9]);
 
    IrpContext = SptiCreateIrpContext(DeviceObject,
                                      Irp,
                                      DataBuffer,
                                      Spt->DataTransferLength,
                                      IsDirectMemoryAccess,
                                      !!(Spt->DataIn == SCSI_IOCTL_DATA_OUT));
    if (!IrpContext)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    Status = SptiTranslateSptToSrb(&IrpContext->Srb, Spt, Cdb);
    if (!NT_SUCCESS(Status))
        goto Cleanup;
 
    Status = SptiCallDriver(DeviceObject, IrpContext);
 
    Srb = &IrpContext->Srb;
 
    /*
     * Low-level storage drivers map SRB_STATUS_DATA_OVERRUN to STATUS_BUFFER_OVERFLOW.
     * This SRB status is usually set on an underrun and means success in that case.
     */
    if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_DATA_OVERRUN)
        Status = STATUS_SUCCESS;
 
    if (Srb->SrbStatus & SRB_STATUS_AUTOSENSE_VALID)
    {
        ASSERT(Srb->SenseInfoBufferLength <= Spt->SenseInfoLength);
 
        Spt->SenseInfoLength = Srb->SenseInfoBufferLength;
 
        /* Copy the sense buffer back */
        RtlCopyMemory((PVOID)((ULONG_PTR)Spt + SenseInfoOffset),
                      Srb->SenseInfoBuffer,
                      Srb->SenseInfoBufferLength);
    }
    else
    {
        Spt->SenseInfoLength = 0;
    }
 
    Spt->ScsiStatus = Srb->ScsiStatus;
 
    /* Update the output buffer size */
    Spt->DataTransferLength = Srb->DataTransferLength;
    if (IsDirectMemoryAccess)
    {
        if (Spt->SenseInfoLength != 0)
            Irp->IoStatus.Information = SenseInfoOffset + Spt->SenseInfoLength;
        else
            Irp->IoStatus.Information = Spt->Length;
    }
    else
    {
        if ((Srb->SrbFlags & SRB_FLAGS_DATA_IN) && (SptData.BufferOffset != 0))
            Irp->IoStatus.Information = SptData.BufferOffset + Spt->DataTransferLength;
        else if (Spt->SenseInfoLength != 0)
            Irp->IoStatus.Information = SenseInfoOffset + Spt->SenseInfoLength;
        else
            Irp->IoStatus.Information = Spt->Length;
    }
 
    DPRINT("SPT: Return %lx, DTL %lu, "
           "Srb status %02x, SCSI status %02x, sense len %u, %lu bytes\n",
           Status,
           Spt->DataTransferLength,
           Srb->SrbStatus,
           Spt->ScsiStatus,
           Spt->SenseInfoLength,
           (ULONG)Irp->IoStatus.Information);
 
Cleanup:
    SptiFreeIrpContext(IrpContext);
    return Status;
}

Referenced by PdoHandleScsiPassthrough(), and USBSTOR_HandleDeviceControl().