atapi.h File Reference

#include <ntddk.h>
#include <ntstrsafe.h>
#include <ntintsafe.h>
#include <wmilib.h>
#include <initguid.h>
#include <wdmguid.h>
#include <wmistr.h>
#include <wmidata.h>
#include <ata.h>
#include <ide.h>
#include <scsi.h>
#include <ntddscsi.h>
#include <ntdddisk.h>
#include <sptilib.h>
#include <section_attribs.h>
#include <debug/driverdbg.h>
#include <reactos/drivers/ata/ata_shared.h>
#include <reactos/drivers/ata/ata_user.h>
#include <reactos/drivers/ata/identify_funcs.h>
#include "debug.h"
#include "scsiex.h"

Include dependency graph for atapi.h:

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

Go to the source code of this file.

Classes
union	_ATA_SCSI_ADDRESS
struct	_ATAPORT_IO_CONTEXT
struct	_ATA_WORKER_CONTEXT
struct	_ATA_WORKER_DEVICE_CONTEXT
struct	_REQUEST_QUEUE_ENTRY
struct	_ATAPORT_PORT_DATA
struct	_ATAPORT_COMMON_EXTENSION
struct	_ATAPORT_CHANNEL_EXTENSION
struct	_ATAPORT_DEVICE_EXTENSION

Macros
#define	DEVICE_PIO_ONLY   0x00000001
#define	DEVICE_LBA_MODE   0x00000002
#define	DEVICE_LBA48   0x00000004
#define	DEVICE_HAS_FUA   0x00000008
#define	DEVICE_NCQ   0x00000010
#define	DEVICE_HAS_MEDIA_STATUS   0x00000020
#define	DEVICE_SENSE_DATA_REPORTING   0x00000040
#define	DEVICE_IS_SUPER_FLOPPY   0x00000080
#define	DEVICE_IS_PDO_REMOVABLE   0x00000100
#define	DEVICE_UNINITIALIZED   0x00000200
#define	DEVICE_PNP_STARTED   0x00000400
#define	DEVICE_DESCRIPTOR_SENSE   0x00000800
#define	DEVICE_PIO_VIA_DMA   0x00001000
#define	DEVICE_PIO_FOR_LBA48_XFER   0x00002000
#define	DEVICE_CACHE_INQUIRY   0x00004000
#define	QUEUE_FLAG_FROZEN_PORT_BUSY   0x00000001
#define	QUEUE_FLAG_FROZEN_SLOT   0x00000002
#define	QUEUE_FLAG_FROZEN_PNP   0x00000004
#define	QUEUE_FLAG_SIGNAL_STOP   0x00000008
#define	QUEUE_FLAG_FROZEN_QUEUE_FREEZE   0x00000010
#define	QUEUE_FLAG_FROZEN_POWER   0x00000020
#define	QUEUE_FLAG_FROZEN_REMOVED   0x00000040
#define	QUEUE_FLAG_FROZEN_QUEUE_LOCK   0x00080000
#define	QUEUE_FLAGS_FROZEN
#define	QUEUE_FLAGS_FROZEN_NOT_BYPASS    (QUEUE_FLAGS_FROZEN & ~(QUEUE_FLAG_FROZEN_QUEUE_FREEZE | QUEUE_FLAG_FROZEN_QUEUE_LOCK))
#define	ATAPORT_PAGED_DATA   DATA_SEG("PAGECONS")
#define	DECLARE_PAGED_UNICODE_STRING(Variable, Str)
#define	DECLARE_PAGED_STRING(v, n)    static const ATAPORT_PAGED_DATA CHAR (v)[] = (n)
#define	DECLARE_PAGED_WSTRING(v, n)    static const ATAPORT_PAGED_DATA WCHAR (v)[] = (n)
#define	ASSUME(cond)
#define	ATAPORT_TAG   'PedI'
#define	IS_FDO(p)    ((((PATAPORT_COMMON_EXTENSION)(p))->Flags & DO_IS_FDO) != 0)
#define	IS_ATAPI(Device)    (((Device)->TransportFlags & DEVICE_IS_ATAPI) != 0)
#define	NUM_TO_BITMAP(num)   (0xFFFFFFFF >> (RTL_BITS_OF(ULONG) - (num)))
#define	ATAPORT_FN_FIELD   40
	The maximum length of identifier strings for ATA devices excluding the terminating NULL.
#define	ATAPORT_SN_FIELD   40
#define	ATAPORT_RN_FIELD   8
#define	ATA_RESERVED_PAGES   4
#define	ATA_MAX_LUN_COUNT   8
#define	ATA_LOCAL_BUFFER_SIZE   572
#define	MAX_SLOTS   32
#define	ATA_MAX_LBA_28   0x0FFFFFFFULL
#define	ATA_MAX_LBA_48   (1ULL << 48)
#define	IDE_DRIVE_SELECT_SLAVE   0x10
#define	IDE_HIGH_ORDER_BYTE   0x80
#define	IDE_DRIVE_SELECT   0xA0
#define	IDE_ERROR_WRITE_PROTECT   0x40
#define	IDE_FEATURE_PIO   0x00
#define	IDE_FEATURE_DMA   0x01
#define	IDE_FEATURE_DMADIR   0x04
#define	IDE_DEVICE_FUA_NCQ   0x80
#define	IDE_DC_ALWAYS   0x08
#define	IDE_COMMAND_REQUEST_SENSE_DATA_EXT   0x0B
#define	SRB_FLAG_RETRY_COUNT_MASK   0x000000FF
#define	SRB_FLAG_LOW_MEM_RETRY   0x00000100
#define	SRB_FLAG_PIO_RETRY   0x00000200
#define	SRB_SET_FLAGS(Srb, Flags)    ((Srb)->SrbExtension = (PVOID)((ULONG_PTR)(Srb)->SrbExtension | (Flags)))
#define	SRB_CLEAR_FLAGS(Srb, Flags)    ((Srb)->SrbExtension = (PVOID)((ULONG_PTR)(Srb)->SrbExtension & ~(Flags)))
#define	SRB_GET_FLAGS(Srb)   ((ULONG_PTR)(Srb)->SrbExtension)
#define	WORKER_FLAG_NEED_RESCAN   0x00000001
#define	WORKER_FLAG_COMPLETE_PORT_ENUM_EVENT   0x00000002
#define	DEV_WORKER_FLAG_HOLD_REFERENCE   0x00000001
#define	DEV_WORKER_FLAG_REMOVED   0x00000002
#define	QUEUE_ENTRY_FROM_IRP(Irp)    ((PREQUEST_QUEUE_ENTRY)&(((PIRP)(Irp))->Tail.Overlay.DriverContext[0]))
#define	IRP_FROM_QUEUE_ENTRY(QueueEntry)    (PIRP)CONTAINING_RECORD(QueueEntry, IRP, Tail.Overlay.DriverContext[0])
#define	ASSERT_REQUEST(Request)    ASSERT((Request) && (Request)->Signature == ATA_DEVICE_REQUEST_SIGNATURE)
#define	PORT_FLAG_IS_SIMPLEX   0x00000001
#define	PORT_FLAG_PIO_VIA_DMA   0x00000002
#define	PORT_FLAG_IS_EXTERNAL   0x00000004
#define	PORT_FLAG_NCQ   0x00000008
#define	PORT_FLAG_IS_AHCI   0x00000010
#define	PORT_FLAG_SYMLINK_CREATED   0x00000020
#define	PORT_FLAG_IO_TIMER_ACTIVE   0x00000040
#define	PORT_FLAG_CHANNEL_ATTACHED   0x00000080
#define	PORT_FLAG_PIO_ONLY   0x00000100
#define	PORT_FLAG_PIO_FOR_LBA48_XFER   0x00000200
#define	PORT_FLAG_EXIT_THREAD   0x80000000
#define	PORT_INT_FLAG_IS_IO_ACTIVE   0x00000001
#define	PORT_INT_FLAG_IGNORE_LINK_IRQ   0x00000002
#define	PORT_QUEUE_FLAG_EXCLUSIVE_MODE   0x00000001
#define	PORT_QUEUE_FLAG_SIGNAL_STOP   0x00000002
#define	DO_IS_FDO   0x80000000

Typedefs
typedef struct _ATAPORT_CHANNEL_EXTENSION	ATAPORT_CHANNEL_EXTENSION
typedef struct _ATAPORT_CHANNEL_EXTENSION *	PATAPORT_CHANNEL_EXTENSION
typedef struct _ATAPORT_DEVICE_EXTENSION	ATAPORT_DEVICE_EXTENSION
typedef struct _ATAPORT_DEVICE_EXTENSION *	PATAPORT_DEVICE_EXTENSION
typedef struct _ATAPORT_PORT_DATA	ATAPORT_PORT_DATA
typedef struct _ATAPORT_PORT_DATA *	PATAPORT_PORT_DATA
typedef struct _ATAPORT_IO_CONTEXT	ATAPORT_IO_CONTEXT
typedef struct _ATAPORT_IO_CONTEXT *	PATAPORT_IO_CONTEXT
typedef union _ATA_SCSI_ADDRESS	ATA_SCSI_ADDRESS
typedef union _ATA_SCSI_ADDRESS *	PATA_SCSI_ADDRESS
typedef VOID()	STOP_IO_CALLBACK(_In_ PATAPORT_IO_CONTEXT Device)
typedef STOP_IO_CALLBACK *	PSTOP_IO_CALLBACK
typedef enum _ATA_PORT_ACTION	ATA_PORT_ACTION
typedef enum _ATA_DEVICE_STATUS	ATA_DEVICE_STATUS
typedef enum _ATA_ERROR_LOG_VALUE	ATA_ERROR_LOG_VALUE
typedef struct _ATA_WORKER_CONTEXT	ATA_WORKER_CONTEXT
typedef struct _ATA_WORKER_CONTEXT *	PATA_WORKER_CONTEXT
typedef struct _ATA_WORKER_DEVICE_CONTEXT	ATA_WORKER_DEVICE_CONTEXT
typedef struct _ATA_WORKER_DEVICE_CONTEXT *	PATA_WORKER_DEVICE_CONTEXT
typedef struct _REQUEST_QUEUE_ENTRY	REQUEST_QUEUE_ENTRY
typedef struct _REQUEST_QUEUE_ENTRY *	PREQUEST_QUEUE_ENTRY
typedef struct _ATAPORT_COMMON_EXTENSION	ATAPORT_COMMON_EXTENSION
typedef struct _ATAPORT_COMMON_EXTENSION *	PATAPORT_COMMON_EXTENSION

Enumerations
enum	_ATA_PORT_ACTION {   ACTION_PORT_RESET = (1 << 0) , ACTION_ENUM_PORT = (1 << 1) , ACTION_ENUM_DEVICE_NEW = (1 << 2) , ACTION_ENUM_DEVICE = (1 << 3) ,   ACTION_PORT_TIMING = (1 << 4) , ACTION_DEVICE_CONFIG = (1 << 5) , ACTION_DEVICE_ERROR = (1 << 6) , ACTION_DEVICE_POWER = (1 << 7) }
enum	_ATA_DEVICE_STATUS { DEV_STATUS_NO_DEVICE , DEV_STATUS_NEW_DEVICE , DEV_STATUS_SAME_DEVICE , DEV_STATUS_FAILED }
enum	_ATA_ERROR_LOG_VALUE {   EVENT_CODE_CRC_ERROR = 100 , EVENT_CODE_BAD_STATE , EVENT_CODE_TIMEOUT , EVENT_CODE_DOWNSHIFT ,   EVENT_CODE_DMA_DISABLE , EVENT_CODE_NCQ_DISABLE }
enum	DEVICE_TYPE_NAME { GetDeviceType , GetGenericType , GetPeripheralId }

Functions
	C_ASSERT (sizeof(REQUEST_QUEUE_ENTRY)<=4 *sizeof(PVOID))
	C_ASSERT (REQUEST_FLAG_DATA_IN==SRB_FLAGS_DATA_IN)
	C_ASSERT (REQUEST_FLAG_DATA_OUT==SRB_FLAGS_DATA_OUT)
	C_ASSERT (REQUEST_FLAG_NO_KEEP_AWAKE==SRB_FLAGS_NO_KEEP_AWAKE)
	C_ASSERT (QUEUE_FLAG_FROZEN_QUEUE_FREEZE==SRB_FLAGS_BYPASS_FROZEN_QUEUE)
	C_ASSERT (QUEUE_FLAG_FROZEN_QUEUE_LOCK==SRB_FLAGS_BYPASS_LOCKED_QUEUE)
FORCEINLINE BOOLEAN	AtaPortQueueEmpty (_In_ PATAPORT_PORT_DATA PortData)
FORCEINLINE ATA_SCSI_ADDRESS	AtaMarshallScsiAddress (_In_ ULONG PathId, _In_ ULONG TargetId, _In_ ULONG Lun)
FORCEINLINE BOOLEAN	IsPowerOfTwo (_In_ ULONG x)
FORCEINLINE BOOLEAN	AtaPacketCommandUseDma (_In_ UCHAR OpCode)
FORCEINLINE BOOLEAN	AtaCommandUseLba48 (_In_ ULONG64 SectorNumber, _In_ ULONG SectorCount)
	_Dispatch_type_ (IRP_MJ_CREATE) _Dispatch_type_(IRP_MJ_CLOSE) DRIVER_DISPATCH_PAGED AtaDispatchCreateClose
PCSTR	AtaTypeCodeToName (_In_ PATAPORT_DEVICE_EXTENSION DevExt, _In_ DEVICE_TYPE_NAME Type)
NTSTATUS	AtaOpenRegistryKey (_Out_ PHANDLE KeyHandle, _In_ HANDLE RootKey, _In_ PUNICODE_STRING KeyName, _In_ BOOLEAN Create)
VOID	AtaGetRegistryKey (_In_ PATAPORT_CHANNEL_EXTENSION ChanExt, _In_ UCHAR TargetId, _In_ PCWSTR KeyName, _Out_ PULONG KeyValue, _In_ ULONG DefaultValue)
VOID	AtaSetRegistryKey (_In_ PATAPORT_CHANNEL_EXTENSION ChanExt, _In_ UCHAR TargetId, _In_ PCWSTR KeyName, _In_ ULONG KeyValue)
VOID	AtaSetPortRegistryKey (_In_ PATAPORT_CHANNEL_EXTENSION ChanExt, _In_ PCWSTR KeyName, _In_ ULONG KeyValue)
NTSTATUS	AtaPnpQueryInterface (_In_ PATAPORT_COMMON_EXTENSION CommonExt, _In_ const GUID *Guid, _Out_ PVOID Interface, _In_ ULONG Version, _In_ ULONG Size)
NTSTATUS	AtaPnpRepeatRequest (_In_ PATAPORT_COMMON_EXTENSION CommonExt, _In_ PIRP Irp, _In_opt_ PDEVICE_CAPABILITIES DeviceCapabilities)
NTSTATUS	AtaPnpQueryDeviceUsageNotification (_In_ PATAPORT_COMMON_EXTENSION CommonExt, _In_ PIRP Irp)
NTSTATUS	AtaPnpQueryPnpDeviceState (_In_ PATAPORT_COMMON_EXTENSION CommonExt, _In_ PIRP Irp)
VOID	AtaPnpInitializeCommonExtension (_In_ PATAPORT_COMMON_EXTENSION CommonExt, _In_ PDEVICE_OBJECT SelfDeviceObject, _In_ ULONG Flags)
NTSTATUS	AtaPortDeviceProcessConfig (_In_ PATAPORT_PORT_DATA PortData, _In_ PATAPORT_DEVICE_EXTENSION DevExt)
NTSTATUS	AtaPortDeviceProcessError (_In_ PATAPORT_PORT_DATA PortData, _In_ PATAPORT_DEVICE_EXTENSION DevExt)
NTSTATUS	AtaDeviceSendIdentify (_In_ PATAPORT_PORT_DATA PortData, _In_ PATAPORT_DEVICE_EXTENSION DevExt, _In_ UCHAR Command)
ATA_DEVICE_STATUS	AtaPortIdentifyDevice (_In_ PATAPORT_PORT_DATA PortData, _In_ PATAPORT_DEVICE_EXTENSION DevExt)
	_Dispatch_type_ (IRP_MJ_POWER) DRIVER_DISPATCH_RAISED AtaDispatchPower
VOID	AtaDeviceFlushPowerIrpQueue (_In_ PATAPORT_DEVICE_EXTENSION DevExt)
UCHAR	AtaDeviceGetFlushCacheCommand (_In_ PATAPORT_DEVICE_EXTENSION DevExt)
NTSTATUS	AtaPortDeviceProcessPowerChange (_In_ PATAPORT_PORT_DATA PortData, _In_ PATAPORT_DEVICE_EXTENSION DevExt)
NTSTATUS	AtaPortCheckDevicePowerState (_In_ PATAPORT_PORT_DATA PortData, _In_ PATAPORT_DEVICE_EXTENSION DevExt)
VOID	AtaPortSelectTimings (_In_ PATAPORT_PORT_DATA PortData, _In_ BOOLEAN ForceCompatibleTimings)
PUCHAR	AtaCopyIdStringUnsafe (_Out_writes_bytes_all_(Length) PUCHAR Destination, _In_reads_bytes_(Length) PUCHAR Source, _In_ ULONG Length)
PCHAR	AtaCopyIdStringSafe (_Out_writes_bytes_all_(MaxLength) PCHAR Destination, _In_reads_bytes_(MaxLength) PUCHAR Source, _In_ ULONG MaxLength, _In_ CHAR DefaultCharacter)
VOID	AtaSwapIdString (_Inout_updates_bytes_(WordCount *sizeof(USHORT)) PVOID Buffer, _In_range_(>, 0) ULONG WordCount)
VOID	AtaDeviceSetAddressingMode (_In_ PATAPORT_DEVICE_EXTENSION DevExt)
NTSTATUS	AtaFdoQueryBusRelations (_In_ PATAPORT_CHANNEL_EXTENSION ChanExt, _In_ PIRP Irp)
NTSTATUS	AtaFdoStartDevice (_In_ PATAPORT_CHANNEL_EXTENSION ChanExt, _In_ PCM_RESOURCE_LIST ResourcesTranslated)
NTSTATUS	AtaFdoPnp (_In_ PATAPORT_CHANNEL_EXTENSION ChanExt, _Inout_ PIRP Irp)
DECLSPEC_NOINLINE_FROM_PAGED PATAPORT_DEVICE_EXTENSION	AtaFdoFindDeviceByPath (_In_ PATAPORT_CHANNEL_EXTENSION ChanExt, _In_ ATA_SCSI_ADDRESS AtaScsiAddress, _In_ PVOID ReferenceTag)
DECLSPEC_NOINLINE_FROM_PAGED PATAPORT_DEVICE_EXTENSION	AtaFdoFindNextDeviceByPath (_In_ PATAPORT_CHANNEL_EXTENSION ChanExt, _Inout_ PATA_SCSI_ADDRESS AtaScsiAddress, _In_ BOOLEAN SearchRemoveDev, _In_ PVOID ReferenceTag)
DECLSPEC_NOINLINE_FROM_PAGED VOID	AtaFdoDeviceListInsert (_In_ PATAPORT_CHANNEL_EXTENSION ChanExt, _In_ PATAPORT_DEVICE_EXTENSION DevExt, _In_ BOOLEAN DoInsert)
	_Dispatch_type_ (IRP_MJ_DEVICE_CONTROL) DRIVER_DISPATCH_RAISED AtaDispatchDeviceControl
	_Dispatch_type_ (IRP_MJ_PNP) DRIVER_DISPATCH_PAGED AtaDispatchPnp
VOID	AtaPdoFreeDevice (_In_ PATAPORT_DEVICE_EXTENSION DevExt)
PATAPORT_DEVICE_EXTENSION	AtaPdoCreateDevice (_In_ PATAPORT_CHANNEL_EXTENSION ChanExt, _In_ ATA_SCSI_ADDRESS AtaScsiAddress)
NTSTATUS	AtaPortSendRequest (_In_ PATAPORT_PORT_DATA PortData, _In_ PATAPORT_DEVICE_EXTENSION DevExt)
VOID	AtaPortTimeout (_In_ PATAPORT_PORT_DATA PortData, _In_ ULONG Slot)
DECLSPEC_NOINLINE_FROM_PAGED VOID	AtaPortSignalWorkerThread (_In_ PATAPORT_PORT_DATA PortData)
DECLSPEC_NOINLINE_FROM_PAGED VOID	AtaDeviceQueueEvent (_In_ PATAPORT_PORT_DATA PortData, _In_opt_ PATAPORT_DEVICE_EXTENSION DevExt, _In_ ATA_PORT_ACTION Action)
BOOLEAN	AtaReqDmaTransferToPioTransfer (_In_ PATA_DEVICE_REQUEST Request)
VOID	AtaCreateStandardInquiryData (_In_ PATAPORT_DEVICE_EXTENSION DevExt)
UCHAR	AtaReqExecuteScsi (_In_ PATAPORT_DEVICE_EXTENSION DevExt, _In_ PATA_DEVICE_REQUEST Request, _In_ PSCSI_REQUEST_BLOCK Srb)
UCHAR	AtaReqSetFixedAtaSenseData (_In_ PATA_DEVICE_REQUEST Request)
VOID	AtaReqBuildReadLogTaskFile (_In_ PATA_DEVICE_REQUEST Request, _In_ UCHAR LogAddress, _In_ UCHAR PageNumber, _In_ USHORT LogPageCount)
	_Dispatch_type_ (IRP_MJ_SCSI) DRIVER_DISPATCH_RAISED AtaDispatchScsi
VOID	AtaReqCompleteFailedRequest (_In_ PATA_DEVICE_REQUEST Request)
UCHAR	AtaReqSetFixedSenseData (_In_ PSCSI_REQUEST_BLOCK Srb, _In_ SCSI_SENSE_CODE SenseCode)
VOID	AtaReqSetLbaInformation (_In_ PSCSI_REQUEST_BLOCK Srb, _In_ ULONG64 Lba)
BOOLEAN	AtaReqAllocateMdl (_In_ PATA_DEVICE_REQUEST Request)
VOID	AtaReqSendRequest (_In_ PATA_DEVICE_REQUEST Request)
VOID	AtaReqStartCompletionDpc (_In_ PATA_DEVICE_REQUEST Request)
DECLSPEC_NOINLINE_FROM_PAGED VOID	AtaReqFreezeQueue (_In_ PATAPORT_DEVICE_EXTENSION DevExt, _In_ ULONG ReasonFlags)
DECLSPEC_NOINLINE_FROM_PAGED VOID	AtaReqThawQueue (_In_ PATAPORT_DEVICE_EXTENSION DevExt, _In_ ULONG ReasonFlags)
DECLSPEC_NOINLINE_FROM_PAGED VOID	AtaReqWaitForOutstandingIoToComplete (_In_ PATAPORT_IO_CONTEXT Device, _In_ PSCSI_REQUEST_BLOCK Srb)
DECLSPEC_NOINLINE_FROM_PAGED VOID	AtaReqFlushDeviceQueue (_In_ PATAPORT_IO_CONTEXT Device)
UCHAR	AtaReqSmartIoControl (_In_ PATAPORT_DEVICE_EXTENSION DevExt, _In_ PATA_DEVICE_REQUEST Request, _In_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	AtaPdoHandleMiniportSmartVersion (_In_ PATAPORT_DEVICE_EXTENSION DevExt, _In_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	AtaPdoHandleMiniportIdentify (_In_ PATAPORT_DEVICE_EXTENSION DevExt, _In_ PSCSI_REQUEST_BLOCK Srb)
	_Dispatch_type_ (IRP_MJ_SYSTEM_CONTROL) DRIVER_DISPATCH_PAGED AtaDispatchWmi
NTSTATUS	AtaPdoWmiRegistration (_In_ PATAPORT_DEVICE_EXTENSION DevExt, _In_ BOOLEAN Register)

Variables
UNICODE_STRING	AtapDriverRegistryPath
BOOLEAN	AtapInPEMode
DRIVER_ADD_DEVICE	AtaAddChannel
DRIVER_UNLOAD	AtaUnload
DRIVER_INITIALIZE	DriverEntry
IO_WORKITEM_ROUTINE	AtaStorageNotificationWorker
KDEFERRED_ROUTINE	AtaStorageNotificationlDpc
IO_COMPLETION_ROUTINE	AtaPdoCompletionRoutine
KSTART_ROUTINE	AtaPortWorkerThread
KDEFERRED_ROUTINE	AtaPortWorkerSignalDpc
REQUEST_COMPLETION_ROUTINE	AtaPortCompleteInternalRequest
PORT_NOTIFICATION	AtaPortNotification
IO_TIMER_ROUTINE	AtaPortIoTimer
KDEFERRED_ROUTINE	AtaReqCompletionDpc
SLIST_HEADER	AtapCompletionQueueList
KDPC	AtapCompletionDpc

Macro Definition Documentation

ASSERT_REQUEST

#define ASSERT_REQUEST

(

Request

)

ASSERT((Request) && (Request)->Signature == ATA_DEVICE_REQUEST_SIGNATURE)

Definition at line 326 of file atapi.h.

ASSUME

#define ASSUME

(

cond

)

Value:

    do { \
        ASSERT(cond); \
        __assume(cond); \
    } while (0)

Definition at line 165 of file atapi.h.

ATA_LOCAL_BUFFER_SIZE

#define ATA_LOCAL_BUFFER_SIZE   572

Definition at line 205 of file atapi.h.

ATA_MAX_LBA_28

#define ATA_MAX_LBA_28   0x0FFFFFFFULL

Definition at line 209 of file atapi.h.

ATA_MAX_LBA_48

#define ATA_MAX_LBA_48   (1ULL << 48)

Definition at line 210 of file atapi.h.

ATA_MAX_LUN_COUNT

#define ATA_MAX_LUN_COUNT   8

Definition at line 202 of file atapi.h.

ATA_RESERVED_PAGES

#define ATA_RESERVED_PAGES   4

Definition at line 200 of file atapi.h.

ATAPORT_FN_FIELD

#define ATAPORT_FN_FIELD   40

The maximum length of identifier strings for ATA devices excluding the terminating NULL.

See also

See MSDN note: https://learn.microsoft.com/en-us/windows-hardware/drivers/install/identifiers-for-ide-devices

and IDENTIFY_DEVICE_DATA.SerialNumber IDENTIFY_DEVICE_DATA.ModelNumber IDENTIFY_DEVICE_DATA.FirmwareRevision

Definition at line 195 of file atapi.h.

ATAPORT_PAGED_DATA

#define ATAPORT_PAGED_DATA   DATA_SEG("PAGECONS")

Pageable read-only data

Definition at line 153 of file atapi.h.

ATAPORT_RN_FIELD

#define ATAPORT_RN_FIELD   8

Definition at line 197 of file atapi.h.

ATAPORT_SN_FIELD

#define ATAPORT_SN_FIELD   40

Definition at line 196 of file atapi.h.

ATAPORT_TAG

#define ATAPORT_TAG   'PedI'

Definition at line 171 of file atapi.h.

DECLARE_PAGED_STRING

#define DECLARE_PAGED_STRING	(		v,
			n
	)		static const ATAPORT_PAGED_DATA CHAR (v)[] = (n)

Definition at line 159 of file atapi.h.

DECLARE_PAGED_UNICODE_STRING

#define DECLARE_PAGED_UNICODE_STRING	(		Variable,
			Str
	)

Value:

  static const ATAPORT_PAGED_DATA WCHAR Variable##_buffer[] = Str; \
  UNICODE_STRING Variable = { sizeof(Str) - sizeof(WCHAR), sizeof(Str), (PWCH)Variable##_buffer } \

Definition at line 155 of file atapi.h.

DECLARE_PAGED_WSTRING

#define DECLARE_PAGED_WSTRING	(		v,
			n
	)		static const ATAPORT_PAGED_DATA WCHAR (v)[] = (n)

Definition at line 162 of file atapi.h.

DEV_WORKER_FLAG_HOLD_REFERENCE

#define DEV_WORKER_FLAG_HOLD_REFERENCE   0x00000001

Definition at line 304 of file atapi.h.

DEV_WORKER_FLAG_REMOVED

#define DEV_WORKER_FLAG_REMOVED   0x00000002

Definition at line 305 of file atapi.h.

DEVICE_CACHE_INQUIRY

#define DEVICE_CACHE_INQUIRY   0x00004000

Definition at line 96 of file atapi.h.

DEVICE_DESCRIPTOR_SENSE

#define DEVICE_DESCRIPTOR_SENSE   0x00000800

Definition at line 93 of file atapi.h.

DEVICE_HAS_FUA

#define DEVICE_HAS_FUA   0x00000008

Definition at line 85 of file atapi.h.

DEVICE_HAS_MEDIA_STATUS

#define DEVICE_HAS_MEDIA_STATUS   0x00000020

Definition at line 87 of file atapi.h.

DEVICE_IS_PDO_REMOVABLE

#define DEVICE_IS_PDO_REMOVABLE   0x00000100

Definition at line 90 of file atapi.h.

DEVICE_IS_SUPER_FLOPPY

#define DEVICE_IS_SUPER_FLOPPY   0x00000080

Definition at line 89 of file atapi.h.

DEVICE_LBA48

#define DEVICE_LBA48   0x00000004

Definition at line 84 of file atapi.h.

DEVICE_LBA_MODE

#define DEVICE_LBA_MODE   0x00000002

Definition at line 83 of file atapi.h.

DEVICE_NCQ

#define DEVICE_NCQ   0x00000010

Definition at line 86 of file atapi.h.

DEVICE_PIO_FOR_LBA48_XFER

#define DEVICE_PIO_FOR_LBA48_XFER   0x00002000

Definition at line 95 of file atapi.h.

DEVICE_PIO_ONLY

#define DEVICE_PIO_ONLY   0x00000001

Definition at line 82 of file atapi.h.

DEVICE_PIO_VIA_DMA

#define DEVICE_PIO_VIA_DMA   0x00001000

Definition at line 94 of file atapi.h.

DEVICE_PNP_STARTED

#define DEVICE_PNP_STARTED   0x00000400

Definition at line 92 of file atapi.h.

DEVICE_SENSE_DATA_REPORTING

#define DEVICE_SENSE_DATA_REPORTING   0x00000040

Definition at line 88 of file atapi.h.

DEVICE_UNINITIALIZED

#define DEVICE_UNINITIALIZED   0x00000200

Definition at line 91 of file atapi.h.

DO_IS_FDO

#define DO_IS_FDO   0x80000000

Definition at line 430 of file atapi.h.

IDE_COMMAND_REQUEST_SENSE_DATA_EXT

#define IDE_COMMAND_REQUEST_SENSE_DATA_EXT   0x0B

Definition at line 226 of file atapi.h.

IDE_DC_ALWAYS

#define IDE_DC_ALWAYS   0x08

Definition at line 224 of file atapi.h.

IDE_DEVICE_FUA_NCQ

#define IDE_DEVICE_FUA_NCQ   0x80

Definition at line 222 of file atapi.h.

IDE_DRIVE_SELECT

#define IDE_DRIVE_SELECT   0xA0

Definition at line 214 of file atapi.h.

IDE_DRIVE_SELECT_SLAVE

#define IDE_DRIVE_SELECT_SLAVE   0x10

Definition at line 212 of file atapi.h.

IDE_ERROR_WRITE_PROTECT

#define IDE_ERROR_WRITE_PROTECT   0x40

Definition at line 216 of file atapi.h.

IDE_FEATURE_DMA

#define IDE_FEATURE_DMA   0x01

Definition at line 219 of file atapi.h.

IDE_FEATURE_DMADIR

#define IDE_FEATURE_DMADIR   0x04

Definition at line 220 of file atapi.h.

IDE_FEATURE_PIO

#define IDE_FEATURE_PIO   0x00

Definition at line 218 of file atapi.h.

IDE_HIGH_ORDER_BYTE

#define IDE_HIGH_ORDER_BYTE   0x80

Definition at line 213 of file atapi.h.

IRP_FROM_QUEUE_ENTRY

#define IRP_FROM_QUEUE_ENTRY

(

QueueEntry

)

(PIRP)CONTAINING_RECORD(QueueEntry, IRP, Tail.Overlay.DriverContext[0])

Definition at line 313 of file atapi.h.

IS_ATAPI

#define IS_ATAPI

(

Device

)

(((Device)->TransportFlags & DEVICE_IS_ATAPI) != 0)

Definition at line 176 of file atapi.h.

IS_FDO

#define IS_FDO

(

p

)

((((PATAPORT_COMMON_EXTENSION)(p))->Flags & DO_IS_FDO) != 0)

Definition at line 173 of file atapi.h.

MAX_SLOTS

#define MAX_SLOTS   32

Definition at line 207 of file atapi.h.

NUM_TO_BITMAP

#define NUM_TO_BITMAP

(

num

)

(0xFFFFFFFF >> (RTL_BITS_OF(ULONG) - (num)))

Definition at line 179 of file atapi.h.

PORT_FLAG_CHANNEL_ATTACHED

#define PORT_FLAG_CHANNEL_ATTACHED   0x00000080

Definition at line 343 of file atapi.h.

PORT_FLAG_EXIT_THREAD

#define PORT_FLAG_EXIT_THREAD   0x80000000

Definition at line 346 of file atapi.h.

PORT_FLAG_IO_TIMER_ACTIVE

#define PORT_FLAG_IO_TIMER_ACTIVE   0x00000040

Definition at line 342 of file atapi.h.

PORT_FLAG_IS_AHCI

#define PORT_FLAG_IS_AHCI   0x00000010

Definition at line 340 of file atapi.h.

PORT_FLAG_IS_EXTERNAL

#define PORT_FLAG_IS_EXTERNAL   0x00000004

Definition at line 338 of file atapi.h.

PORT_FLAG_IS_SIMPLEX

#define PORT_FLAG_IS_SIMPLEX   0x00000001

Definition at line 336 of file atapi.h.

PORT_FLAG_NCQ

#define PORT_FLAG_NCQ   0x00000008

Definition at line 339 of file atapi.h.

PORT_FLAG_PIO_FOR_LBA48_XFER

#define PORT_FLAG_PIO_FOR_LBA48_XFER   0x00000200

Definition at line 345 of file atapi.h.

PORT_FLAG_PIO_ONLY

#define PORT_FLAG_PIO_ONLY   0x00000100

Definition at line 344 of file atapi.h.

PORT_FLAG_PIO_VIA_DMA

#define PORT_FLAG_PIO_VIA_DMA   0x00000002

Definition at line 337 of file atapi.h.

PORT_FLAG_SYMLINK_CREATED

#define PORT_FLAG_SYMLINK_CREATED   0x00000020

Definition at line 341 of file atapi.h.

PORT_INT_FLAG_IGNORE_LINK_IRQ

#define PORT_INT_FLAG_IGNORE_LINK_IRQ   0x00000002

Definition at line 361 of file atapi.h.

PORT_INT_FLAG_IS_IO_ACTIVE

#define PORT_INT_FLAG_IS_IO_ACTIVE   0x00000001

Definition at line 360 of file atapi.h.

PORT_QUEUE_FLAG_EXCLUSIVE_MODE

#define PORT_QUEUE_FLAG_EXCLUSIVE_MODE   0x00000001

Definition at line 369 of file atapi.h.

PORT_QUEUE_FLAG_SIGNAL_STOP

#define PORT_QUEUE_FLAG_SIGNAL_STOP   0x00000002

Definition at line 370 of file atapi.h.

QUEUE_ENTRY_FROM_IRP

#define QUEUE_ENTRY_FROM_IRP

(

Irp

)

((PREQUEST_QUEUE_ENTRY)&(((PIRP)(Irp))->Tail.Overlay.DriverContext[0]))

Definition at line 310 of file atapi.h.

QUEUE_FLAG_FROZEN_PNP

#define QUEUE_FLAG_FROZEN_PNP   0x00000004

Definition at line 107 of file atapi.h.

QUEUE_FLAG_FROZEN_PORT_BUSY

#define QUEUE_FLAG_FROZEN_PORT_BUSY   0x00000001

Definition at line 105 of file atapi.h.

QUEUE_FLAG_FROZEN_POWER

#define QUEUE_FLAG_FROZEN_POWER   0x00000020

Definition at line 110 of file atapi.h.

QUEUE_FLAG_FROZEN_QUEUE_FREEZE

#define QUEUE_FLAG_FROZEN_QUEUE_FREEZE   0x00000010

Definition at line 109 of file atapi.h.

QUEUE_FLAG_FROZEN_QUEUE_LOCK

#define QUEUE_FLAG_FROZEN_QUEUE_LOCK   0x00080000

Definition at line 112 of file atapi.h.

QUEUE_FLAG_FROZEN_REMOVED

#define QUEUE_FLAG_FROZEN_REMOVED   0x00000040

Definition at line 111 of file atapi.h.

QUEUE_FLAG_FROZEN_SLOT

#define QUEUE_FLAG_FROZEN_SLOT   0x00000002

Definition at line 106 of file atapi.h.

QUEUE_FLAG_SIGNAL_STOP

#define QUEUE_FLAG_SIGNAL_STOP   0x00000008

Definition at line 108 of file atapi.h.

QUEUE_FLAGS_FROZEN

#define QUEUE_FLAGS_FROZEN

Value:

    (QUEUE_FLAG_FROZEN_PORT_BUSY | \
     QUEUE_FLAG_FROZEN_SLOT | \
     QUEUE_FLAG_FROZEN_PNP | \
     QUEUE_FLAG_FROZEN_QUEUE_FREEZE | \
     QUEUE_FLAG_FROZEN_POWER | \
     QUEUE_FLAG_FROZEN_REMOVED | \
     QUEUE_FLAG_FROZEN_QUEUE_LOCK)

Definition at line 114 of file atapi.h.

QUEUE_FLAGS_FROZEN_NOT_BYPASS

#define QUEUE_FLAGS_FROZEN_NOT_BYPASS    (QUEUE_FLAGS_FROZEN & ~(QUEUE_FLAG_FROZEN_QUEUE_FREEZE | QUEUE_FLAG_FROZEN_QUEUE_LOCK))

Definition at line 123 of file atapi.h.

SRB_CLEAR_FLAGS

#define SRB_CLEAR_FLAGS	(		Srb,
			Flags
	)		((Srb)->SrbExtension = (PVOID)((ULONG_PTR)(Srb)->SrbExtension & ~(Flags)))

Definition at line 235 of file atapi.h.

SRB_FLAG_LOW_MEM_RETRY

#define SRB_FLAG_LOW_MEM_RETRY   0x00000100

Definition at line 229 of file atapi.h.

SRB_FLAG_PIO_RETRY

#define SRB_FLAG_PIO_RETRY   0x00000200

Definition at line 230 of file atapi.h.

SRB_FLAG_RETRY_COUNT_MASK

#define SRB_FLAG_RETRY_COUNT_MASK   0x000000FF

Definition at line 228 of file atapi.h.

SRB_GET_FLAGS

#define SRB_GET_FLAGS

(

Srb

)

((ULONG_PTR)(Srb)->SrbExtension)

Definition at line 238 of file atapi.h.

SRB_SET_FLAGS

#define SRB_SET_FLAGS	(		Srb,
			Flags
	)		((Srb)->SrbExtension = (PVOID)((ULONG_PTR)(Srb)->SrbExtension | (Flags)))

Definition at line 232 of file atapi.h.

WORKER_FLAG_COMPLETE_PORT_ENUM_EVENT

#define WORKER_FLAG_COMPLETE_PORT_ENUM_EVENT   0x00000002

Definition at line 280 of file atapi.h.

WORKER_FLAG_NEED_RESCAN

#define WORKER_FLAG_NEED_RESCAN   0x00000001

Definition at line 279 of file atapi.h.

Typedef Documentation

ATA_DEVICE_STATUS

typedef enum _ATA_DEVICE_STATUS ATA_DEVICE_STATUS

ATA_ERROR_LOG_VALUE

typedef enum _ATA_ERROR_LOG_VALUE ATA_ERROR_LOG_VALUE

ATA_PORT_ACTION

typedef enum _ATA_PORT_ACTION ATA_PORT_ACTION

ATA_SCSI_ADDRESS

typedef union _ATA_SCSI_ADDRESS ATA_SCSI_ADDRESS

ATA_WORKER_CONTEXT

typedef struct _ATA_WORKER_CONTEXT ATA_WORKER_CONTEXT

ATA_WORKER_DEVICE_CONTEXT

typedef struct _ATA_WORKER_DEVICE_CONTEXT ATA_WORKER_DEVICE_CONTEXT

ATAPORT_CHANNEL_EXTENSION

typedef struct _ATAPORT_CHANNEL_EXTENSION ATAPORT_CHANNEL_EXTENSION

Definition at line 33 of file atapi.h.

ATAPORT_COMMON_EXTENSION

typedef struct _ATAPORT_COMMON_EXTENSION ATAPORT_COMMON_EXTENSION

ATAPORT_DEVICE_EXTENSION

typedef struct _ATAPORT_DEVICE_EXTENSION ATAPORT_DEVICE_EXTENSION

Definition at line 34 of file atapi.h.

ATAPORT_IO_CONTEXT

typedef struct _ATAPORT_IO_CONTEXT ATAPORT_IO_CONTEXT

Definition at line 36 of file atapi.h.

ATAPORT_PORT_DATA

typedef struct _ATAPORT_PORT_DATA ATAPORT_PORT_DATA

Definition at line 35 of file atapi.h.

PATA_SCSI_ADDRESS

typedef union _ATA_SCSI_ADDRESS * PATA_SCSI_ADDRESS

PATA_WORKER_CONTEXT

typedef struct _ATA_WORKER_CONTEXT * PATA_WORKER_CONTEXT

PATA_WORKER_DEVICE_CONTEXT

typedef struct _ATA_WORKER_DEVICE_CONTEXT * PATA_WORKER_DEVICE_CONTEXT

PATAPORT_CHANNEL_EXTENSION

typedef struct _ATAPORT_CHANNEL_EXTENSION * PATAPORT_CHANNEL_EXTENSION

Definition at line 33 of file atapi.h.

PATAPORT_COMMON_EXTENSION

typedef struct _ATAPORT_COMMON_EXTENSION * PATAPORT_COMMON_EXTENSION

PATAPORT_DEVICE_EXTENSION

typedef struct _ATAPORT_DEVICE_EXTENSION * PATAPORT_DEVICE_EXTENSION

Definition at line 34 of file atapi.h.

PATAPORT_IO_CONTEXT

typedef struct _ATAPORT_IO_CONTEXT * PATAPORT_IO_CONTEXT

Definition at line 36 of file atapi.h.

PATAPORT_PORT_DATA

typedef struct _ATAPORT_PORT_DATA * PATAPORT_PORT_DATA

Definition at line 35 of file atapi.h.

PREQUEST_QUEUE_ENTRY

typedef struct _REQUEST_QUEUE_ENTRY * PREQUEST_QUEUE_ENTRY

PSTOP_IO_CALLBACK

typedef STOP_IO_CALLBACK* PSTOP_IO_CALLBACK

Definition at line 75 of file atapi.h.

REQUEST_QUEUE_ENTRY

typedef struct _REQUEST_QUEUE_ENTRY REQUEST_QUEUE_ENTRY

STOP_IO_CALLBACK

typedef VOID() STOP_IO_CALLBACK(_In_ PATAPORT_IO_CONTEXT Device)

Definition at line 72 of file atapi.h.

Enumeration Type Documentation

_ATA_DEVICE_STATUS

enum _ATA_DEVICE_STATUS

Enumerator
DEV_STATUS_NO_DEVICE
DEV_STATUS_NEW_DEVICE
DEV_STATUS_SAME_DEVICE
DEV_STATUS_FAILED

Definition at line 253 of file atapi.h.

{
    DEV_STATUS_NO_DEVICE,
    DEV_STATUS_NEW_DEVICE,
    DEV_STATUS_SAME_DEVICE,
    DEV_STATUS_FAILED,
} ATA_DEVICE_STATUS;

_ATA_ERROR_LOG_VALUE

enum _ATA_ERROR_LOG_VALUE

Enumerator
EVENT_CODE_CRC_ERROR
EVENT_CODE_BAD_STATE
EVENT_CODE_TIMEOUT
EVENT_CODE_DOWNSHIFT
EVENT_CODE_DMA_DISABLE
EVENT_CODE_NCQ_DISABLE

Definition at line 261 of file atapi.h.

{
    EVENT_CODE_CRC_ERROR = 100,
    EVENT_CODE_BAD_STATE,
    EVENT_CODE_TIMEOUT,
    EVENT_CODE_DOWNSHIFT,
    EVENT_CODE_DMA_DISABLE,
    EVENT_CODE_NCQ_DISABLE,
} ATA_ERROR_LOG_VALUE;

_ATA_PORT_ACTION

enum _ATA_PORT_ACTION

Enumerator
ACTION_PORT_RESET
ACTION_ENUM_PORT
ACTION_ENUM_DEVICE_NEW
ACTION_ENUM_DEVICE
ACTION_PORT_TIMING
ACTION_DEVICE_CONFIG
ACTION_DEVICE_ERROR
ACTION_DEVICE_POWER

Definition at line 241 of file atapi.h.

{
    ACTION_PORT_RESET           = (1 << 0), // High priority
    ACTION_ENUM_PORT            = (1 << 1),
    ACTION_ENUM_DEVICE_NEW      = (1 << 2),
    ACTION_ENUM_DEVICE          = (1 << 3),
    ACTION_PORT_TIMING          = (1 << 4), // Set transfer timings after device enumeration only
    ACTION_DEVICE_CONFIG        = (1 << 5), // Also use the timing information for configuration
    ACTION_DEVICE_ERROR         = (1 << 6),
    ACTION_DEVICE_POWER         = (1 << 7),
} ATA_PORT_ACTION;

DEVICE_TYPE_NAME

enum DEVICE_TYPE_NAME

Enumerator
GetDeviceType
GetGenericType
GetPeripheralId

Definition at line 564 of file atapi.h.

{
    GetDeviceType,
    GetGenericType,
    GetPeripheralId
} DEVICE_TYPE_NAME;

Function Documentation

_Dispatch_type_() [1/6]

_Dispatch_type_

(

IRP_MJ_CREATE

)

Definition at line 1353 of file isapnp.c.

{
    PAGED_CODE();
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
 
    DPRINT("%s(%p, %p)\n", __FUNCTION__, DeviceObject, Irp);
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}

_Dispatch_type_() [2/6]

_Dispatch_type_

(

IRP_MJ_DEVICE_CONTROL

)

Definition at line 1376 of file isapnp.c.

{
    PISAPNP_COMMON_EXTENSION CommonExt = DeviceObject->DeviceExtension;
 
    PAGED_CODE();
 
    DPRINT("%s(%p, %p) Minor - %X\n", __FUNCTION__, DeviceObject, Irp,
           IoGetCurrentIrpStackLocation(Irp)->MinorFunction);
 
    if (CommonExt->Signature == IsaPnpBus)
    {
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(((PISAPNP_FDO_EXTENSION)CommonExt)->Ldo, Irp);
    }
    else
    {
        NTSTATUS Status = Irp->IoStatus.Status;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
}

_Dispatch_type_() [3/6]

_Dispatch_type_

(

IRP_MJ_PNP

)

Definition at line 1331 of file isapnp.c.

{
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PISAPNP_COMMON_EXTENSION DevExt = DeviceObject->DeviceExtension;
 
    PAGED_CODE();
 
    if (DevExt->Signature == IsaPnpBus)
        return IsaFdoPnp((PISAPNP_FDO_EXTENSION)DevExt, Irp, IrpSp);
    else
        return IsaPdoPnp((PISAPNP_PDO_EXTENSION)DevExt, Irp, IrpSp);
}

_Dispatch_type_() [4/6]

_Dispatch_type_

(

IRP_MJ_POWER

)

Definition at line 1293 of file isapnp.c.

{
    PISAPNP_COMMON_EXTENSION DevExt = DeviceObject->DeviceExtension;
    NTSTATUS Status;
 
    if (DevExt->Signature != IsaPnpBus)
    {
        switch (IoGetCurrentIrpStackLocation(Irp)->MinorFunction)
        {
            case IRP_MN_SET_POWER:
            case IRP_MN_QUERY_POWER:
                Status = STATUS_SUCCESS;
                Irp->IoStatus.Status = Status;
                break;
 
            default:
                Status = Irp->IoStatus.Status;
                break;
        }
 
        PoStartNextPowerIrp(Irp);
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
 
    PoStartNextPowerIrp(Irp);
    IoSkipCurrentIrpStackLocation(Irp);
    return PoCallDriver(((PISAPNP_FDO_EXTENSION)DevExt)->Ldo, Irp);
}

_Dispatch_type_() [5/6]

_Dispatch_type_

(

IRP_MJ_SCSI

)

_Dispatch_type_() [6/6]

_Dispatch_type_

(

IRP_MJ_SYSTEM_CONTROL

)

Definition at line 5748 of file btrfs.c.

                                                                                              {
    NTSTATUS Status;
    device_extension* Vcb = DeviceObject->DeviceExtension;
    bool top_level;
 
    FsRtlEnterFileSystem();
 
    top_level = is_top_level(Irp);
 
    Irp->IoStatus.Information = 0;
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        volume_device_extension* vde = DeviceObject->DeviceExtension;
 
        IoSkipCurrentIrpStackLocation(Irp);
 
        Status = IoCallDriver(vde->attached_device, Irp);
 
        goto exit;
    } else if (Vcb && Vcb->type == VCB_TYPE_FS) {
        IoSkipCurrentIrpStackLocation(Irp);
 
        Status = IoCallDriver(Vcb->Vpb->RealDevice, Irp);
 
        goto exit;
    } else if (Vcb && Vcb->type == VCB_TYPE_BUS) {
        bus_device_extension* bde = DeviceObject->DeviceExtension;
 
        IoSkipCurrentIrpStackLocation(Irp);
 
        Status = IoCallDriver(bde->attached_device, Irp);
 
        goto exit;
    }
 
    Status = Irp->IoStatus.Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
exit:
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

AtaCommandUseLba48()

FORCEINLINE BOOLEAN AtaCommandUseLba48	(	_In_ ULONG64	SectorNumber,
		_In_ ULONG	SectorCount
	)

Definition at line 630 of file atapi.h.

{
    /* Use the 48-bit command when reasonable */
    return (((SectorNumber + SectorCount) >= ATA_MAX_LBA_28) || (SectorCount > 0x100));
}

AtaCopyIdStringSafe()

PCHAR AtaCopyIdStringSafe	(	_Out_writes_bytes_all_(MaxLength) PCHAR	Destination,
		_In_reads_bytes_(MaxLength) PUCHAR	Source,
		_In_ ULONG	MaxLength,
		_In_ CHAR	DefaultCharacter
	)

Definition at line 35 of file enum.c.

{
    PCHAR Dest = Destination;
 
    PAGED_CODE();
 
    while (MaxLength != 0)
    {
        const UCHAR Char = *Source;
 
        /* Only characters from space to tilde are allowed in an ID */
        if (Char > ' ' && Char <= '~' && Char != ',')
            *Dest = Char;
        else
            *Dest = DefaultCharacter;
 
        ++Source;
        ++Dest;
        --MaxLength;
    }
 
    return Dest;
}

Referenced by AtaCreateAtapiStandardInquiryData(), AtaPdoFillIdentificationStrings(), and AtaPdoQueryId().

AtaCopyIdStringUnsafe()

PUCHAR AtaCopyIdStringUnsafe	(	_Out_writes_bytes_all_(Length) PUCHAR	Destination,
		_In_reads_bytes_(Length) PUCHAR	Source,
		_In_ ULONG	Length
	)

Definition at line 15 of file enum.c.

{
    ULONG i;
 
    ASSUME((Length >= sizeof(USHORT)) && (Length % sizeof(USHORT)) == 0);
 
    /* Copy the ATA string and swap it */
    for (i = 0; i < Length; i += sizeof(USHORT))
    {
        Destination[i] = Source[i + 1];
        Destination[i + 1] = Source[i];
    }
 
    return &Destination[i - 1];
}

Referenced by AtaCreateStandardInquiryData(), AtaDeviceIsXboxDrive(), AtaReqScsiInquiryDeviceIdentifiers(), and AtaReqScsiInquirySerialNumber().

AtaCreateStandardInquiryData()

VOID AtaCreateStandardInquiryData

(

_In_ PATAPORT_DEVICE_EXTENSION

DevExt

)

Definition at line 1166 of file satl.c.

{
    PIDENTIFY_DEVICE_DATA IdentifyData = &DevExt->IdentifyDeviceData;
    PINQUIRYDATA InquiryData = &DevExt->InquiryData;
    ULONG Offset;
    PUCHAR VersionDescriptor;
 
    PAGED_CODE();
 
    InquiryData->DeviceType = DIRECT_ACCESS_DEVICE;
    InquiryData->RemovableMedia = AtaDevIsRemovable(IdentifyData);
    InquiryData->Versions = 0x07; // SPC-5
    InquiryData->ResponseDataFormat = 2; // This means "Complies to this standard"
 
    if (DevExt->Device.DeviceFlags & DEVICE_NCQ)
        InquiryData->CommandQueue = 1;
 
    /* T10 vendor ID */
    RtlCopyMemory(InquiryData->VendorId, "ATA     ", RTL_FIELD_SIZE(INQUIRYDATA, VendorId));
 
    /* Product ID */
    AtaCopyIdStringUnsafe(InquiryData->ProductId,
                          IdentifyData->ModelNumber,
                          RTL_FIELD_SIZE(INQUIRYDATA, ProductId));
 
    /* Product revision level */
    if (IdentifyData->FirmwareRevision[4] == ' ' &&
        IdentifyData->FirmwareRevision[5] == ' ' &&
        IdentifyData->FirmwareRevision[6] == ' ' &&
        IdentifyData->FirmwareRevision[7] == ' ')
    {
        Offset = 0;
    }
    else
    {
        Offset = 4;
    }
    AtaCopyIdStringUnsafe(InquiryData->ProductRevisionLevel,
                          &IdentifyData->FirmwareRevision[Offset],
                          RTL_FIELD_SIZE(INQUIRYDATA, ProductRevisionLevel));
 
    VersionDescriptor = &InquiryData->Reserved3[3];
 
    /* SAM-5 (no version claimed) */
    *VersionDescriptor++ = 0x00;
    *VersionDescriptor++ = 0xA0;
 
    /* SPC-5 (no version claimed) */
    *VersionDescriptor++ = 0x05;
    *VersionDescriptor++ = 0xC0;
 
    /* SBC-4 (no version claimed) */
    *VersionDescriptor++ = 0x06;
    *VersionDescriptor++ = 0x00;
 
    if (AtaDevHasIeee1667(IdentifyData))
    {
        /* IEEE 1667 (no version claimed) */
        *VersionDescriptor++ = 0xFF;
        *VersionDescriptor++ = 0xC0;
    }
 
    if (IdentifyData->MajorRevision != 0xFFFF)
    {
        if (IdentifyData->MajorRevision & (1 << 8))
        {
            /* ATA/ATAPI-8 ATA8-ACS ATA/ATAPI Command Set (no version claimed) */
            *VersionDescriptor++ = 0x16;
            *VersionDescriptor++ = 0x23;
        }
        else if (IdentifyData->MajorRevision & (1 << 7))
        {
            if (IdentifyData->MinorRevision == 0x1D)
            {
                /* ATA/ATAPI-7 INCITS 397-2005 */
                *VersionDescriptor++ = 0x16;
                *VersionDescriptor++ = 0x1C;
            }
            else
            {
                /* ATA/ATAPI-7 (no version claimed) */
                *VersionDescriptor++ = 0x16;
                *VersionDescriptor++ = 0x00;
            }
        }
        else if (IdentifyData->MajorRevision & (1 << 6))
        {
            if (IdentifyData->MinorRevision == 0x22)
            {
                /* ATA/ATAPI-6 INCITS 361-2002 */
                *VersionDescriptor++ = 0x15;
                *VersionDescriptor++ = 0xFD;
            }
            else
            {
                /* ATA/ATAPI-6 (no version claimed) */
                *VersionDescriptor++ = 0x15;
                *VersionDescriptor++ = 0xE0;
            }
        }
    }
 
    InquiryData->AdditionalLength =
        ((ULONG_PTR)VersionDescriptor - (ULONG_PTR)InquiryData) -
        RTL_SIZEOF_THROUGH_FIELD(INQUIRYDATA, AdditionalLength);
 
    TRACE("VendorId: '%.*s'\n",
          RTL_FIELD_SIZE(INQUIRYDATA, VendorId), InquiryData->VendorId);
    TRACE("ProductId: '%.*s'\n",
          RTL_FIELD_SIZE(INQUIRYDATA, ProductId), InquiryData->ProductId);
    TRACE("ProductRevisionLevel: '%.*s'\n",
          RTL_FIELD_SIZE(INQUIRYDATA, ProductRevisionLevel), InquiryData->ProductRevisionLevel);
}

Referenced by AtaPdoInit().

AtaDeviceFlushPowerIrpQueue()

VOID AtaDeviceFlushPowerIrpQueue

(

_In_ PATAPORT_DEVICE_EXTENSION

DevExt

)

Definition at line 37 of file dev_power.c.

{
    while (TRUE)
    {
        PLIST_ENTRY Entry;
        PIRP PowerIrp;
        KIRQL OldLevel;
 
        KeAcquireSpinLock(&DevExt->Device.QueueLock, &OldLevel);
        if (IsListEmpty(&DevExt->PowerIrpQueueList))
            Entry = NULL;
        else
            Entry = RemoveHeadList(&DevExt->PowerIrpQueueList);
        KeReleaseSpinLock(&DevExt->Device.QueueLock, OldLevel);
 
        if (!Entry)
            break;
 
        PowerIrp = CONTAINING_RECORD(Entry, IRP, Tail.Overlay.ListEntry);
        ASSERT(IoGetCurrentIrpStackLocation(PowerIrp)->MinorFunction == IRP_MN_SET_POWER);
        AtaPowerCompleteIrp(&DevExt->Common, PowerIrp, STATUS_NO_SUCH_DEVICE);
    }
}

Referenced by AtaPortExitStateMachine().

AtaDeviceGetFlushCacheCommand()

UCHAR AtaDeviceGetFlushCacheCommand

(

_In_ PATAPORT_DEVICE_EXTENSION

DevExt

)

Definition at line 63 of file dev_power.c.

{
    UCHAR Command = 0;
 
    if (!IS_ATAPI(&DevExt->Device))
    {
        if ((DevExt->Device.DeviceFlags & DEVICE_LBA48) &&
            AtaDevHasFlushCacheExt(&DevExt->IdentifyDeviceData))
        {
            Command = IDE_COMMAND_FLUSH_CACHE_EXT;
        }
        else if (AtaDevHasFlushCache(&DevExt->IdentifyDeviceData))
        {
            Command = IDE_COMMAND_FLUSH_CACHE;
        }
    }
 
    return Command;
}

Referenced by AtaDeviceFlushCache(), and AtaReqScsiSynchronizeCache().

AtaDeviceQueueEvent()

DECLSPEC_NOINLINE_FROM_PAGED VOID AtaDeviceQueueEvent	(	_In_ PATAPORT_PORT_DATA	PortData,
		_In_opt_ PATAPORT_DEVICE_EXTENSION	DevExt,
		_In_ ATA_PORT_ACTION	Action
	)

Definition at line 992 of file portstate.c.

{
    KIRQL OldIrql;
 
    TRACE("New action %lu\n", Action);
 
    OldIrql = KeAcquireInterruptSpinLock(PortData->InterruptObject);
    AtaPortQueueEvent(PortData, DevExt, NULL, Action);
    KeReleaseInterruptSpinLock(PortData->InterruptObject, OldIrql);
}

Referenced by AtaFdoEnumeratePort(), AtaFdoQueryDeviceCount(), AtaFdoQueryDeviceStatus(), AtaPdoQueuePowerIrp(), and AtaPdoStartDevice().

AtaDeviceSendIdentify()

NTSTATUS AtaDeviceSendIdentify	(	_In_ PATAPORT_PORT_DATA	PortData,
		_In_ PATAPORT_DEVICE_EXTENSION	DevExt,
		_In_ UCHAR	Command
	)

Definition at line 45 of file dev_identify.c.

{
    PATA_DEVICE_REQUEST Request = &PortData->Worker.InternalRequest;
 
    TRACE("CH %lu: Send %s identify device %u\n",
          PortData->PortNumber,
          Command == IDE_COMMAND_IDENTIFY ? "ATA" : "ATAPI",
          DevExt->Device.AtaScsiAddress.TargetId);
 
    /*
     * For PATA devices, disable interrupts for the identify command and use polling instead.
     *
     * On some single device 1 configurations or non-existent IDE channels
     * the status register stuck permanently at a value of 0,
     * and we incorrectly assume that the device is present.
     * This will result in a taskfile timeout
     * which must be avoided as it would cause hangs at boot time.
     */
    Request->Flags = REQUEST_FLAG_POLL;
 
    Request->Flags |= REQUEST_FLAG_DATA_IN | REQUEST_FLAG_HAS_LOCAL_BUFFER;
    Request->TimeOut = 10;
    Request->DataTransferLength = sizeof(DevExt->IdentifyDeviceData);
 
    RtlZeroMemory(&Request->TaskFile, sizeof(Request->TaskFile));
    Request->TaskFile.Command = Command;
 
    return AtaPortSendRequest(PortData, DevExt);
}

Referenced by AtaPortDeviceProcessConfig(), and AtaPortIdentifyDevice().

AtaDeviceSetAddressingMode()

VOID AtaDeviceSetAddressingMode

(

_In_ PATAPORT_DEVICE_EXTENSION

DevExt

)

Definition at line 182 of file enum.c.

{
    PIDENTIFY_DEVICE_DATA IdentifyData = &DevExt->IdentifyDeviceData;
    ULONG64 TotalSectors;
 
    DevExt->Device.DeviceFlags &= ~(DEVICE_LBA_MODE | DEVICE_LBA48 | DEVICE_HAS_FUA);
 
    /* Using LBA addressing mode */
    if (AtaDevHasLbaTranslation(IdentifyData))
    {
        DevExt->Device.DeviceFlags |= DEVICE_LBA_MODE;
 
        if (AtaDevHas48BitAddressFeature(IdentifyData))
        {
            /* Using LBA48 addressing mode */
            TotalSectors = AtaDevUserAddressableSectors48Bit(IdentifyData);
            ASSERT(TotalSectors <= ATA_MAX_LBA_48);
 
            DevExt->Device.DeviceFlags |= DEVICE_LBA48;
 
            if (AtaDevHasForceUnitAccessCommands(IdentifyData))
                DevExt->Device.DeviceFlags |= DEVICE_HAS_FUA;
        }
        else
        {
            /* Using LBA28 addressing mode */
            TotalSectors = AtaDevUserAddressableSectors28Bit(IdentifyData);
            ASSERT(TotalSectors <= ATA_MAX_LBA_28);
        }
    }
    else
    {
        USHORT Cylinders, Heads, SectorsPerTrack;
 
        /* Using CHS addressing mode */
        if (AtaDevIsCurrentGeometryValid(IdentifyData))
        {
            AtaDevCurrentChsTranslation(IdentifyData, &Cylinders, &Heads, &SectorsPerTrack);
        }
        else
        {
            AtaDevDefaultChsTranslation(IdentifyData, &Cylinders, &Heads, &SectorsPerTrack);
        }
        DevExt->Device.Cylinders = Cylinders;
        DevExt->Device.Heads = Heads;
        DevExt->Device.SectorsPerTrack = SectorsPerTrack;
 
        TotalSectors = (ULONG64)Cylinders * Heads * SectorsPerTrack;
    }
 
    /*
     * The sector count can be 0 on faulty devices. It's better to keep
     * them available in the system to allow
     * the user to send any command to the drive through the pass-through interface.
     */
    if (TotalSectors == 0)
    {
        ERR("Unknown geometry\n");
 
        /* Fix up sector count for the READ CAPACITY command */
        TotalSectors = 1;
 
        /* Avoid dividing by zero in READ/WRITE commands */
        DevExt->Device.SectorsPerTrack = 1;
        DevExt->Device.Heads = 1;
    }
 
    DevExt->Device.TotalSectors = TotalSectors;
 
    DevExt->Device.SectorSize = AtaDevBytesPerLogicalSector(IdentifyData);
    ASSERT(DevExt->Device.SectorSize >= ATA_MIN_SECTOR_SIZE);
    DevExt->Device.SectorSize = max(DevExt->Device.SectorSize, ATA_MIN_SECTOR_SIZE);
 
    INFO("Total sectors %I64u of size %lu, CHS %u:%u:%u\n",
         DevExt->Device.TotalSectors,
         DevExt->Device.SectorSize,
         DevExt->Device.Cylinders,
         DevExt->Device.Heads,
         DevExt->Device.SectorsPerTrack);
}

Referenced by AtaPdoInit(), and AtaReqCompleteReadCapacity().

AtaFdoDeviceListInsert()

DECLSPEC_NOINLINE_FROM_PAGED VOID AtaFdoDeviceListInsert	(	_In_ PATAPORT_CHANNEL_EXTENSION	ChanExt,
		_In_ PATAPORT_DEVICE_EXTENSION	DevExt,
		_In_ BOOLEAN	DoInsert
	)

Definition at line 699 of file fdo.c.

{
    PSINGLE_LIST_ENTRY Entry, PrevEntry;
    KIRQL OldLevel;
    ULONG Address = DevExt->Device.AtaScsiAddress.AsULONG;
 
    PAGED_CODE();
 
    KeAcquireSpinLock(&ChanExt->PdoListLock, &OldLevel);
 
    for (Entry = ChanExt->PdoList.Next, PrevEntry = NULL;
         Entry != NULL;
         Entry = Entry->Next)
    {
        PATAPORT_DEVICE_EXTENSION CurrentDevExt;
 
        CurrentDevExt = CONTAINING_RECORD(Entry, ATAPORT_DEVICE_EXTENSION, ListEntry);
 
        if (DoInsert)
        {
            if (CurrentDevExt->Device.AtaScsiAddress.AsULONG > Address)
                break;
        }
        else
        {
            if (CurrentDevExt->Device.AtaScsiAddress.AsULONG == Address)
                break;
        }
 
        PrevEntry = Entry;
    }
 
    /* The device list is ordered by SCSI address (Path:Target:Lun), smallest first */
    if (PrevEntry)
    {
        /* Before the current entry */
        if (DoInsert)
        {
            DevExt->ListEntry.Next = PrevEntry->Next;
            PrevEntry->Next = &DevExt->ListEntry;
        }
        else
        {
            PrevEntry->Next = DevExt->ListEntry.Next;
        }
    }
    else
    {
        /* In the beginning */
        if (DoInsert)
            PushEntryList(&ChanExt->PdoList, &DevExt->ListEntry);
        else
            PopEntryList(&DevExt->ListEntry);
    }
 
    KeReleaseSpinLock(&ChanExt->PdoListLock, OldLevel);
}

Referenced by AtaFdoEnumeratePort(), and AtaPdoRemoveDevice().

AtaFdoFindDeviceByPath()

DECLSPEC_NOINLINE_FROM_PAGED PATAPORT_DEVICE_EXTENSION AtaFdoFindDeviceByPath	(	_In_ PATAPORT_CHANNEL_EXTENSION	ChanExt,
		_In_ ATA_SCSI_ADDRESS	AtaScsiAddress,
		_In_ PVOID	ReferenceTag
	)

Definition at line 614 of file fdo.c.

{
    PATAPORT_DEVICE_EXTENSION DevExt, Result = NULL;
    PSINGLE_LIST_ENTRY Entry;
    KIRQL OldLevel;
    NTSTATUS Status;
 
    KeAcquireSpinLock(&ChanExt->PdoListLock, &OldLevel);
 
    for (Entry = ChanExt->PdoList.Next; Entry != NULL; Entry = Entry->Next)
    {
        DevExt = CONTAINING_RECORD(Entry, ATAPORT_DEVICE_EXTENSION, ListEntry);
 
        if (DevExt->Device.AtaScsiAddress.AsULONG != AtaScsiAddress.AsULONG)
            continue;
 
        if (DevExt->ReportedMissing || DevExt->RemovalPending)
            continue;
 
        if (ReferenceTag)
        {
            Status = IoAcquireRemoveLock(&DevExt->Common.RemoveLock, ReferenceTag);
            if (!NT_SUCCESS(Status))
                break;
        }
 
        Result = DevExt;
        break;
    }
 
    KeReleaseSpinLock(&ChanExt->PdoListLock, OldLevel);
 
    return Result;
}

Referenced by AtaFdoEnumeratePort(), AtaFdoHandleScsiMiniport(), AtaFdoHandleScsiPassthrough(), AtaPdoHandleMiniportSmartVersion(), AtaPortSelectTimings(), and AtaStorageNotificationlDpc().

AtaFdoFindNextDeviceByPath()

DECLSPEC_NOINLINE_FROM_PAGED PATAPORT_DEVICE_EXTENSION AtaFdoFindNextDeviceByPath	(	_In_ PATAPORT_CHANNEL_EXTENSION	ChanExt,
		_Inout_ PATA_SCSI_ADDRESS	AtaScsiAddress,
		_In_ BOOLEAN	SearchRemoveDev,
		_In_ PVOID	ReferenceTag
	)

Definition at line 654 of file fdo.c.

{
    PATAPORT_DEVICE_EXTENSION DevExt, Result = NULL;
    PSINGLE_LIST_ENTRY Entry;
    KIRQL OldLevel;
    NTSTATUS Status;
 
    KeAcquireSpinLock(&ChanExt->PdoListLock, &OldLevel);
 
    for (Entry = ChanExt->PdoList.Next; Entry != NULL; Entry = Entry->Next)
    {
        DevExt = CONTAINING_RECORD(Entry, ATAPORT_DEVICE_EXTENSION, ListEntry);
 
        if (DevExt->Device.AtaScsiAddress.AsULONG <= AtaScsiAddress->AsULONG)
            continue;
 
        if (DevExt->ReportedMissing)
            continue;
 
        if (!SearchRemoveDev && DevExt->RemovalPending)
            continue;
 
        *AtaScsiAddress = DevExt->Device.AtaScsiAddress;
 
        if (ReferenceTag)
        {
            Status = IoAcquireRemoveLock(&DevExt->Common.RemoveLock, ReferenceTag);
            if (!NT_SUCCESS(Status))
                continue;
        }
        Result = DevExt;
        break;
    }
 
    KeReleaseSpinLock(&ChanExt->PdoListLock, OldLevel);
 
    return Result;
}

Referenced by AtaFdoHandleGetScsiInquiryData(), AtaFdoInitializeDeviceRelations(), AtaFdoQueryBusRelations(), AtaFdoRemoveDevice(), AtaPortEnterStateMachine(), AtaPortEnumeratePort(), AtaPortExitStateMachine(), and AtaPortOnResetNotification().

AtaFdoPnp()

NTSTATUS AtaFdoPnp	(	_In_ PATAPORT_CHANNEL_EXTENSION	ChanExt,
		_Inout_ PIRP	Irp
	)

Definition at line 510 of file fdo.c.

{
    NTSTATUS Status;
    PIO_STACK_LOCATION IoStack;
 
    PAGED_CODE();
 
    INFO("(%p, %p) Ch.%lu %s\n",
         ChanExt->Common.Self,
         Irp,
         ChanExt->DeviceObjectNumber,
         GetIRPMinorFunctionString(IoGetCurrentIrpStackLocation(Irp)->MinorFunction));
 
    Status = IoAcquireRemoveLock(&ChanExt->Common.RemoveLock, Irp);
    if (!NT_SUCCESS(Status))
    {
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return Status;
    }
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    switch (IoStack->MinorFunction)
    {
        case IRP_MN_START_DEVICE:
        {
            if (!NT_VERIFY(IoForwardIrpSynchronously(ChanExt->Common.LowerDeviceObject, Irp)))
            {
                Status = STATUS_UNSUCCESSFUL;
                goto CompleteIrp;
            }
            Status = Irp->IoStatus.Status;
            if (!NT_SUCCESS(Status))
                goto CompleteIrp;
 
            Status = AtaFdoStartDevice(ChanExt,
                                       IoStack->Parameters.
                                       StartDevice.AllocatedResourcesTranslated);
            goto CompleteIrp;
        }
 
        case IRP_MN_STOP_DEVICE:
            Status = AtaFdoStopDevice(ChanExt, Irp);
            break;
 
        case IRP_MN_REMOVE_DEVICE:
        case IRP_MN_SURPRISE_REMOVAL:
            return AtaFdoRemoveDevice(ChanExt,
                                      Irp,
                                      (IoStack->MinorFunction == IRP_MN_REMOVE_DEVICE));
 
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            Status = AtaPnpQueryPnpDeviceState(&ChanExt->Common, Irp);
            break;
 
        case IRP_MN_QUERY_DEVICE_RELATIONS:
        {
            if (IoStack->Parameters.QueryDeviceRelations.Type != BusRelations)
                break;
 
            Status = AtaFdoQueryBusRelations(ChanExt, Irp);
            if (!NT_SUCCESS(Status))
                goto CompleteIrp;
 
            Irp->IoStatus.Status = Status;
            break;
        }
 
        case IRP_MN_DEVICE_USAGE_NOTIFICATION:
            Status = AtaPnpQueryDeviceUsageNotification(&ChanExt->Common, Irp);
            break;
 
        case IRP_MN_QUERY_STOP_DEVICE:
        case IRP_MN_QUERY_REMOVE_DEVICE:
        case IRP_MN_CANCEL_STOP_DEVICE:
        case IRP_MN_CANCEL_REMOVE_DEVICE:
            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;
 
        default:
            break;
    }
 
    IoSkipCurrentIrpStackLocation(Irp);
    Status = IoCallDriver(ChanExt->Common.LowerDeviceObject, Irp);
 
    IoReleaseRemoveLock(&ChanExt->Common.RemoveLock, Irp);
 
    return Status;
 
CompleteIrp:
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    IoReleaseRemoveLock(&ChanExt->Common.RemoveLock, Irp);
 
    return Status;
}

Referenced by AtaDispatchPnp().

AtaFdoQueryBusRelations()

NTSTATUS AtaFdoQueryBusRelations	(	_In_ PATAPORT_CHANNEL_EXTENSION	ChanExt,
		_In_ PIRP	Irp
	)

Definition at line 566 of file enum.c.

{
    PDEVICE_RELATIONS DeviceRelations = NULL;
    ULONG Size, PdoCount;
    ATA_SCSI_ADDRESS AtaScsiAddress;
#if DBG
    LARGE_INTEGER TimeStart, TimeFinish;
    ULONG EnumTimeMs;
#endif
 
    PAGED_CODE();
 
#if DBG
    KeQuerySystemTime(&TimeStart);
#endif
 
    AtaScsiAddress.AsULONG = 0;
    while (TRUE)
    {
        PATAPORT_DEVICE_EXTENSION DevExt;
 
        DevExt = AtaFdoFindNextDeviceByPath(ChanExt, &AtaScsiAddress, TRUE, NULL);
        if (!DevExt)
            break;
 
        DevExt->NotPresent = TRUE;
 
        if (DevExt->Device.AtaScsiAddress.Lun == 0)
        {
            AtaGetRegistryKey(ChanExt,
                              DevExt->Device.AtaScsiAddress.TargetId,
                              DD_ATA_REG_XFER_MODE_ALLOWED,
                              &DevExt->TransferModeUserAllowedMask,
                              MAXULONG);
        }
    }
 
    AtaFdoEnumeratePort(ChanExt);
 
    PdoCount = 0;
    AtaScsiAddress.AsULONG = 0;
    while (TRUE)
    {
        PATAPORT_DEVICE_EXTENSION DevExt;
 
        DevExt = AtaFdoFindNextDeviceByPath(ChanExt, &AtaScsiAddress, TRUE, NULL);
        if (!DevExt)
            break;
 
        if (!DevExt->NotPresent)
            ++PdoCount;
    }
 
    Size = FIELD_OFFSET(DEVICE_RELATIONS, Objects[PdoCount]);
    DeviceRelations = ExAllocatePoolUninitialized(PagedPool, Size, ATAPORT_TAG);
    if (!DeviceRelations)
    {
        ERR("Failed to allocate device relations\n");
        goto Cleanup;
    }
 
    AtaFdoInitializeDeviceRelations(ChanExt, DeviceRelations);
 
#if DBG
    KeQuerySystemTime(&TimeFinish);
    EnumTimeMs = (TimeFinish.QuadPart - TimeStart.QuadPart) / 10000;
    if (EnumTimeMs >= 5000)
    {
        WARN("%lu: QBR request took %lu ms, %lu devices\n",
             ChanExt->ScsiPortNumber,
             EnumTimeMs,
             DeviceRelations->Count);
    }
    else
    {
        INFO("%lu: QBR request took %lu ms, %lu devices\n",
             ChanExt->ScsiPortNumber,
             EnumTimeMs,
             DeviceRelations->Count);
    }
#endif
 
    Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
    return STATUS_SUCCESS;
 
Cleanup:
    if (DeviceRelations)
        ExFreePoolWithTag(DeviceRelations, ATAPORT_TAG);
 
    return STATUS_INSUFFICIENT_RESOURCES;
}

Referenced by AtaFdoPnp().

AtaFdoStartDevice()

NTSTATUS AtaFdoStartDevice	(	_In_ PATAPORT_CHANNEL_EXTENSION	ChanExt,
		_In_ PCM_RESOURCE_LIST	ResourcesTranslated
	)

Definition at line 229 of file fdo.c.

{
    PATAPORT_PORT_DATA PortData = &ChanExt->PortData;
    PCIIDEX_CHANNEL_INTERFACE ChannelInterface = { 0 };
    NTSTATUS Status;
 
    PAGED_CODE();
 
    INFO("Starting channel %lu\n", ChanExt->DeviceObjectNumber);
 
    /* Get the interface of ATA channel */
    Status = AtaPnpQueryInterface(&ChanExt->Common,
                                  &GUID_PCIIDE_INTERFACE_ROS,
                                  &ChannelInterface,
                                  PCIIDEX_INTERFACE_VERSION,
                                  sizeof(ChannelInterface));
    if (!NT_SUCCESS(Status))
    {
        ERR("Failed to query channel interface %lx\n", Status);
        return Status;
    }
    PortData->ChannelContext = ChannelInterface.ChannelContext;
    PortData->AttachChannel = ChannelInterface.AttachChannel;
    PortData->SetDeviceData = ChannelInterface.SetDeviceData;
    PortData->GetInitTaskFile = ChannelInterface.GetInitTaskFile;
    PortData->DowngradeInterfaceSpeed = ChannelInterface.DowngradeInterfaceSpeed;
    PortData->InterruptObject = ChannelInterface.InterruptObject;
    PortData->AbortChannel = ChannelInterface.AbortChannel;
    PortData->ResetChannel = ChannelInterface.ResetChannel;
    PortData->EnumerateChannel = ChannelInterface.EnumerateChannel;
    PortData->IdentifyDevice = ChannelInterface.IdentifyDevice;
    PortData->SetTransferMode = ChannelInterface.SetTransferMode;
    PortData->AllocateSlot = ChannelInterface.AllocateSlot;
    PortData->PreparePrdTable = ChannelInterface.PreparePrdTable;
    PortData->PrepareIo = ChannelInterface.PrepareIo;
    PortData->StartIo = ChannelInterface.StartIo;
    PortData->MaxTargetId = ChannelInterface.MaxTargetId;
    PortData->MaximumTransferLength = ChannelInterface.MaximumTransferLength;
    PortData->MaximumPhysicalPages = ChannelInterface.MaximumPhysicalPages;
    PortData->QueueDepth = ChannelInterface.QueueDepth;
    PortData->PortNumber = ChannelInterface.Channel;
    PortData->DmaAdapter = ChannelInterface.DmaAdapter;
    PortData->ChannelObject = ChannelInterface.ChannelObject;
 
    PortData->InterruptFlags = PORT_INT_FLAG_IS_IO_ACTIVE;
    PortData->FreeSlotsBitmap =
    PortData->MaxSlotsBitmap = NUM_TO_BITMAP(PortData->QueueDepth);
    /* We need the slot numbers to start from zero */
    PortData->LastUsedSlot = RTL_BITS_OF(ULONG) - 1;
 
    if (!(ChannelInterface.TransferModeSupported & ~PIO_ALL))
        PortData->PortFlags |= PORT_FLAG_PIO_ONLY;
 
    if (ChannelInterface.Flags & ATA_CHANNEL_FLAG_PIO_VIA_DMA)
        PortData->PortFlags |= PORT_FLAG_PIO_VIA_DMA;
 
    if (ChannelInterface.Flags & ATA_CHANNEL_FLAG_NCQ)
        PortData->PortFlags |= PORT_FLAG_NCQ;
 
    if (ChannelInterface.Flags & ATA_CHANNEL_FLAG_IS_AHCI)
        PortData->PortFlags |= PORT_FLAG_IS_AHCI;
 
    if (ChannelInterface.Flags & ATA_CHANNEL_FLAG_IS_EXTERNAL)
        PortData->PortFlags |= PORT_FLAG_IS_EXTERNAL;
 
    if (ChannelInterface.Flags & ATA_CHANNEL_FLAG_PIO_FOR_LBA48_XFER)
        PortData->PortFlags |= PORT_FLAG_PIO_FOR_LBA48_XFER;
 
    if (ChannelInterface.HwSyncObject)
    {
        PortData->PortFlags |= PORT_FLAG_IS_SIMPLEX;
        PortData->HwSyncObject = ChannelInterface.HwSyncObject;
    }
 
    /* Reserve PIO memory resources early. Storage drivers should not fail paging I/O operations */
    if (!(ChannelInterface.Flags & ATA_CHANNEL_FLAG_PIO_VIA_DMA) && !PortData->ReservedVaSpace)
    {
        PortData->ReservedVaSpace = MmAllocateMappingAddress(ATA_RESERVED_PAGES * PAGE_SIZE,
                                                             ATAPORT_TAG);
    }
 
    Status = AtaFdoAllocateLocalBuffer(PortData);
    if (!NT_SUCCESS(Status))
    {
        ERR("CH %lu: Failed to allocate local buffer 0x%lx\n", PortData->PortNumber, Status);
        return Status;
    }
 
    InitializeListHead(&PortData->PortQueueList);
    KeInitializeEvent(&PortData->QueueStoppedEvent, NotificationEvent, FALSE);
 
    KeInitializeDpc(&PortData->Worker.Dpc, AtaPortWorkerSignalDpc, PortData);
    KeInitializeDpc(&PortData->Worker.NotificationDpc, AtaStorageNotificationlDpc, PortData);
    KeInitializeSpinLock(&PortData->Worker.Lock);
    KeInitializeEvent(&PortData->Worker.EnumerationEvent, NotificationEvent, FALSE);
 
    KeInitializeEvent(&PortData->Worker.CompletionEvent, NotificationEvent, FALSE);
    PortData->Worker.InternalRequest.Complete = AtaPortCompleteInternalRequest;
#if DBG
    PortData->Worker.InternalRequest.Signature = ATA_DEVICE_REQUEST_SIGNATURE;
#endif
 
    Status = AtaFdoCreatePortThread(PortData);
    if (!NT_SUCCESS(Status))
    {
        ERR("CH %lu: Failed to create port thread 0x%lx\n", PortData->PortNumber, Status);
        return Status;
    }
 
    Status = AtaFdoCreateSymLinks(ChanExt);
    if (!NT_SUCCESS(Status))
    {
        ERR("CH %lu: Failed to create symbolic links 0x%lx\n", PortData->PortNumber, Status);
        return Status;
    }
 
    AtaSetPortRegistryKey(ChanExt, DD_ATA_REG_MAX_TARGET_ID, PortData->MaxTargetId);
 
    Status = IoRegisterDeviceInterface(ChanExt->Common.Self,
                                       &GUID_DEVINTERFACE_STORAGEPORT,
                                       NULL,
                                       &ChanExt->StorageInterfaceName);
    if (NT_SUCCESS(Status))
    {
        INFO("InterfaceName: '%wZ'\n", &ChanExt->StorageInterfaceName);
 
        Status = IoSetDeviceInterfaceState(&ChanExt->StorageInterfaceName, TRUE);
        if (!NT_SUCCESS(Status))
        {
            RtlFreeUnicodeString(&ChanExt->StorageInterfaceName);
            ChanExt->StorageInterfaceName.Buffer = NULL;
        }
    }
 
    *ChannelInterface.PortContext = PortData;
    *ChannelInterface.PortNotification = AtaPortNotification;
    *ChannelInterface.Slots = PortData->Slots;
 
    Status = IoInitializeTimer(ChanExt->Common.Self, AtaPortIoTimer, PortData);
    if (!NT_SUCCESS(Status))
        return Status;
 
    IoStartTimer(ChanExt->Common.Self);
    PortData->PortFlags |= PORT_FLAG_IO_TIMER_ACTIVE;
 
    Status = PortData->AttachChannel(PortData->ChannelContext, TRUE);
    if (!NT_SUCCESS(Status))
    {
        ERR("CH %lu: Failed to attach channel %lx\n", PortData->PortNumber, Status);
        return Status;
    }
    PortData->PortFlags |= PORT_FLAG_CHANNEL_ATTACHED;
 
    return STATUS_SUCCESS;
}

Referenced by AtaFdoPnp().

AtaGetRegistryKey()

VOID AtaGetRegistryKey	(	_In_ PATAPORT_CHANNEL_EXTENSION	ChanExt,
		_In_ UCHAR	TargetId,
		_In_ PCWSTR	KeyName,
		_Out_ PULONG	KeyValue,
		_In_ ULONG	DefaultValue
	)

Definition at line 113 of file atapi.c.

{
    UCHAR Buffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(*KeyValue)];
    HANDLE HwKeyHandle, TargetKeyHandle;
    UNICODE_STRING ValueName, TargetKeyName;
    NTSTATUS Status;
    WCHAR TargetKeyBuffer[sizeof("Target99")];
    ULONG ResultLength;
    PKEY_VALUE_PARTIAL_INFORMATION PartialInfo = (PVOID)Buffer;
 
    PAGED_CODE();
 
    Status = IoOpenDeviceRegistryKey(ChanExt->Pdo,
                                     PLUGPLAY_REGKEY_DEVICE,
                                     KEY_ALL_ACCESS,
                                     &HwKeyHandle);
    if (!NT_SUCCESS(Status))
    {
        TRACE("Failed to open device hardware key, status 0x%lx\n", Status);
        return;
    }
 
    /* Open or create the 'TargetX' key */
    Status = RtlStringCbPrintfW(TargetKeyBuffer,
                                sizeof(TargetKeyBuffer),
                                L"Target%u",
                                TargetId);
    ASSERT(NT_SUCCESS(Status));
    RtlInitUnicodeString(&TargetKeyName, TargetKeyBuffer);
    Status = AtaOpenRegistryKey(&TargetKeyHandle, HwKeyHandle, &TargetKeyName, TRUE);
    if (!NT_SUCCESS(Status))
    {
        TRACE("Failed to create '%wZ' key, status 0x%lx\n", &TargetKeyName, Status);
        goto Cleanup;
    }
 
    RtlInitUnicodeString(&ValueName, KeyName);
    Status = ZwQueryValueKey(TargetKeyHandle,
                             &ValueName,
                             KeyValuePartialInformation,
                             PartialInfo,
                             sizeof(Buffer),
                             &ResultLength);
    ZwClose(TargetKeyHandle);
    if (!NT_SUCCESS(Status) ||
        (PartialInfo->Type != REG_DWORD) ||
        (PartialInfo->DataLength != sizeof(*KeyValue)))
    {
        TRACE("Failed to read '%wZ' key, status 0x%lx\n", &ValueName, Status);
 
        *KeyValue = DefaultValue;
        goto Cleanup;
    }
 
    *KeyValue = *(PULONG)&PartialInfo->Data;
 
Cleanup:
    ZwClose(HwKeyHandle);
}

Referenced by AtaFdoEnumeratePort(), AtaFdoQueryBusRelations(), and AtaPdoInit().

AtaMarshallScsiAddress()

FORCEINLINE ATA_SCSI_ADDRESS AtaMarshallScsiAddress	(	_In_ ULONG	PathId,
		_In_ ULONG	TargetId,
		_In_ ULONG	Lun
	)

Definition at line 585 of file atapi.h.

{
    ATA_SCSI_ADDRESS AtaScsiAddress;
 
    AtaScsiAddress.Lun = Lun;
    AtaScsiAddress.TargetId = TargetId;
    AtaScsiAddress.PathId = PathId;
 
    /* This is used for address comparison. See AtaFdoFindNextDeviceByPath() */
    AtaScsiAddress.IsValid = 0xAA;
 
    return AtaScsiAddress;
}

Referenced by AtaFdoEnumeratePort(), AtaFdoHandleScsiMiniport(), AtaFdoHandleScsiPassthrough(), AtaPdoHandleMiniportSmartVersion(), AtaPortSelectTimings(), and AtaStorageNotificationlDpc().

AtaOpenRegistryKey()

NTSTATUS AtaOpenRegistryKey	(	_Out_ PHANDLE	KeyHandle,
		_In_ HANDLE	RootKey,
		_In_ PUNICODE_STRING	KeyName,
		_In_ BOOLEAN	Create
	)

Definition at line 75 of file atapi.c.

{
    NTSTATUS Status;
    ULONG Disposition;
    OBJECT_ATTRIBUTES ObjectAttributes;
 
    PAGED_CODE();
 
    InitializeObjectAttributes(&ObjectAttributes,
                               KeyName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               RootKey,
                               NULL);
 
    if (Create)
    {
        Status = ZwCreateKey(KeyHandle,
                             KEY_ALL_ACCESS,
                             &ObjectAttributes,
                             0,
                             NULL,
                             REG_OPTION_VOLATILE,
                             &Disposition);
    }
    else
    {
        Status = ZwOpenKey(KeyHandle, KEY_ALL_ACCESS, &ObjectAttributes);
    }
 
    return Status;
}

Referenced by AtaGetRegistryKey(), and AtaSetRegistryKey().

AtaPacketCommandUseDma()

FORCEINLINE BOOLEAN AtaPacketCommandUseDma

(

_In_ UCHAR

OpCode

)

Definition at line 613 of file atapi.h.

{
    return (OpCode == SCSIOP_READ6 ||
            OpCode == SCSIOP_WRITE6 ||
            OpCode == SCSIOP_READ ||
            OpCode == SCSIOP_WRITE ||
            OpCode == SCSIOP_READ12 ||
            OpCode == SCSIOP_WRITE12 ||
            OpCode == SCSIOP_READ16 ||
            OpCode == SCSIOP_WRITE16 ||
            OpCode == SCSIOP_READ_CD ||
            OpCode == SCSIOP_READ_CD_MSF);
}

Referenced by AtaReqPreparePacketCommand().

AtaPdoCreateDevice()

PATAPORT_DEVICE_EXTENSION AtaPdoCreateDevice	(	_In_ PATAPORT_CHANNEL_EXTENSION	ChanExt,
		_In_ ATA_SCSI_ADDRESS	AtaScsiAddress
	)

Definition at line 685 of file pdo.c.

{
    PATAPORT_PORT_DATA PortData = &ChanExt->PortData;
    NTSTATUS Status;
    UNICODE_STRING DeviceName;
    PATAPORT_DEVICE_EXTENSION DevExt;
    PDEVICE_OBJECT Pdo;
    WCHAR DeviceNameBuffer[sizeof("\\Device\\Ide\\IdeDeviceP99999T9L9-FFF")];
    ULONG i;
    DECLARE_PAGED_WSTRING(PdoFormat, L"\\Device\\Ide\\IdeDeviceP%luT%luL%lu-%lx");
    static ULONG AtapPdoNumber = 0;
 
    PAGED_CODE();
 
    Status = RtlStringCbPrintfW(DeviceNameBuffer,
                                sizeof(DeviceNameBuffer),
                                PdoFormat,
                                ChanExt->DeviceObjectNumber,
                                AtaScsiAddress.TargetId,
                                AtaScsiAddress.Lun,
                                AtapPdoNumber++);
    ASSERT(NT_SUCCESS(Status));
    RtlInitUnicodeString(&DeviceName, DeviceNameBuffer);
 
    Status = IoCreateDevice(ChanExt->Common.Self->DriverObject,
                            sizeof(*DevExt),
                            &DeviceName,
                            FILE_DEVICE_MASS_STORAGE,
                            FILE_DEVICE_SECURE_OPEN,
                            FALSE,
                            &Pdo);
    if (!NT_SUCCESS(Status))
    {
        ERR("Failed to create PDO '%wZ' with status 0x%lx\n", &DeviceName, Status);
        return NULL;
    }
 
    INFO("Created device object %p '%wZ'\n", Pdo, &DeviceName);
 
    /* DMA buffers alignment */
    Pdo->AlignmentRequirement = ChanExt->Common.Self->AlignmentRequirement;
    Pdo->AlignmentRequirement = max(Pdo->AlignmentRequirement, ATA_MIN_BUFFER_ALIGNMENT);
 
    Pdo->Flags |= DO_DIRECT_IO;
 
    DevExt = Pdo->DeviceExtension;
 
    RtlZeroMemory(DevExt, sizeof(*DevExt));
    AtaPnpInitializeCommonExtension(&DevExt->Common, Pdo, ChanExt->Common.Flags & ~DO_IS_FDO);
    DevExt->Common.FdoExt = ChanExt;
    DevExt->TransferModeAllowedMask = MAXULONG;
    DevExt->Device.SectorSize = ATA_MIN_SECTOR_SIZE;
    DevExt->Device.PortData = PortData;
    DevExt->Device.LocalBuffer = PortData->LocalBuffer;
 
    DevExt->Device.AtaScsiAddress = AtaScsiAddress;
    DevExt->Device.TransportFlags = AtaScsiAddress.TargetId;
    DevExt->Device.DeviceSelect = IDE_DRIVE_SELECT | AtaScsiAddress.Lun;
 
    if (!(PortData->PortFlags & PORT_FLAG_IS_AHCI))
    {
        /* Master/Slave select bit */
        DevExt->Device.DeviceSelect |= ((AtaScsiAddress.TargetId & 1) << 4);
    }
 
    DevExt->Device.DeviceFlags = DEVICE_UNINITIALIZED;
 
    if (PortData->PortFlags & PORT_FLAG_IS_EXTERNAL)
        DevExt->Device.DeviceFlags |= DEVICE_IS_PDO_REMOVABLE;
 
    if (PortData->PortFlags & PORT_FLAG_PIO_VIA_DMA)
        DevExt->Device.DeviceFlags |= DEVICE_PIO_VIA_DMA;
 
    if (PortData->PortFlags & PORT_FLAG_PIO_FOR_LBA48_XFER)
        DevExt->Device.DeviceFlags |= DEVICE_PIO_FOR_LBA48_XFER;
 
    /* Device's capability not explored, yet */
    DevExt->Device.DeviceFlags |= DEVICE_PIO_ONLY;
 
    DevExt->Device.FreeRequestsBitmap =
    DevExt->Device.MaxRequestsBitmap = NUM_TO_BITMAP(PortData->QueueDepth);
 
    DevExt->Device.Requests = ExAllocatePoolZero(NonPagedPool,
                                                 sizeof(ATA_DEVICE_REQUEST) * PortData->QueueDepth,
                                                 ATAPORT_TAG);
    if (!DevExt->Device.Requests)
        goto Failure;
 
    for (i = 0; i < PortData->QueueDepth; ++i)
    {
        PATA_DEVICE_REQUEST Request = &DevExt->Device.Requests[i];
 
        Request->Device = (PATA_IO_CONTEXT_COMMON)&DevExt->Device;
#if DBG
        Request->Signature = ATA_DEVICE_REQUEST_SIGNATURE;
#endif
    }
 
    KeInitializeSpinLock(&DevExt->Device.QueueLock);
    InitializeListHead(&DevExt->Device.DeviceQueueList);
    InitializeListHead(&DevExt->PowerIrpQueueList);
    KeInitializeEvent(&DevExt->Device.QueueStoppedEvent, NotificationEvent, FALSE);
    KeInitializeEvent(&DevExt->Worker.EnumerationEvent, NotificationEvent, FALSE);
    KeInitializeEvent(&DevExt->Worker.ConfigureEvent, NotificationEvent, FALSE);
 
    return DevExt;
 
Failure:
    AtaPdoFreeDevice(DevExt);
 
    return NULL;
}

Referenced by AtaFdoEnumeratePort().

AtaPdoFreeDevice()

VOID AtaPdoFreeDevice

(

_In_ PATAPORT_DEVICE_EXTENSION

DevExt

)

Definition at line 658 of file pdo.c.

{
    PAGED_CODE();
 
    if (DevExt->Device.PowerIdleCounter)
    {
        PoRegisterDeviceForIdleDetection(DevExt->Common.Self,
                                         0,
                                         0,
                                         PowerDeviceD3);
    }
 
    if (DevExt->GtfDataBuffer)
    {
        ExFreePoolWithTag(DevExt->GtfDataBuffer, ATAPORT_TAG);
        DevExt->GtfDataBuffer = NULL;
    }
 
    if (DevExt->Device.Requests)
        ExFreePoolWithTag(DevExt->Device.Requests, ATAPORT_TAG);
 
    IoDeleteDevice(DevExt->Common.Self);
}

Referenced by AtaFdoEnumeratePort(), AtaFdoRemoveDevice(), AtaPdoCreateDevice(), and AtaPdoRemoveDevice().

AtaPdoHandleMiniportIdentify()

NTSTATUS AtaPdoHandleMiniportIdentify	(	_In_ PATAPORT_DEVICE_EXTENSION	DevExt,
		_In_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 207 of file smart.c.

{
    union _PARAMS
    {
        PSENDCMDINPARAMS CmdIn;
        PSENDCMDOUTPARAMS CmdOut;
    } Buffer;
 
    PAGED_CODE();
 
    if (Srb->DataTransferLength <
        (sizeof(SRB_IO_CONTROL) + sizeof(*Buffer.CmdOut) - 1 + IDENTIFY_BUFFER_SIZE))
    {
        Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    Buffer.CmdIn = (PSENDCMDINPARAMS)(((PUCHAR)Srb->DataBuffer) + sizeof(SRB_IO_CONTROL));
 
    if (IS_ATAPI(&DevExt->Device) || (Buffer.CmdIn->irDriveRegs.bCommandReg != ID_CMD))
    {
        Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    Buffer.CmdOut->cBufferSize = IDENTIFY_BUFFER_SIZE;
    Buffer.CmdOut->DriverStatus.bDriverError = 0;
    Buffer.CmdOut->DriverStatus.bIDEError = 0;
 
    RtlCopyMemory(Buffer.CmdOut->bBuffer, &DevExt->IdentifyDeviceData, IDENTIFY_BUFFER_SIZE);
 
    Srb->SrbStatus = SRB_STATUS_SUCCESS;
    return STATUS_SUCCESS;
}

Referenced by AtaPdoHandleIoControl().

AtaPdoHandleMiniportSmartVersion()

NTSTATUS AtaPdoHandleMiniportSmartVersion	(	_In_ PATAPORT_DEVICE_EXTENSION	DevExt,
		_In_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 246 of file smart.c.

{
    PATAPORT_CHANNEL_EXTENSION ChanExt = DevExt->Common.FdoExt;
    PATAPORT_PORT_DATA PortData = &ChanExt->PortData;
    PGETVERSIONINPARAMS VersionParameters;
    ULONG i;
 
    PAGED_CODE();
 
    if (Srb->DataTransferLength < (sizeof(*VersionParameters) + sizeof(SRB_IO_CONTROL)))
    {
        Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    VersionParameters = (PGETVERSIONINPARAMS)(((PUCHAR)Srb->DataBuffer) + sizeof(SRB_IO_CONTROL));
 
    /* SMART 1.03 */
    VersionParameters->bVersion = 1;
    VersionParameters->bRevision = 1;
    VersionParameters->bReserved = 0;
 
    VersionParameters->fCapabilities = (CAP_ATA_ID_CMD | CAP_ATAPI_ID_CMD | CAP_SMART_CMD);
 
    VersionParameters->bIDEDeviceMap = 0;
 
    /* Emulate the PATA behavior */
    for (i = 0; i < MAX_IDE_DEVICE; ++i)
    {
        PATAPORT_DEVICE_EXTENSION DevExt;
        ULONG DeviceFlag;
 
        DevExt = AtaFdoFindDeviceByPath(ChanExt,
                                        AtaMarshallScsiAddress(PortData->PortNumber, i, 0),
                                        Srb);
        if (!DevExt)
            continue;
 
        DeviceFlag = 1 << i;
        if (PortData->PortNumber != 0)
            DeviceFlag <<= 2;
        if (IS_ATAPI(&DevExt->Device))
            DeviceFlag <<= 4;
        VersionParameters->bIDEDeviceMap |= DeviceFlag;
 
        IoReleaseRemoveLock(&DevExt->Common.RemoveLock, Srb);
    }
 
    Srb->SrbStatus = SRB_STATUS_SUCCESS;
    return STATUS_SUCCESS;
}

Referenced by AtaPdoHandleIoControl().

AtaPdoWmiRegistration()

NTSTATUS AtaPdoWmiRegistration	(	_In_ PATAPORT_DEVICE_EXTENSION	DevExt,
		_In_ BOOLEAN	Register
	)

Definition at line 189 of file wmi.c.

{
    ULONG Action;
 
    PAGED_CODE();
 
    if (Register)
    {
        DevExt->WmiLibInfo.GuidCount = RTL_NUMBER_OF(AtapWmiGuidList);
        DevExt->WmiLibInfo.GuidList = AtapWmiGuidList;
 
        DevExt->WmiLibInfo.QueryWmiRegInfo = AtaQueryWmiRegInfo;
        DevExt->WmiLibInfo.QueryWmiDataBlock = AtaQueryWmiDataBlock;
 
        Action = WMIREG_ACTION_REGISTER;
    }
    else
    {
        Action = WMIREG_ACTION_DEREGISTER;
    }
 
    return IoWMIRegistrationControl(DevExt->Common.Self, Action);
}

Referenced by AtaPdoRemoveDevice(), and AtaPdoStartDevice().

AtaPnpInitializeCommonExtension()

VOID AtaPnpInitializeCommonExtension	(	_In_ PATAPORT_COMMON_EXTENSION	CommonExt,
		_In_ PDEVICE_OBJECT	SelfDeviceObject,
		_In_ ULONG	Flags
	)

Definition at line 572 of file atapi.c.

{
    PAGED_CODE();
 
    CommonExt->Flags = Flags;
    CommonExt->Self = SelfDeviceObject;
    CommonExt->DevicePowerState = PowerDeviceD0;
    CommonExt->SystemPowerState = PowerSystemWorking;
 
    IoInitializeRemoveLock(&CommonExt->RemoveLock, ATAPORT_TAG, 0, 0);
}

Referenced by AtaAddChannel(), and AtaPdoCreateDevice().

AtaPnpQueryDeviceUsageNotification()

NTSTATUS AtaPnpQueryDeviceUsageNotification	(	_In_ PATAPORT_COMMON_EXTENSION	CommonExt,
		_In_ PIRP	Irp
	)

Definition at line 503 of file atapi.c.

{
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
    volatile LONG* Counter;
 
    PAGED_CODE();
 
    if (!IS_FDO(CommonExt))
    {
        Status = AtaPnpRepeatRequest(CommonExt, Irp, NULL);
    }
    else
    {
        if (!NT_VERIFY(IoForwardIrpSynchronously(CommonExt->LowerDeviceObject, Irp)))
            return STATUS_UNSUCCESSFUL;
        Status = Irp->IoStatus.Status;
    }
    if (!NT_SUCCESS(Status))
        return Status;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    switch (IoStack->Parameters.UsageNotification.Type)
    {
        case DeviceUsageTypePaging:
            Counter = &CommonExt->PageFiles;
            break;
 
        case DeviceUsageTypeHibernation:
            Counter = &CommonExt->HibernateFiles;
            break;
 
        case DeviceUsageTypeDumpFile:
            Counter = &CommonExt->DumpFiles;
            break;
 
        default:
            return Status;
    }
 
    IoAdjustPagingPathCount(Counter, IoStack->Parameters.UsageNotification.InPath);
 
    if (!IS_FDO(CommonExt))
        IoInvalidateDeviceState(CommonExt->Self);
 
    return STATUS_SUCCESS;
}

Referenced by AtaFdoPnp(), and AtaPdoPnp().

AtaPnpQueryInterface()

NTSTATUS AtaPnpQueryInterface	(	_In_ PATAPORT_COMMON_EXTENSION	CommonExt,
		_In_ const GUID *	Guid,
		_Out_ PVOID	Interface,
		_In_ ULONG	Version,
		_In_ ULONG	Size
	)

Definition at line 396 of file atapi.c.

{
    KEVENT Event;
    PIRP Irp;
    IO_STATUS_BLOCK IoStatusBlock;
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP,
                                       CommonExt->LowerDeviceObject,
                                       NULL,
                                       0,
                                       NULL,
                                       &Event,
                                       &IoStatusBlock);
    if (!Irp)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 
    IoStack = IoGetNextIrpStackLocation(Irp);
    IoStack->MinorFunction = IRP_MN_QUERY_INTERFACE;
    IoStack->Parameters.QueryInterface.InterfaceType = Guid;
    IoStack->Parameters.QueryInterface.Size = Size;
    IoStack->Parameters.QueryInterface.Version = Version;
    IoStack->Parameters.QueryInterface.Interface = Interface;
    IoStack->Parameters.QueryInterface.InterfaceSpecificData = NULL;
 
    Status = IoCallDriver(CommonExt->LowerDeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        Status = IoStatusBlock.Status;
    }
 
    return Status;
}

Referenced by AtaFdoStartDevice().

AtaPnpQueryPnpDeviceState()

NTSTATUS AtaPnpQueryPnpDeviceState	(	_In_ PATAPORT_COMMON_EXTENSION	CommonExt,
		_In_ PIRP	Irp
	)

Definition at line 555 of file atapi.c.

{
    PAGED_CODE();
 
    if (CommonExt->PageFiles || CommonExt->HibernateFiles || CommonExt->DumpFiles)
        Irp->IoStatus.Information |= PNP_DEVICE_NOT_DISABLEABLE;
 
    if (IS_FDO(CommonExt))
        Irp->IoStatus.Status = STATUS_SUCCESS;
 
    return STATUS_SUCCESS;
}

Referenced by AtaFdoPnp(), and AtaPdoPnp().

AtaPnpRepeatRequest()

NTSTATUS AtaPnpRepeatRequest	(	_In_ PATAPORT_COMMON_EXTENSION	CommonExt,
		_In_ PIRP	Irp,
		_In_opt_ PDEVICE_CAPABILITIES	DeviceCapabilities
	)

Definition at line 445 of file atapi.c.

{
    PATAPORT_COMMON_EXTENSION FdoExt = CommonExt->FdoExt;
    PDEVICE_OBJECT TopDeviceObject;
    PIO_STACK_LOCATION IoStack, SubStack;
    PIRP SubIrp;
    KEVENT Event;
    NTSTATUS Status;
 
    PAGED_CODE();
    ASSERT(!IS_FDO(CommonExt));
 
    TopDeviceObject = IoGetAttachedDeviceReference(FdoExt->Self);
 
    SubIrp = IoAllocateIrp(TopDeviceObject->StackSize, FALSE);
    if (!SubIrp)
    {
        ObDereferenceObject(TopDeviceObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    SubStack = IoGetNextIrpStackLocation(SubIrp);
    RtlCopyMemory(SubStack, IoStack, sizeof(*SubStack));
 
    if (DeviceCapabilities)
        SubStack->Parameters.DeviceCapabilities.Capabilities = DeviceCapabilities;
 
    IoSetCompletionRoutine(SubIrp,
                           AtaPdoCompletionRoutine,
                           &Event,
                           TRUE,
                           TRUE,
                           TRUE);
 
    SubIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 
    Status = IoCallDriver(TopDeviceObject, SubIrp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
    }
 
    ObDereferenceObject(TopDeviceObject);
 
    Status = SubIrp->IoStatus.Status;
    IoFreeIrp(SubIrp);
 
    return Status;
}

Referenced by AtaPdoQueryCapabilities(), and AtaPnpQueryDeviceUsageNotification().

AtaPortCheckDevicePowerState()

NTSTATUS AtaPortCheckDevicePowerState	(	_In_ PATAPORT_PORT_DATA	PortData,
		_In_ PATAPORT_DEVICE_EXTENSION	DevExt
	)

Definition at line 218 of file dev_power.c.

{
    NTSTATUS Status;
 
    if (DevExt->Common.DevicePowerState == PowerDeviceD0)
        return STATUS_SUCCESS;
 
    INFO("CH %lu: Powering up idle device '%s'\n", PortData->PortNumber, DevExt->FriendlyName);
 
    Status = AtaDeviceSetIdleMode(PortData, DevExt);
    if (!NT_SUCCESS(Status))
    {
        /*
         * If the power on device has failed, the next command can still work.
         * The media access will result in a transition from the PM1:Idle/PM2:Standby state
         * to the PM0:Active state by the ATA spec.
         */
        ERR("CH %lu: Failed to power up device '%s' %lx\n",
            PortData->PortNumber, DevExt->FriendlyName, Status);
    }
    else
    {
        DevExt->Common.DevicePowerState = PowerDeviceD0;
    }
 
    return Status;
}

Referenced by AtaPortIdentifyDevice().

AtaPortDeviceProcessConfig()

NTSTATUS AtaPortDeviceProcessConfig	(	_In_ PATAPORT_PORT_DATA	PortData,
		_In_ PATAPORT_DEVICE_EXTENSION	DevExt
	)

Definition at line 341 of file dev_config.c.

{
    NTSTATUS Status;
 
    DevExt->Device.DeviceFlags |= DEVICE_PIO_ONLY;
    DevExt->Device.DeviceFlags &= ~(DEVICE_HAS_MEDIA_STATUS | DEVICE_SENSE_DATA_REPORTING);
    DevExt->Device.MultiSectorCount = 0;
 
    Status = AtaDeviceSetGeometry(PortData, DevExt);
    if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
        return Status;
 
    Status = AtaDeviceSetPioTransferMode(PortData, DevExt);
    if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
        return Status;
 
    Status = AtaDeviceSetDmaTransferMode(PortData, DevExt);
    if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
        return Status;
 
    Status = AtaDeviceSetMultipleMode(PortData, DevExt);
    if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
        return Status;
 
    Status = AtaDeviceExecuteAcpiTaskFile(PortData, DevExt);
    if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
        return Status;
 
    Status = AtaDeviceLockSecurityModeFeatureCommands(PortData, DevExt);
    if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
        return Status;
 
    Status = AtaDeviceLockDeviceParameters(PortData, DevExt);
    if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
        return Status;
 
    Status = AtaDeviceEnableMsnFeature(PortData, DevExt);
    if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
        return Status;
 
    /* Identify data might have changed during the configuration, so update it here */
    Status = AtaDeviceSendIdentify(PortData,
                                   DevExt,
                                   IS_ATAPI(&DevExt->Device) ?
                                   IDE_COMMAND_ATAPI_IDENTIFY : IDE_COMMAND_IDENTIFY);
    if (NT_SUCCESS(Status))
    {
        RtlCopyMemory(&DevExt->IdentifyDeviceData,
                      DevExt->Device.LocalBuffer,
                      sizeof(DevExt->IdentifyDeviceData));
    }
 
    return Status;
}

Referenced by AtaPortConfigureDevice().

AtaPortDeviceProcessError()

NTSTATUS AtaPortDeviceProcessError	(	_In_ PATAPORT_PORT_DATA	PortData,
		_In_ PATAPORT_DEVICE_EXTENSION	DevExt
	)

Definition at line 642 of file dev_error.c.

{
    PATA_DEVICE_REQUEST FailedRequest = PortData->Worker.FailedRequest;
    NTSTATUS Status;
 
    ASSERT_REQUEST(FailedRequest);
 
    if (FailedRequest->Flags & REQUEST_FLAG_NCQ)
        Status = AtaDeviceNcqRecovery(PortData, DevExt);
    else
        Status = AtaDeviceGenericRecovery(PortData, DevExt);
 
    return Status;
}

Referenced by AtaPortRecoveryFromError().

AtaPortDeviceProcessPowerChange()

NTSTATUS AtaPortDeviceProcessPowerChange	(	_In_ PATAPORT_PORT_DATA	PortData,
		_In_ PATAPORT_DEVICE_EXTENSION	DevExt
	)

Definition at line 151 of file dev_power.c.

{
    PLIST_ENTRY Entry;
    PIRP PowerIrp;
    PIO_STACK_LOCATION IoStack;
    DEVICE_POWER_STATE NewState;
    KIRQL OldLevel;
    NTSTATUS Status;
 
    KeAcquireSpinLock(&DevExt->Device.QueueLock, &OldLevel);
    if (IsListEmpty(&DevExt->PowerIrpQueueList))
        Entry = NULL;
    else
        Entry = RemoveHeadList(&DevExt->PowerIrpQueueList);
    KeReleaseSpinLock(&DevExt->Device.QueueLock, OldLevel);
    if (!Entry)
        return STATUS_SUCCESS;
 
    PowerIrp = CONTAINING_RECORD(Entry, IRP, Tail.Overlay.ListEntry);
 
    IoStack = IoGetCurrentIrpStackLocation(PowerIrp);
    ASSERT(IoStack->MinorFunction == IRP_MN_SET_POWER);
 
    NewState = IoStack->Parameters.Power.State.DeviceState;
    if (NewState == DevExt->Common.DevicePowerState)
    {
        AtaDeviceCompletePowerIrp(DevExt, PowerIrp);
        return STATUS_SUCCESS;
    }
 
    if (NewState != PowerDeviceD3)
    {
        AtaReqThawQueue(DevExt, QUEUE_FLAG_FROZEN_POWER);
 
        /* Power up the device */
        Status = AtaDeviceSetIdleMode(PortData, DevExt);
        if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
            return Status;
 
        /* Restore the software settings after power up */
        _InterlockedOr(&DevExt->Worker.EventsPending, ACTION_DEVICE_CONFIG);
        _InterlockedOr(&PortData->Worker.EventsPending, ACTION_DEVICE_CONFIG);
    }
    else
    {
        AtaReqFreezeQueue(DevExt, QUEUE_FLAG_FROZEN_POWER);
 
        /* Flush device caches */
        Status = AtaDeviceFlushCache(PortData, DevExt);
        if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
            return Status;
 
        /* Power down the device */
        Status = AtaDeviceSetStandbyMode(PortData, DevExt);
        if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
            return Status;
    }
 
    AtaDeviceCompletePowerIrp(DevExt, PowerIrp);
 
    DevExt->Common.DevicePowerState = NewState;
    return Status;
}

Referenced by AtaPortDeviceChangePower().

AtaPortIdentifyDevice()

ATA_DEVICE_STATUS AtaPortIdentifyDevice	(	_In_ PATAPORT_PORT_DATA	PortData,
		_In_ PATAPORT_DEVICE_EXTENSION	DevExt
	)

Definition at line 213 of file dev_identify.c.

{
    PIDENTIFY_DEVICE_DATA IdentifyData = DevExt->Device.LocalBuffer;
    ATA_CONNECTION_STATUS ConnectionStatus;
    NTSTATUS Status;
    BOOLEAN StartFromAtapi, IsSameDevice;
    ULONG Attempt, RetryCount;
    ATA_DEVICE_TYPE DeviceType;
 
    _InterlockedOr(&PortData->InterruptFlags, PORT_INT_FLAG_IGNORE_LINK_IRQ);
 
    ConnectionStatus = PortData->IdentifyDevice(PortData->ChannelContext,
                                                DevExt->Device.AtaScsiAddress.TargetId);
 
    _InterlockedAnd(&PortData->InterruptFlags, ~PORT_INT_FLAG_IGNORE_LINK_IRQ);
 
    if (ConnectionStatus == CONN_STATUS_FAILURE)
        return DEV_STATUS_FAILED;
 
    if (ConnectionStatus == CONN_STATUS_NO_DEVICE)
        return DEV_STATUS_NO_DEVICE;
 
    /* Power up the device if needed */
    Status = AtaPortCheckDevicePowerState(PortData, DevExt);
    if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
        return DEV_STATUS_FAILED;
 
    /*
     * Try the known device type first.
     * This may speed up device detection by eliminating I/O errors.
     */
    if (DevExt->Device.DeviceFlags & DEVICE_UNINITIALIZED)
        StartFromAtapi = (ConnectionStatus == CONN_STATUS_DEV_ATAPI);
    else
        StartFromAtapi = IS_ATAPI(&DevExt->Device);
 
    /* Look for ATA/ATAPI devices */
    for (RetryCount = 0; RetryCount < 2; ++RetryCount)
    {
        /* Send the identify command */
        for (Attempt = 0; Attempt < 2; ++Attempt)
        {
            if (StartFromAtapi)
                DeviceType = DEV_ATAPI;
            else
                DeviceType = DEV_ATA;
 
            /* Swap device types */
            if (Attempt != 0)
                DeviceType ^= (DEV_ATAPI ^ DEV_ATA);
 
            Status = AtaDeviceSendIdentify(PortData,
                                           DevExt,
                                           DeviceType == DEV_ATAPI ?
                                           IDE_COMMAND_ATAPI_IDENTIFY : IDE_COMMAND_IDENTIFY);
            if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
                return DEV_STATUS_FAILED;
 
            if (NT_SUCCESS(Status))
                break;
        }
        if (!NT_SUCCESS(Status))
            return DEV_STATUS_NO_DEVICE;
 
        /*
         * The drive needs to be spun up
         * or the device was unable to return complete identity data.
         */
        if (AtaDevInPuisState(IdentifyData) || AtaDevIsIdentifyDataIncomplete(IdentifyData))
        {
 
            Status = AtaDeviceSpinUp(PortData, DevExt);
            if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
                return DEV_STATUS_FAILED;
 
            if (!NT_SUCCESS(Status))
                ERR("Failed to spin-up device\n");
            continue;
        }
    }
 
    /* Verify the checksum */
    if (!AtaDevIsIdentifyDataValid(IdentifyData))
    {
        ERR("Identify data CRC error\n");
        return DEV_STATUS_FAILED;
    }
 
    if (DevExt->Device.DeviceFlags & DEVICE_UNINITIALIZED)
    {
        IsSameDevice = FALSE;
    }
    else
    {
        IsSameDevice = (DeviceType == DevExt->DeviceType) &&
                       (AtaDeviceIdentifyDataEqual(&DevExt->IdentifyDeviceData,
                                                   DevExt->Device.LocalBuffer));
    }
 
    /* Update identify data */
    RtlCopyMemory(&DevExt->IdentifyDeviceData,
                  DevExt->Device.LocalBuffer,
                  sizeof(DevExt->IdentifyDeviceData));
    DevExt->DeviceType = DeviceType;
 
    if (IsSameDevice)
        return DEV_STATUS_SAME_DEVICE;
 
    DevExt->Device.TransportFlags &= ~(DEVICE_IS_ATAPI |
                                       DEVICE_HAS_CDB_INTERRUPT |
                                       DEVICE_NEED_DMA_DIRECTION |
                                       DEVICE_IS_NEC_CDR260);
 
    if (DeviceType == DEV_ATAPI)
    {
        DevExt->Device.TransportFlags |= DEVICE_IS_ATAPI;
 
        DevExt->Device.CdbSize = AtaDevCdbSizeInWords(&DevExt->IdentifyPacketData);
        TRACE("Device has CDB size of %u bytes\n", DevExt->Device.CdbSize * 2);
 
        if (AtaDevHasCdbInterrupt(&DevExt->IdentifyPacketData))
        {
            TRACE("Device has CDB interrupt\n");
            DevExt->Device.TransportFlags |= DEVICE_HAS_CDB_INTERRUPT;
        }
 
        if (AtaDevIsDmaDirectionRequired(&DevExt->IdentifyPacketData))
        {
            TRACE("Device needs DMA DIR\n");
            DevExt->Device.TransportFlags |= DEVICE_NEED_DMA_DIRECTION;
        }
 
        /* The NEC CDR-260 string is not byteswapped */
        if (DevExt->IdentifyPacketData.ModelNumber[0] == 'N' &&
            DevExt->IdentifyPacketData.ModelNumber[1] == 'E' &&
            DevExt->IdentifyPacketData.ModelNumber[2] == 'C')
        {
            TRACE("Device is a NEC CDR-260 drive\n");
            DevExt->Device.TransportFlags |= DEVICE_IS_NEC_CDR260;
        }
 
        Status = AtaDeviceSendInquiry(PortData, DevExt);
        if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
            return DEV_STATUS_FAILED;
 
        /* Update the inquiry data */
        RtlCopyMemory(&DevExt->InquiryData,
                      DevExt->Device.LocalBuffer,
                      sizeof(DevExt->InquiryData));
    }
 
    return DEV_STATUS_NEW_DEVICE;
}

Referenced by AtaPortEnumerateDevice().

AtaPortQueueEmpty()

FORCEINLINE BOOLEAN AtaPortQueueEmpty

(

_In_ PATAPORT_PORT_DATA

PortData

)

Definition at line 573 of file atapi.h.

{
    ULONG SlotsBitmap;
 
    SlotsBitmap = PortData->Worker.PausedSlotsBitmap | PortData->FreeSlotsBitmap;
 
    return (SlotsBitmap == PortData->MaxSlotsBitmap);
}

Referenced by AtaPortWaitForIdle(), and AtaReqCompleteRequest().

AtaPortSelectTimings()

VOID AtaPortSelectTimings	(	_In_ PATAPORT_PORT_DATA	PortData,
		_In_ BOOLEAN	ForceCompatibleTimings
	)

Definition at line 258 of file dev_timings.c.

{
    PATAPORT_CHANNEL_EXTENSION ChanExt;
    ULONG i;
    CHANNEL_DEVICE_CONFIG Config[ATA_MAX_DEVICE] = { 0 };
    PCHANNEL_DEVICE_CONFIG DeviceList[ATA_MAX_DEVICE] = { 0 };
 
    if (ForceCompatibleTimings)
    {
        for (i = 0; i < ATA_MAX_DEVICE; ++i)
        {
            /* Fake device presence */
            DeviceList[i] = &Config[i];
 
            /* Disable DMA and select compatible timings */
            Config[i].SupportedModes = PIO_MODE0;
            Config[i].CurrentModes = PIO_MODE0;
            Config[i].MinPioCycleTime = AtapModeToCycleTime[PIO_MODE(0)];
            Config[i].MinSwDmaCycleTime = AtapModeToCycleTime[SWDMA_MODE(0)];
            Config[i].MinMwDmaCycleTime = AtapModeToCycleTime[MWDMA_MODE(0)];
            Config[i].IsFixedDisk = TRUE;
            Config[i].IoReadySupported = FALSE;
            Config[i].IsNewDevice = FALSE;
            Config[i].FriendlyName = "";
        }
 
        /* Call the chipset driver */
        PortData->SetTransferMode(PortData->ChannelContext, DeviceList);
        return;
    }
 
    ChanExt = CONTAINING_RECORD(PortData, ATAPORT_CHANNEL_EXTENSION, PortData);
 
    for (i = 0; i < ATA_MAX_DEVICE; ++i)
    {
        PATAPORT_DEVICE_EXTENSION DevExt;
        ULONG AllowedModesMask;
 
        DevExt = AtaFdoFindDeviceByPath(ChanExt,
                                        AtaMarshallScsiAddress(PortData->PortNumber, i, 0),
                                        NULL);
        if (!DevExt)
            continue;
 
        DevExt->TransferModeCurrentBitmap = 0;
        DevExt->TransferModeSupportedBitmap = 0;
 
        AllowedModesMask = DevExt->TransferModeUserAllowedMask;
        AllowedModesMask &= DevExt->TransferModeAllowedMask;
        /* Mode cannot be slower than PIO0 */
        AllowedModesMask |= PIO_MODE0;
 
        AtaTimQueryPioModeSupport(DevExt, AllowedModesMask);
        AtaTimQuerySwDmaModeSupport(DevExt, AllowedModesMask);
        AtaTimQueryMwDmaModeSupport(DevExt, AllowedModesMask);
        AtaTimQueryUDmaModeSupport(DevExt, AllowedModesMask);
 
        DeviceList[i] = &Config[i];
        Config[i].CurrentModes = DevExt->TransferModeCurrentBitmap;
        Config[i].SupportedModes = DevExt->TransferModeSupportedBitmap;
        Config[i].MinPioCycleTime = DevExt->MinimumPioCycleTime;
        Config[i].MinSwDmaCycleTime = DevExt->MinimumSingleWordDmaCycleTime;
        Config[i].MinMwDmaCycleTime = DevExt->MinimumMultiWordDmaCycleTime;
        Config[i].IsFixedDisk = !IS_ATAPI(&DevExt->Device);
        Config[i].IoReadySupported = !!DevExt->IdentifyDeviceData.Capabilities.IordySupported;
        Config[i].IsNewDevice = !(DevExt->Device.DeviceFlags & DEVICE_PNP_STARTED);
        Config[i].FriendlyName = DevExt->FriendlyName;
    }
 
    /* Call the chipset driver */
    PortData->SetTransferMode(PortData->ChannelContext, DeviceList);
 
    /* Save the result */
    for (i = 0; i < ATA_MAX_DEVICE; ++i)
    {
        PCHANNEL_DEVICE_CONFIG DeviceConfig = DeviceList[i];
        PATAPORT_DEVICE_EXTENSION DevExt;
 
        if (!DeviceConfig)
            continue;
 
        DevExt = AtaFdoFindDeviceByPath(ChanExt,
                                        AtaMarshallScsiAddress(PortData->PortNumber, i, 0),
                                        NULL);
        ASSERT(DevExt);
 
        DevExt->TransferModeSelectedBitmap = 1 << DeviceConfig->PioMode;
        if (DeviceConfig->DmaMode != PIO_MODE(0))
        {
            DevExt->TransferModeSelectedBitmap |= 1 << DeviceConfig->DmaMode;
        }
 
        AtaTimDumpTimingInfo(PortData, DevExt);
    }
}

Referenced by AtaPortResetPort(), and AtaPortSetTransferMode().

AtaPortSendRequest()

NTSTATUS AtaPortSendRequest	(	_In_ PATAPORT_PORT_DATA	PortData,
		_In_ PATAPORT_DEVICE_EXTENSION	DevExt
	)

Definition at line 831 of file portstate.c.

{
    PATA_DEVICE_REQUEST Request = &PortData->Worker.InternalRequest;
    KIRQL OldIrql;
 
    if (Request->Flags & REQUEST_FLAG_PACKET_COMMAND)
    {
        INFO("CH %lu: Send CDB %u %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
             PortData->PortNumber,
             DevExt->Device.AtaScsiAddress.TargetId,
             Request->Cdb[0],
             Request->Cdb[1],
             Request->Cdb[2],
             Request->Cdb[3],
             Request->Cdb[4],
             Request->Cdb[5],
             Request->Cdb[6]);
    }
    else
    {
        INFO("CH %lu: Send TF %u %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
             PortData->PortNumber,
             DevExt->Device.AtaScsiAddress.TargetId,
             Request->TaskFile.Command,
             Request->TaskFile.Feature,
             Request->TaskFile.SectorCount,
             Request->TaskFile.LowLba,
             Request->TaskFile.MidLba,
             Request->TaskFile.HighLba,
             Request->TaskFile.DriveSelect);
    }
 
    KeClearEvent(&PortData->Worker.CompletionEvent);
 
    Request->Flags |= REQUEST_FLAG_INTERNAL;
    Request->Device = (PATA_IO_CONTEXT_COMMON)&DevExt->Device;
 
    PortData->Worker.OldRequest = PortData->Slots[0];
    PortData->Slots[0] = Request;
 
    KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
 
    KeAcquireSpinLockAtDpcLevel(&PortData->QueueLock);
    PortData->ActiveTimersBitmap |= 1 << 0;
    KeReleaseSpinLockFromDpcLevel(&PortData->QueueLock);
 
    AtaReqSendRequest(Request);
 
    KeLowerIrql(OldIrql);
 
    KeWaitForSingleObject(&PortData->Worker.CompletionEvent, Executive, KernelMode, FALSE, NULL);
 
    /* Stop the timer */
    KeAcquireSpinLock(&PortData->QueueLock, &OldIrql);
    PortData->ActiveTimersBitmap = 0;
    KeReleaseSpinLock(&PortData->QueueLock, OldIrql);
 
    PortData->Slots[0] = PortData->Worker.OldRequest;
 
    if ((Request->SrbStatus == SRB_STATUS_TIMEOUT) ||
        (Request->SrbStatus == SRB_STATUS_BUS_RESET))
    {
        return STATUS_ADAPTER_HARDWARE_ERROR;
    }
 
    if (Request->SrbStatus == SRB_STATUS_SUCCESS)
        return STATUS_SUCCESS;
 
    return STATUS_IO_DEVICE_ERROR;
}

Referenced by AtaDeviceEnableMsnFeature(), AtaDeviceExecuteAcpiTaskFile(), AtaDeviceFlushCache(), AtaDeviceLockDeviceParameters(), AtaDeviceLockSecurityModeFeatureCommands(), AtaDeviceSendIdentify(), AtaDeviceSendInquiry(), AtaDeviceSendReadNcqCommandErrorLog(), AtaDeviceSendRequestSense(), AtaDeviceSendRequestSenseExt(), AtaDeviceSetDmaTransferMode(), AtaDeviceSetGeometry(), AtaDeviceSetIdleMode(), AtaDeviceSetMultipleMode(), AtaDeviceSetPioTransferMode(), AtaDeviceSetStandbyMode(), and AtaDeviceSpinUp().

AtaPortSignalWorkerThread()

DECLSPEC_NOINLINE_FROM_PAGED VOID AtaPortSignalWorkerThread

(

_In_ PATAPORT_PORT_DATA

PortData

)

Definition at line 963 of file portstate.c.

{
    KIRQL OldIrql;
 
    KeAcquireSpinLock(&PortData->Worker.Lock, &OldIrql);
    KeSetEvent(&PortData->Worker.ThreadEvent, IO_NO_INCREMENT, FALSE);
    KeReleaseSpinLock(&PortData->Worker.Lock, OldIrql);
}

Referenced by AtaFdoDestroyPortThread(), and AtaPortWorkerSignalDpc().

AtaPortTimeout()

VOID AtaPortTimeout	(	_In_ PATAPORT_PORT_DATA	PortData,
		_In_ ULONG	Slot
	)

Definition at line 905 of file portstate.c.

{
    PATA_DEVICE_REQUEST Request;
    PATAPORT_DEVICE_EXTENSION DevExt;
 
    ASSERT(KeGetCurrentIrql() > DISPATCH_LEVEL);
 
    Request = PortData->Slots[Slot];
    ASSERT_REQUEST(Request);
 
    DevExt = CONTAINING_RECORD(Request->Device, ATAPORT_DEVICE_EXTENSION, Device);
 
    ERR("CH %lu: Slot %lu (%08lx) timed out %lx (%lus) %u '%s'\n",
        PortData->PortNumber,
        Slot,
        1 << Slot,
        Request->Flags,
        Request->TimeOut,
        DevExt->Device.AtaScsiAddress.TargetId,
        DevExt->FriendlyName);
    if (Request->Flags & REQUEST_FLAG_PACKET_COMMAND)
    {
        ERR("CH %lu: CDB %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
            PortData->PortNumber,
            Request->Cdb[0],
            Request->Cdb[1],
            Request->Cdb[2],
            Request->Cdb[3],
            Request->Cdb[4],
            Request->Cdb[5],
            Request->Cdb[6]);
    }
    else
    {
        ERR("CH %lu: TF %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
            PortData->PortNumber,
            Request->TaskFile.Command,
            Request->TaskFile.Feature,
            Request->TaskFile.SectorCount,
            Request->TaskFile.LowLba,
            Request->TaskFile.MidLba,
            Request->TaskFile.HighLba,
            Request->TaskFile.DriveSelect);
    }
 
    Request->SrbStatus = SRB_STATUS_TIMEOUT;
 
    /* The active command has timed out, set the ATA outputs to something meaningful */
    Request->Output.Status = IDE_STATUS_ERROR;
    Request->Output.Error = IDE_ERROR_COMMAND_ABORTED;
 
    AtaPortQueueEvent(PortData, NULL, Request, ACTION_PORT_RESET | ACTION_DEVICE_ERROR);
}

Referenced by AtaPortIoTimer().

AtaReqAllocateMdl()

BOOLEAN AtaReqAllocateMdl

(

_In_ PATA_DEVICE_REQUEST

Request

)

Definition at line 467 of file scsi.c.

{
    PMDL Mdl;
 
    Mdl = IoAllocateMdl(Request->DataBuffer,
                        Request->DataTransferLength,
                        FALSE,
                        FALSE,
                        NULL);
    if (!Mdl)
        return FALSE;
 
    MmBuildMdlForNonPagedPool(Mdl);
 
    Request->Mdl = Mdl;
    Request->Flags |= REQUEST_FLAG_HAS_MDL;
 
    return TRUE;
}

Referenced by AtaReqBuildIdentifyCommand().

AtaReqBuildReadLogTaskFile()

VOID AtaReqBuildReadLogTaskFile	(	_In_ PATA_DEVICE_REQUEST	Request,
		_In_ UCHAR	LogAddress,
		_In_ UCHAR	PageNumber,
		_In_ USHORT	LogPageCount
	)

Definition at line 399 of file satl.c.

{
    PATA_TASKFILE TaskFile = &Request->TaskFile;
 
    /* PIO Data-In command */
    Request->Flags = REQUEST_FLAG_DATA_IN | REQUEST_FLAG_LBA48;
    Request->DataTransferLength = LogPageCount * IDE_GP_LOG_SECTOR_SIZE;
 
    TaskFile->Feature = 0;
    TaskFile->FeatureEx = 0;
 
    /* LOG PAGE COUNT */
    TaskFile->SectorCount = (UCHAR)LogPageCount;
    TaskFile->SectorCountEx = (UCHAR)(LogPageCount >> 8);
 
    TaskFile->LowLba = LogAddress; // LOG ADDRESS
    TaskFile->MidLba = PageNumber; // PAGE NUMBER
    TaskFile->HighLba = 0;         // Reserved
    TaskFile->LowLbaEx = 0;        // Reserved
    TaskFile->MidLbaEx = 0;        // PAGE NUMBER EX
    TaskFile->HighLbaEx = 0;       // Reserved
    TaskFile->Command = IDE_COMMAND_READ_LOG_EXT;
}

Referenced by AtaDeviceSendReadNcqCommandErrorLog().

AtaReqCompleteFailedRequest()

VOID AtaReqCompleteFailedRequest

(

_In_ PATA_DEVICE_REQUEST

Request

)

AtaReqDmaTransferToPioTransfer()

BOOLEAN AtaReqDmaTransferToPioTransfer

(

_In_ PATA_DEVICE_REQUEST

Request

)

Definition at line 78 of file satl.c.

{
    PATAPORT_IO_CONTEXT Device = (PATAPORT_IO_CONTEXT)Request->Device;
 
    ASSERT(!(Device->DeviceFlags & DEVICE_PIO_VIA_DMA));
    ASSERT(Request->Flags & REQUEST_DMA_FLAGS);
 
    /* ATAPI commands */
    if (Request->Flags & REQUEST_FLAG_PACKET_COMMAND)
    {
        Request->Flags &= ~REQUEST_DMA_FLAGS;
        return TRUE;
    }
 
    /*
     * For ATA commands there is no simple way to achieve this,
     * we have to fix the command opcode.
     * Determine if it is safe or allowed to change the command.
     */
    if (Request->Flags & REQUEST_FLAG_READ_WRITE)
    {
        Request->Flags &= ~REQUEST_DMA_FLAGS;
 
        Request->TaskFile.Command = AtaReadWriteCommand(Request, Device);
        if (Request->TaskFile.Command == 0)
        {
            /* PIO is not available */
            Request->Flags |= REQUEST_DMA_FLAGS;
            return FALSE;
        }
 
        return TRUE;
    }
 
    /* PIO is not available */
    return FALSE;
}

Referenced by AtaReqSendRequest().

AtaReqExecuteScsi()

UCHAR AtaReqExecuteScsi	(	_In_ PATAPORT_DEVICE_EXTENSION	DevExt,
		_In_ PATA_DEVICE_REQUEST	Request,
		_In_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 2054 of file satl.c.

{
    if (IS_ATAPI(&DevExt->Device))
        return AtaReqExecuteScsiAtapi(DevExt, Request, Srb);
    else
        return AtaReqExecuteScsiAta(DevExt, Request, Srb);
}

Referenced by AtaReqTranslateRequest().

AtaReqFlushDeviceQueue()

DECLSPEC_NOINLINE_FROM_PAGED VOID AtaReqFlushDeviceQueue

(

_In_ PATAPORT_IO_CONTEXT

Device

)

Definition at line 1451 of file scsi.c.

{
    PATA_DEVICE_REQUEST Request;
    KIRQL OldLevel;
    PLIST_ENTRY Entry;
 
    KeAcquireSpinLock(&Device->QueueLock, &OldLevel);
 
    for (Entry = Device->DeviceQueueList.Flink;
         Entry != &Device->DeviceQueueList;
         Entry = Entry->Flink)
    {
        PREQUEST_QUEUE_ENTRY QueueEntry;
        PIRP Irp;
        PSCSI_REQUEST_BLOCK Srb;
 
        QueueEntry = CONTAINING_RECORD(Entry, REQUEST_QUEUE_ENTRY, ListEntry);
        ASSERT(QueueEntry->Context == Device);
 
        AtaReqDeviceQueueRemoveEntry(Device, QueueEntry);
 
        /* Clear our cancel routine */
        Irp = IRP_FROM_QUEUE_ENTRY(QueueEntry);
        if (!IoSetCancelRoutine(Irp, NULL))
        {
            /* We're already canceled, reset the list entry to point to itself */
            InitializeListHead(&QueueEntry->ListEntry);
            continue;
        }
 
        KeReleaseSpinLock(&Device->QueueLock, OldLevel);
 
        Srb = IoGetCurrentIrpStackLocation(Irp)->Parameters.Scsi.Srb;
        ASSERT(Srb);
        ASSERT(Srb->OriginalRequest == Irp);
 
        Srb->SrbStatus = SRB_STATUS_ABORTED;
        Irp->IoStatus.Status = STATUS_CANCELLED;
        Irp->IoStatus.Information = Srb->DataTransferLength;
        IoCompleteRequest(Irp, IO_DISK_INCREMENT);
 
        KeAcquireSpinLock(&Device->QueueLock, &OldLevel);
    }
 
    Request = AtaReqRemovePortRequest(Device);
 
    KeReleaseSpinLock(&Device->QueueLock, OldLevel);
 
    if (Request)
    {
        KIRQL OldIrql;
 
        Request->SrbStatus = SRB_STATUS_ABORTED;
        Request->InternalState = REQUEST_STATE_NOT_STARTED;
 
        KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
        AtaReqCompleteRequest(Request);
        KeLowerIrql(OldIrql);
    }
}

Referenced by AtaFdoRemoveDevice(), AtaPdoDispatchScsi(), AtaPdoRemoveDevice(), and AtaPortExitStateMachine().

AtaReqFreezeQueue()

DECLSPEC_NOINLINE_FROM_PAGED VOID AtaReqFreezeQueue	(	_In_ PATAPORT_DEVICE_EXTENSION	DevExt,
		_In_ ULONG	ReasonFlags
	)

Definition at line 1351 of file scsi.c.

{
    PATAPORT_IO_CONTEXT Device = &DevExt->Device;
    KIRQL OldLevel;
 
    KeAcquireSpinLock(&Device->QueueLock, &OldLevel);
    _InterlockedOr(&Device->QueueFlags, ReasonFlags);
    KeReleaseSpinLock(&Device->QueueLock, OldLevel);
}

Referenced by AtaPdoDispatchScsi(), AtaPdoInit(), AtaPdoRemoveDevice(), AtaPdoStopDevice(), AtaPortDeviceProcessPowerChange(), AtaPortEnterStateMachine(), AtaPortEnumerateDevice(), and AtaPortExitStateMachine().

AtaReqSendRequest()

VOID AtaReqSendRequest

(

_In_ PATA_DEVICE_REQUEST

Request

)

Definition at line 632 of file scsi.c.

{
    PATAPORT_IO_CONTEXT Device = (PATAPORT_IO_CONTEXT)Request->Device;
 
    PVOID BaseAddress;
    ULONG_PTR Offset;
 
    ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
 
    /* The channel can only perform DMA I/O and PIO is not supported */
    if (Device->DeviceFlags & DEVICE_PIO_VIA_DMA)
        Request->Flags |= REQUEST_FLAG_PROGRAM_DMA;
 
    if (Request->Flags & REQUEST_FLAG_DMA)
        ASSERT(Request->Flags & REQUEST_FLAG_PROGRAM_DMA);
 
    if (!(Request->Flags & REQUEST_FLAG_NO_KEEP_AWAKE))
    {
        PULONG PowerIdleCounter = Device->PowerIdleCounter;
 
        if (PowerIdleCounter)
            PoSetDeviceBusy(PowerIdleCounter);
    }
 
    /* Local buffer transfer */
    if (Request->Flags & REQUEST_FLAG_HAS_LOCAL_BUFFER)
    {
        ASSERT(Request->Flags & REQUEST_FLAG_INTERNAL);
 
        if (Request->Flags & REQUEST_FLAG_PROGRAM_DMA)
        {
            /* DMA transfer */
            Device->PortData->LocalSgList.Elements[0].Length = Request->DataTransferLength;
            AtaReqPreparePrdTable(NULL, NULL, &Device->PortData->LocalSgList, Request);
        }
        else
        {
            /* PIO data transfer */
            Request->DataBuffer = Device->LocalBuffer;
            AtaReqStartIo(Request);
        }
        return;
    }
 
    /* No data transfer */
    if (!(Request->Flags & (REQUEST_FLAG_DATA_IN | REQUEST_FLAG_DATA_OUT)))
    {
        AtaReqStartIo(Request);
        return;
    }
 
    /* DMA transfer, get the S/G list for the MDL */
    if (Request->Flags & REQUEST_FLAG_PROGRAM_DMA)
    {
        if (AtaReqGetScatterGatherList(Device->PortData, Request))
            return;
 
        /* This channel can only perform DMA I/O and PIO is not supported */
        if (Device->DeviceFlags & DEVICE_PIO_VIA_DMA)
            goto CompleteNoMemory;
 
        /* S/G list construction failed, attempt to fall back to PIO mode */
        if (!AtaReqDmaTransferToPioTransfer(Request))
            goto CompleteNoMemory;
    }
 
    /* PIO data transfer path */
    ASSERT(!(Device->DeviceFlags & DEVICE_PIO_VIA_DMA));
 
    BaseAddress = AtaReqMapBuffer(Device, Request);
    if (!BaseAddress)
        goto CompleteNoMemory;
 
    /* Calculate the offset within DataBuffer */
    Offset = (ULONG_PTR)BaseAddress +
             (ULONG_PTR)Request->DataBuffer -
             (ULONG_PTR)MmGetMdlVirtualAddress(Request->Mdl);
    Request->DataBuffer = (PVOID)Offset;
 
    AtaReqStartIo(Request);
    return;
 
CompleteNoMemory:
    Request->SrbStatus = SRB_STATUS_INSUFFICIENT_RESOURCES;
    Request->InternalState = REQUEST_STATE_REQUEUE;
 
    /*
     * Defer the completion to a DPC.
     * We cannot complete request with the queue spinlock held.
     */
    AtaReqStartCompletionDpc(Request);
}

Referenced by AtaPortSendRequest(), AtaReqCallSendRequestSerialized(), and AtaReqDispatchRequest().

AtaReqSetFixedAtaSenseData()

UCHAR AtaReqSetFixedAtaSenseData

(

_In_ PATA_DEVICE_REQUEST

Request

)

Definition at line 248 of file satl.c.

{
    SCSI_SENSE_CODE SenseCode;
    UCHAR SrbStatus, SK, ASK, ASCQ;
 
    ASSERT(!(Request->SrbStatus & SRB_STATUS_AUTOSENSE_VALID));
 
    if (!AtaReqTranslateFixedError(Request, &SK, &ASK, &ASCQ))
        return Request->SrbStatus;
 
    SenseCode.SrbStatus = Request->SrbStatus;
    SenseCode.SenseKey = SK;
    SenseCode.AdditionalSenseCode = ASK;
    SenseCode.AdditionalSenseCodeQualifier = ASCQ;
 
    SrbStatus = AtaReqSetFixedSenseData(Request->Srb, SenseCode);
    AtaReqSetLbaInformation(Request->Srb, AtaReqLbaFromTaskFile(Request));
 
    return SrbStatus;
}

Referenced by AtaDeviceGenericRecovery(), AtaDeviceHandleRequestSense(), and AtaDeviceNcqRecovery().

AtaReqSetFixedSenseData()

UCHAR AtaReqSetFixedSenseData	(	_In_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ SCSI_SENSE_CODE	SenseCode
	)

Definition at line 411 of file scsi.c.

{
    SENSE_DATA SenseData;
 
    if ((Srb->SenseInfoBuffer == NULL) || (Srb->SenseInfoBufferLength == 0))
        return SenseCode.SrbStatus;
 
    ASSERT(!(SenseCode.SrbStatus & SRB_STATUS_AUTOSENSE_VALID));
 
    Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
 
    // TODO: D_SENSE (fixed or descriptor format) is not supported yet
    RtlZeroMemory(&SenseData, sizeof(SenseData));
    SenseData.Valid = 1;
    SenseData.ErrorCode = SCSI_SENSE_ERRORCODE_FIXED_CURRENT;
    SenseData.SenseKey = SenseCode.SenseKey;
    SenseData.AdditionalSenseCode = SenseCode.AdditionalSenseCode;
    SenseData.AdditionalSenseCodeQualifier = SenseCode.AdditionalSenseCodeQualifier;
    SenseData.AdditionalSenseLength =
        sizeof(SenseData) - RTL_SIZEOF_THROUGH_FIELD(SENSE_DATA, AdditionalSenseLength);
 
    RtlCopyMemory(Srb->SenseInfoBuffer,
                  &SenseData,
                  min(Srb->SenseInfoBufferLength, sizeof(SenseData)));
 
    return SenseCode.SrbStatus | SRB_STATUS_AUTOSENSE_VALID;
}

Referenced by AtaDeviceHandleRequestSense(), AtaDeviceNcqRecovery(), AtaReqCompleteReadCapacity(), AtaReqScsiRequestSense(), AtaReqSetFixedAtaSenseData(), AtaReqTerminateInvalidField(), AtaReqTerminateInvalidFieldParameter(), AtaReqTerminateInvalidOpCode(), and AtaReqTerminateInvalidRange().

AtaReqSetLbaInformation()

VOID AtaReqSetLbaInformation	(	_In_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ ULONG64	Lba
	)

Definition at line 442 of file scsi.c.

{
    PSENSE_DATA SenseData;
 
    if ((Srb->SenseInfoBuffer == NULL) || (Srb->SenseInfoBufferLength == 0))
        return;
 
    SenseData = Srb->SenseInfoBuffer;
 
    if (RTL_CONTAINS_FIELD(SenseData, Srb->SenseInfoBufferLength, Information))
    {
        ASSERT(SenseData->Valid);
 
        SenseData->Information[0] = (UCHAR)(Lba >> 24);
        SenseData->Information[1] = (UCHAR)(Lba >> 16);
        SenseData->Information[2] = (UCHAR)(Lba >> 8);
        SenseData->Information[3] = (UCHAR)(Lba >> 0);
    }
 
    // TODO: D_SENSE (fixed or descriptor format) is not supported yet
}

Referenced by AtaDeviceNcqRecovery(), and AtaReqSetFixedAtaSenseData().

AtaReqSmartIoControl()

UCHAR AtaReqSmartIoControl	(	_In_ PATAPORT_DEVICE_EXTENSION	DevExt,
		_In_ PATA_DEVICE_REQUEST	Request,
		_In_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 92 of file smart.c.

{
    union _PARAMS
    {
        PSENDCMDINPARAMS CmdIn;
        PSENDCMDOUTPARAMS CmdOut;
    } Buffer;
 
    if (Srb->DataTransferLength < (sizeof(SRB_IO_CONTROL) + sizeof(*Buffer.CmdIn) - 1))
        return SRB_STATUS_INVALID_REQUEST;
 
    Buffer.CmdIn = (PSENDCMDINPARAMS)(((PUCHAR)Srb->DataBuffer) + sizeof(SRB_IO_CONTROL));
 
    if (Buffer.CmdIn->irDriveRegs.bCommandReg != SMART_CMD)
        return SRB_STATUS_INVALID_REQUEST;
 
    switch (Buffer.CmdIn->irDriveRegs.bFeaturesReg)
    {
        case READ_ATTRIBUTES:
        {
            Request->DataTransferLength = READ_ATTRIBUTE_BUFFER_SIZE;
            Request->Flags = REQUEST_FLAG_DATA_IN;
            break;
        }
 
        case READ_THRESHOLDS:
        {
            Request->DataTransferLength = READ_THRESHOLD_BUFFER_SIZE;
            Request->Flags = REQUEST_FLAG_DATA_IN;
            break;
        }
 
        case SMART_READ_LOG:
        {
            Request->DataTransferLength =
                Buffer.CmdIn->irDriveRegs.bSectorCountReg * SMART_LOG_SECTOR_SIZE;
            Request->Flags = REQUEST_FLAG_DATA_IN;
            break;
        }
 
        case SMART_WRITE_LOG:
        {
            Request->DataTransferLength =
                Buffer.CmdIn->irDriveRegs.bSectorCountReg * SMART_LOG_SECTOR_SIZE;
            Request->Flags = REQUEST_FLAG_DATA_OUT;
            break;
        }
 
        case RETURN_SMART_STATUS:
        {
            Request->DataTransferLength = sizeof(IDEREGS);
            Request->Flags = REQUEST_FLAG_SAVE_TASK_FILE;
            break;
        }
 
        case EXECUTE_OFFLINE_DIAGS:
        {
            UCHAR Subcommand = Buffer.CmdIn->irDriveRegs.bSectorNumberReg;
 
            if (Subcommand == SMART_SHORT_SELFTEST_CAPTIVE ||
                Subcommand == SMART_EXTENDED_SELFTEST_CAPTIVE)
            {
                return SRB_STATUS_INVALID_REQUEST;
            }
 
            __fallthrough;
        }
        case ENABLE_DISABLE_AUTOSAVE:
        case SAVE_ATTRIBUTE_VALUES:
        case ENABLE_SMART:
        case DISABLE_SMART:
        case ENABLE_DISABLE_AUTO_OFFLINE:
        {
            Request->DataTransferLength = 0;
            Request->Flags = 0;
            break;
        }
 
        default:
            return SRB_STATUS_INVALID_REQUEST;
    }
 
    if (Request->Flags & (REQUEST_FLAG_DATA_IN | REQUEST_FLAG_SAVE_TASK_FILE))
    {
        if (Srb->DataTransferLength <
            (sizeof(SRB_IO_CONTROL) + sizeof(*Buffer.CmdOut) - 1 + Request->DataTransferLength))
        {
            return SRB_STATUS_INVALID_REQUEST;
        }
 
        Request->DataBuffer = Buffer.CmdOut->bBuffer;
    }
    else if (Request->Flags & REQUEST_FLAG_DATA_OUT)
    {
        if (Srb->DataTransferLength <
            (sizeof(SRB_IO_CONTROL) + sizeof(*Buffer.CmdIn) - 1 + Request->DataTransferLength))
        {
            return SRB_STATUS_INVALID_REQUEST;
        }
 
        Request->DataBuffer = Buffer.CmdIn->bBuffer;
    }
 
    Request->Complete = AtaReqCompleteSmartIoControl;
 
    AtaIdeRegsToTaskFile(DevExt, &Buffer.CmdIn->irDriveRegs, Request);
 
    return SRB_STATUS_PENDING;
}

Referenced by AtaReqTranslateRequest().

AtaReqStartCompletionDpc()

VOID AtaReqStartCompletionDpc

(

_In_ PATA_DEVICE_REQUEST

Request

)

Definition at line 777 of file scsi.c.

{
    ASSERT_REQUEST(Request);
 
    InterlockedPushEntrySList(&AtapCompletionQueueList, &Request->CompletionEntry);
    KeInsertQueueDpc(&AtapCompletionDpc, NULL, NULL);
}

Referenced by AtaPortGetNextEvent(), AtaPortQueueEvent(), AtaReqSendRequest(), AtaReqStartIo(), and AtaReqStartRequest().

AtaReqThawQueue()

DECLSPEC_NOINLINE_FROM_PAGED VOID AtaReqThawQueue	(	_In_ PATAPORT_DEVICE_EXTENSION	DevExt,
		_In_ ULONG	ReasonFlags
	)

Definition at line 1365 of file scsi.c.

{
    PATAPORT_IO_CONTEXT Device = &DevExt->Device;
    PATAPORT_PORT_DATA PortData;
    KIRQL OldIrql;
 
    KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
    KeAcquireSpinLockAtDpcLevel(&Device->QueueLock);
 
    if (Device->FreeRequestsBitmap != Device->MaxRequestsBitmap)
        AtaDeviceCheckPowerState(Device);
 
    PortData = Device->PortData;
    KeAcquireSpinLockAtDpcLevel(&PortData->QueueLock);
    if (!AtaReqPortQueueListDispatchNextRequest(PortData))
        KeReleaseSpinLockFromDpcLevel(&PortData->QueueLock);
 
    _InterlockedAnd(&Device->QueueFlags, ~ReasonFlags);
 
    if (!AtaReqDeviceQueueDispatchNextRequest(Device))
        KeReleaseSpinLockFromDpcLevel(&Device->QueueLock);
 
    KeLowerIrql(OldIrql);
}

Referenced by AtaPdoDispatchScsi(), AtaPdoStartDevice(), AtaPortDeviceProcessPowerChange(), and AtaPortExitStateMachine().

AtaReqWaitForOutstandingIoToComplete()

DECLSPEC_NOINLINE_FROM_PAGED VOID AtaReqWaitForOutstandingIoToComplete	(	_In_ PATAPORT_IO_CONTEXT	Device,
		_In_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 1395 of file scsi.c.

{
    KIRQL OldIrql;
    BOOLEAN DoWait;
    PATA_DEVICE_REQUEST Request;
 
    KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
    KeAcquireSpinLockAtDpcLevel(&Device->QueueLock);
 
    ASSERT(Device->QueueFlags & QUEUE_FLAGS_FROZEN);
 
    KeClearEvent(&Device->QueueStoppedEvent);
 
    if (Srb)
        Device->QuiescenceSrb = Srb;
 
    /* Wait for all the active IRPs to finish executing */
    if (Device->FreeRequestsBitmap != Device->MaxRequestsBitmap)
    {
        Device->QueueFlags |= QUEUE_FLAG_SIGNAL_STOP;
        DoWait = !Srb;
    }
    else
    {
        AtaDeviceQueueEmptyEvent(Device);
 
        KeSetEvent(&Device->QueueStoppedEvent, 0, FALSE);
        DoWait = FALSE;
    }
 
    Request = AtaReqRemovePortRequest(Device);
 
    KeReleaseSpinLockFromDpcLevel(&Device->QueueLock);
    KeLowerIrql(OldIrql);
 
    /* Requeue the pending request */
    if (Request)
    {
        Request->SrbStatus = SRB_STATUS_BUSY;
        Request->InternalState = REQUEST_STATE_NOT_STARTED;
 
        KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
        AtaReqCompleteRequest(Request);
        KeLowerIrql(OldIrql);
    }
 
    if (!DoWait)
        return;
 
    KeWaitForSingleObject(&Device->QueueStoppedEvent, Executive, KernelMode, FALSE, NULL);
}

Referenced by AtaPdoHandleQuiesceDevice(), and AtaPdoStopDevice().

AtaSetPortRegistryKey()

VOID AtaSetPortRegistryKey	(	_In_ PATAPORT_CHANNEL_EXTENSION	ChanExt,
		_In_ PCWSTR	KeyName,
		_In_ ULONG	KeyValue
	)

Definition at line 236 of file atapi.c.

{
    HANDLE HwKeyHandle;
    UNICODE_STRING ValueName;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    Status = IoOpenDeviceRegistryKey(ChanExt->Pdo,
                                     PLUGPLAY_REGKEY_DEVICE,
                                     KEY_ALL_ACCESS,
                                     &HwKeyHandle);
    if (!NT_SUCCESS(Status))
    {
        TRACE("Failed to open device hardware key, status 0x%lx\n", Status);
        return;
    }
 
    RtlInitUnicodeString(&ValueName, KeyName);
    Status = ZwSetValueKey(HwKeyHandle,
                           &ValueName,
                           0,
                           REG_DWORD,
                           &KeyValue,
                           sizeof(KeyValue));
    ZwClose(HwKeyHandle);
    if (!NT_SUCCESS(Status))
    {
        TRACE("Failed to set '%wZ' key, status 0x%lx\n", &ValueName, Status);
    }
}

Referenced by AtaFdoStartDevice().

AtaSetRegistryKey()

VOID AtaSetRegistryKey	(	_In_ PATAPORT_CHANNEL_EXTENSION	ChanExt,
		_In_ UCHAR	TargetId,
		_In_ PCWSTR	KeyName,
		_In_ ULONG	KeyValue
	)

Definition at line 180 of file atapi.c.

{
    HANDLE HwKeyHandle, TargetKeyHandle;
    UNICODE_STRING ValueName, TargetKeyName;
    NTSTATUS Status;
    WCHAR TargetKeyBuffer[sizeof("Target99")];
 
    PAGED_CODE();
 
    Status = IoOpenDeviceRegistryKey(ChanExt->Pdo,
                                     PLUGPLAY_REGKEY_DEVICE,
                                     KEY_ALL_ACCESS,
                                     &HwKeyHandle);
    if (!NT_SUCCESS(Status))
    {
        TRACE("Failed to open device hardware key, status 0x%lx\n", Status);
        return;
    }
 
    /* Open or create the 'TargetX' key */
    Status = RtlStringCbPrintfW(TargetKeyBuffer,
                                sizeof(TargetKeyBuffer),
                                L"Target%u",
                                TargetId);
    ASSERT(NT_SUCCESS(Status));
    RtlInitUnicodeString(&TargetKeyName, TargetKeyBuffer);
    Status = AtaOpenRegistryKey(&TargetKeyHandle, HwKeyHandle, &TargetKeyName, TRUE);
    if (!NT_SUCCESS(Status))
    {
        TRACE("Failed to create '%wZ' key, status 0x%lx\n", &TargetKeyName, Status);
        goto Cleanup;
    }
 
    RtlInitUnicodeString(&ValueName, KeyName);
    Status = ZwSetValueKey(TargetKeyHandle,
                           &ValueName,
                           0,
                           REG_DWORD,
                           &KeyValue,
                           sizeof(KeyValue));
    ZwClose(TargetKeyHandle);
    if (!NT_SUCCESS(Status))
    {
        TRACE("Failed to set '%wZ' key, status 0x%lx\n", &ValueName, Status);
    }
 
Cleanup:
    ZwClose(HwKeyHandle);
}

Referenced by AtaFdoInitializeDeviceRelations(), and AtaPdoInit().

AtaSwapIdString()

VOID AtaSwapIdString	(	_Inout_updates_bytes_(WordCount *sizeof(USHORT)) PVOID	Buffer,
		_In_range_(>, 0) ULONG	WordCount
	)

Definition at line 64 of file enum.c.

{
    PUSHORT Word = Buffer;
 
    /* The buffer should be USHORT aligned for ARM compatibility */
    ASSERT(((ULONG_PTR)Buffer & 1) == 0);
 
    while (WordCount--)
    {
        *Word = RtlUshortByteSwap(*Word);
        ++Word;
    }
}

Referenced by AtaCreateAtapiStandardInquiryData(), and AtaPdoFillIdentificationStrings().

AtaTypeCodeToName()

PCSTR AtaTypeCodeToName	(	_In_ PATAPORT_DEVICE_EXTENSION	DevExt,
		_In_ DEVICE_TYPE_NAME	Type
	)

Definition at line 42 of file atapi.c.

{
    ULONG DeviceType;
 
    PAGED_CODE();
 
    DeviceType = DevExt->InquiryData.DeviceType;
    DeviceType = min(DeviceType, RTL_NUMBER_OF(AtapGenericDeviceNames) - 1);
 
    switch (Type)
    {
        case GetDeviceType:
            return AtapGenericDeviceNames[DeviceType].DeviceType;
 
        case GetPeripheralId:
            return AtapGenericDeviceNames[DeviceType].PeripheralId;
 
        case GetGenericType:
            if (DevExt->Device.DeviceFlags & DEVICE_IS_SUPER_FLOPPY)
                return "GenSFloppy"; // Install the Super Floppy storage class driver
            else
                return AtapGenericDeviceNames[DeviceType].GenericType;
 
        default:
            ASSERT(FALSE);
            UNREACHABLE;
    }
}

Referenced by AtaPdoQueryId().

C_ASSERT() [1/6]

C_ASSERT

(

QUEUE_FLAG_FROZEN_QUEUE_FREEZE

= =SRB_FLAGS_BYPASS_FROZEN_QUEUE

)

C_ASSERT() [2/6]

C_ASSERT

(

QUEUE_FLAG_FROZEN_QUEUE_LOCK

= =SRB_FLAGS_BYPASS_LOCKED_QUEUE

)

C_ASSERT() [3/6]

C_ASSERT

(

REQUEST_FLAG_DATA_IN

= =SRB_FLAGS_DATA_IN

)

C_ASSERT() [4/6]

C_ASSERT

(

REQUEST_FLAG_DATA_OUT

= =SRB_FLAGS_DATA_OUT

)

C_ASSERT() [5/6]

C_ASSERT

(

REQUEST_FLAG_NO_KEEP_AWAKE

= =SRB_FLAGS_NO_KEEP_AWAKE

)

C_ASSERT() [6/6]

C_ASSERT

(

sizeof(REQUEST_QUEUE_ENTRY)<=4 *sizeof(PVOID)

)

IsPowerOfTwo()

FORCEINLINE BOOLEAN IsPowerOfTwo

(

_In_ ULONG

x

)

Definition at line 604 of file atapi.h.

{
    /* Also exclude zero numbers */
    return (x != 0) && ((x & (x - 1)) == 0);
}

Referenced by AtaAhciHandleFatalError(), and AtaReqAllocateSlot().

Variable Documentation

AtaAddChannel

DRIVER_ADD_DEVICE AtaAddChannel

Definition at line 646 of file atapi.h.

Referenced by DriverEntry().

AtapCompletionDpc

KDPC AtapCompletionDpc

extern

Definition at line 15 of file scsi.c.

Referenced by AtaPortOnRequestComplete(), AtaReqStartCompletionDpc(), and DriverEntry().

AtapCompletionQueueList

SLIST_HEADER AtapCompletionQueueList

extern

Definition at line 14 of file scsi.c.

Referenced by AtaPortOnRequestComplete(), AtaReqCompletionDpc(), AtaReqStartCompletionDpc(), and DriverEntry().

AtaPdoCompletionRoutine

IO_COMPLETION_ROUTINE AtaPdoCompletionRoutine

Definition at line 859 of file atapi.h.

Referenced by AtaPnpRepeatRequest().

AtapDriverRegistryPath

UNICODE_STRING AtapDriverRegistryPath

extern

Definition at line 14 of file atapi.c.

Referenced by AtaQueryWmiRegInfo(), AtaUnload(), and DriverEntry().

AtapInPEMode

BOOLEAN AtapInPEMode

extern

Definition at line 15 of file atapi.c.

Referenced by AtaDeviceLockSecurityModeFeatureCommands(), and DriverEntry().

AtaPortCompleteInternalRequest

REQUEST_COMPLETION_ROUTINE AtaPortCompleteInternalRequest

Definition at line 880 of file atapi.h.

Referenced by AtaFdoStartDevice().

AtaPortIoTimer

IO_TIMER_ROUTINE AtaPortIoTimer

Definition at line 938 of file atapi.h.

Referenced by AtaFdoStartDevice().

AtaPortNotification

PORT_NOTIFICATION AtaPortNotification

Definition at line 881 of file atapi.h.

Referenced by AtaFdoStartDevice().

AtaPortWorkerSignalDpc

KDEFERRED_ROUTINE AtaPortWorkerSignalDpc

Definition at line 879 of file atapi.h.

Referenced by AtaFdoStartDevice().

AtaPortWorkerThread

KSTART_ROUTINE AtaPortWorkerThread

Definition at line 878 of file atapi.h.

Referenced by AtaFdoCreatePortThread(), AtaPortEnterStateMachine(), and AtaPortExitStateMachine().

AtaReqCompletionDpc

KDEFERRED_ROUTINE AtaReqCompletionDpc

Definition at line 939 of file atapi.h.

Referenced by DriverEntry().

AtaStorageNotificationlDpc

KDEFERRED_ROUTINE AtaStorageNotificationlDpc

Definition at line 655 of file atapi.h.

Referenced by AtaFdoStartDevice(), and AtaStorageNotificationlDpc().

AtaStorageNotificationWorker

IO_WORKITEM_ROUTINE AtaStorageNotificationWorker

Definition at line 654 of file atapi.h.

Referenced by AtaStorageNotificationlDpc().

AtaUnload

DRIVER_UNLOAD AtaUnload

Definition at line 649 of file atapi.h.

Referenced by DriverEntry().

DriverEntry

DRIVER_INITIALIZE DriverEntry

Definition at line 652 of file atapi.h.