You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1609 lines
46 KiB
1609 lines
46 KiB
/*++
|
|
Copyright (C) Microsoft Corporation, 1998 - 1999
|
|
|
|
Module Name:
|
|
|
|
RedBook.c
|
|
|
|
Abstract:
|
|
|
|
Author:
|
|
|
|
|
|
Environment:
|
|
|
|
kernel mode only
|
|
|
|
Notes:
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "redbook.h"
|
|
#include "ntddredb.h"
|
|
#include "proto.h"
|
|
#include <scsi.h> // for SetKnownGoodDrive()
|
|
#include <stdio.h> // vsprintf()
|
|
|
|
#ifdef _USE_ETW
|
|
#include "ioctl.tmh"
|
|
#endif // _USE_ETW
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE, RedBookCheckForDiscChangeAndFreeResources )
|
|
#pragma alloc_text(PAGE, RedBookCompleteIoctl )
|
|
#pragma alloc_text(PAGE, RedBookDCCheckVerify )
|
|
#pragma alloc_text(PAGE, RedBookDCDefault )
|
|
#pragma alloc_text(PAGE, RedBookDCGetVolume )
|
|
#pragma alloc_text(PAGE, RedBookDCPause )
|
|
#pragma alloc_text(PAGE, RedBookDCPlay )
|
|
#pragma alloc_text(PAGE, RedBookDCReadQ )
|
|
#pragma alloc_text(PAGE, RedBookDCResume )
|
|
#pragma alloc_text(PAGE, RedBookDCSeek )
|
|
#pragma alloc_text(PAGE, RedBookDCSetVolume )
|
|
#pragma alloc_text(PAGE, RedBookDCStop )
|
|
#pragma alloc_text(PAGE, RedBookThreadIoctlCompletionHandler )
|
|
#pragma alloc_text(PAGE, RedBookThreadIoctlHandler )
|
|
#pragma alloc_text(PAGE, WhichTrackContainsThisLBA )
|
|
#endif // ALLOC_PRAGMA
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
NTSTATUS
|
|
RedBookDeviceControl(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called by the I/O subsystem for device controls.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject
|
|
Irp
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
PREDBOOK_DEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
|
PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation( Irp );
|
|
ULONG cdromState;
|
|
NTSTATUS status;
|
|
|
|
BOOLEAN putOnQueue = FALSE;
|
|
BOOLEAN completeRequest = FALSE;
|
|
|
|
//
|
|
// ioctls not guaranteed at passive, making this whole
|
|
// section non-paged
|
|
//
|
|
|
|
//
|
|
// Prevent a remove from occuring while IO pending
|
|
//
|
|
|
|
status = IoAcquireRemoveLock( &deviceExtension->RemoveLock, Irp );
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DeviceControl !! Unable to acquire remove lock %lx\n",
|
|
status));
|
|
Irp->IoStatus.Information = 0;
|
|
Irp->IoStatus.Status = status;
|
|
IoCompleteRequest( Irp, IO_CD_ROM_INCREMENT );
|
|
return status;
|
|
}
|
|
|
|
#if DBG
|
|
//
|
|
// save some info for the last N device ioctls that came through
|
|
//
|
|
{
|
|
ULONG index;
|
|
ULONG sizeToCopy;
|
|
ULONG stacksToCopy;
|
|
PSAVED_IO savedIo;
|
|
|
|
index = InterlockedIncrement(&deviceExtension->SavedIoCurrentIndex);
|
|
index %= SAVED_IO_MAX;
|
|
|
|
savedIo = &(deviceExtension->SavedIo[index]);
|
|
|
|
//
|
|
// copy as much of the irp as we can....
|
|
//
|
|
|
|
savedIo->OriginalIrp = Irp;
|
|
if (Irp->StackCount > 7) {
|
|
|
|
sizeToCopy = IoSizeOfIrp(8);
|
|
RtlFillMemory(savedIo, sizeToCopy, 0xff);
|
|
sizeToCopy -= sizeof(IO_STACK_LOCATION);
|
|
RtlCopyMemory(savedIo, Irp, sizeToCopy);
|
|
|
|
} else {
|
|
|
|
sizeToCopy = IoSizeOfIrp(Irp->StackCount);
|
|
RtlZeroMemory(savedIo, sizeof(SAVED_IO));
|
|
RtlCopyMemory(savedIo, Irp, sizeToCopy);
|
|
|
|
}
|
|
} // end of saved io
|
|
#endif // DBG
|
|
|
|
//
|
|
// if handled, just verify the paramters in this routine.
|
|
//
|
|
|
|
status = STATUS_UNSUCCESSFUL;
|
|
cdromState = GetCdromState(deviceExtension);
|
|
|
|
switch ( currentIrpStack->Parameters.DeviceIoControl.IoControlCode ) {
|
|
|
|
case IOCTL_CDROM_PAUSE_AUDIO: {
|
|
if (TEST_FLAG(cdromState, CD_STOPPED)) {
|
|
Irp->IoStatus.Information = 0;
|
|
status = STATUS_INVALID_DEVICE_REQUEST;
|
|
completeRequest = TRUE;
|
|
} else {
|
|
putOnQueue = TRUE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_STOP_AUDIO: {
|
|
if (TEST_FLAG(cdromState, CD_STOPPED)) {
|
|
Irp->IoStatus.Information = 0;
|
|
status = STATUS_SUCCESS;
|
|
completeRequest = TRUE;
|
|
} else {
|
|
putOnQueue = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_RESUME_AUDIO: {
|
|
if (TEST_FLAG(cdromState, CD_STOPPED)) {
|
|
Irp->IoStatus.Information = 0;
|
|
status = STATUS_INVALID_DEVICE_REQUEST;
|
|
completeRequest = TRUE;
|
|
} else {
|
|
putOnQueue = TRUE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_PLAY_AUDIO_MSF: {
|
|
if (currentIrpStack->Parameters.DeviceIoControl.InputBufferLength <
|
|
sizeof(CDROM_PLAY_AUDIO_MSF)) {
|
|
Irp->IoStatus.Information = sizeof(CDROM_PLAY_AUDIO_MSF);
|
|
status = STATUS_BUFFER_TOO_SMALL;
|
|
completeRequest = TRUE;
|
|
} else {
|
|
putOnQueue = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_SEEK_AUDIO_MSF: {
|
|
if (currentIrpStack->Parameters.DeviceIoControl.InputBufferLength <
|
|
sizeof(CDROM_SEEK_AUDIO_MSF)) {
|
|
Irp->IoStatus.Information = sizeof(CDROM_SEEK_AUDIO_MSF);
|
|
status = STATUS_BUFFER_TOO_SMALL;
|
|
completeRequest = TRUE;
|
|
} else if (TEST_FLAG(cdromState, CD_STOPPED)) {
|
|
// default -- passthrough
|
|
// REQUIRED to reduce latency for some drives.
|
|
// drives may still fail the request
|
|
} else {
|
|
putOnQueue = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_READ_Q_CHANNEL: {
|
|
|
|
PCDROM_SUB_Q_DATA_FORMAT inputBuffer;
|
|
|
|
inputBuffer = Irp->AssociatedIrp.SystemBuffer;
|
|
|
|
if (currentIrpStack->Parameters.DeviceIoControl.OutputBufferLength <
|
|
sizeof(SUB_Q_CHANNEL_DATA)) {
|
|
Irp->IoStatus.Information = sizeof(SUB_Q_CHANNEL_DATA);
|
|
status = STATUS_BUFFER_TOO_SMALL;
|
|
completeRequest = TRUE;
|
|
} else if (currentIrpStack->Parameters.DeviceIoControl.InputBufferLength <
|
|
sizeof(CDROM_SUB_Q_DATA_FORMAT)){
|
|
Irp->IoStatus.Information = sizeof(CDROM_SUB_Q_DATA_FORMAT);
|
|
status = STATUS_INFO_LENGTH_MISMATCH;
|
|
completeRequest = TRUE;
|
|
} else if (inputBuffer->Format != IOCTL_CDROM_CURRENT_POSITION &&
|
|
inputBuffer->Format != IOCTL_CDROM_MEDIA_CATALOG &&
|
|
inputBuffer->Format != IOCTL_CDROM_TRACK_ISRC ) {
|
|
Irp->IoStatus.Information = 0;
|
|
status = STATUS_INVALID_PARAMETER;
|
|
completeRequest = TRUE;
|
|
} else if (TEST_FLAG(cdromState, CD_STOPPED)) {
|
|
// default -- passthrough
|
|
} else {
|
|
putOnQueue = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_SET_VOLUME: {
|
|
|
|
if (currentIrpStack->Parameters.DeviceIoControl.InputBufferLength <
|
|
sizeof(VOLUME_CONTROL)) {
|
|
Irp->IoStatus.Information = sizeof(VOLUME_CONTROL);
|
|
status = STATUS_BUFFER_TOO_SMALL;
|
|
completeRequest = TRUE;
|
|
} else if (TEST_FLAG(cdromState, CD_STOPPED)) {
|
|
// default -- passthrough
|
|
// BUGBUG -- this should set our internal volume
|
|
} else {
|
|
putOnQueue = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_GET_VOLUME: {
|
|
|
|
if (currentIrpStack->Parameters.DeviceIoControl.OutputBufferLength <
|
|
sizeof(VOLUME_CONTROL)) {
|
|
Irp->IoStatus.Information = sizeof(VOLUME_CONTROL);
|
|
status = STATUS_BUFFER_TOO_SMALL;
|
|
completeRequest = TRUE;
|
|
} else if (TEST_FLAG(cdromState, CD_STOPPED)) {
|
|
// default -- passthrough
|
|
// BUGBUG -- this should return our internal volume
|
|
} else {
|
|
putOnQueue = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case IOCTL_STORAGE_CHECK_VERIFY2:
|
|
case IOCTL_STORAGE_CHECK_VERIFY:
|
|
case IOCTL_CDROM_CHECK_VERIFY:
|
|
case IOCTL_DISK_CHECK_VERIFY: {
|
|
|
|
if ((currentIrpStack->Parameters.DeviceIoControl.OutputBufferLength) &&
|
|
(currentIrpStack->Parameters.DeviceIoControl.OutputBufferLength <
|
|
sizeof(ULONG))) {
|
|
Irp->IoStatus.Information = sizeof(ULONG);
|
|
status = STATUS_BUFFER_TOO_SMALL;
|
|
completeRequest = TRUE;
|
|
} else if (TEST_FLAG(cdromState, CD_STOPPED)) {
|
|
// default -- passthrough
|
|
} else {
|
|
putOnQueue = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
|
|
if (TEST_FLAG(cdromState, CD_STOPPED)) {
|
|
// default -- passthrough
|
|
} else {
|
|
putOnQueue = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (putOnQueue) {
|
|
|
|
PREDBOOK_THREAD_IOCTL_DATA ioctlData;
|
|
|
|
ASSERT(completeRequest == FALSE);
|
|
|
|
//
|
|
// need to allocate some info for each ioctl we handle
|
|
//
|
|
|
|
ioctlData =
|
|
(PREDBOOK_THREAD_IOCTL_DATA)ExAllocatePoolWithTag(
|
|
NonPagedPool,
|
|
sizeof(REDBOOK_THREAD_IOCTL_DATA),
|
|
TAG_T_IOCTL);
|
|
if (ioctlData == NULL) {
|
|
Irp->IoStatus.Information = 0;
|
|
Irp->IoStatus.Status = STATUS_NO_MEMORY;
|
|
IoCompleteRequest(Irp, IO_CD_ROM_INCREMENT);
|
|
IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp);
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
|
|
RtlZeroMemory(ioctlData, sizeof(REDBOOK_THREAD_IOCTL_DATA));
|
|
ioctlData->Irp = Irp;
|
|
ioctlData->Irp->IoStatus.Status = STATUS_PENDING;
|
|
IoMarkIrpPending(ioctlData->Irp);
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DeviceControl => Queue Ioctl Irp %p (%p)\n",
|
|
ioctlData->Irp, ioctlData));
|
|
|
|
//
|
|
// queue them, allow thread to handle request
|
|
//
|
|
|
|
ExInterlockedInsertTailList(&deviceExtension->Thread.IoctlList,
|
|
&ioctlData->ListEntry,
|
|
&deviceExtension->Thread.IoctlLock);
|
|
KeSetEvent(deviceExtension->Thread.Events[EVENT_IOCTL],
|
|
IO_NO_INCREMENT, FALSE);
|
|
|
|
|
|
status = STATUS_PENDING;
|
|
|
|
} else if (completeRequest) {
|
|
|
|
ASSERT(putOnQueue == FALSE);
|
|
|
|
//
|
|
// some error, ie. invalid buffer length
|
|
//
|
|
if (!NT_SUCCESS(status)) {
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DeviceControl => Completing Irp %p with error %x\n",
|
|
Irp, status));
|
|
} else {
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DeviceControl => Completing Irp %p early?\n",
|
|
Irp));
|
|
}
|
|
Irp->IoStatus.Status = status;
|
|
|
|
IoCompleteRequest(Irp, IO_CD_ROM_INCREMENT);
|
|
IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp);
|
|
|
|
} else {
|
|
|
|
//
|
|
// pass it through
|
|
//
|
|
|
|
status = RedBookSendToNextDriver(DeviceObject, Irp);
|
|
IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp);
|
|
|
|
}
|
|
|
|
|
|
return status;
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
VOID
|
|
RedBookThreadIoctlCompletionHandler(
|
|
PREDBOOK_DEVICE_EXTENSION DeviceExtension
|
|
)
|
|
{
|
|
PIO_STACK_LOCATION irpStack;
|
|
PREDBOOK_THREAD_IOCTL_DATA ioctlData;
|
|
ULONG state;
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
ioctlData = CONTAINING_RECORD(DeviceExtension->Thread.IoctlCurrent,
|
|
REDBOOK_THREAD_IOCTL_DATA,
|
|
ListEntry);
|
|
|
|
state = GetCdromState(DeviceExtension);
|
|
irpStack = IoGetCurrentIrpStackLocation(ioctlData->Irp);
|
|
|
|
//
|
|
// final state should be set by the digital handler
|
|
//
|
|
|
|
switch (irpStack->Parameters.DeviceIoControl.IoControlCode) {
|
|
|
|
case IOCTL_CDROM_PAUSE_AUDIO: {
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"IoctlComp => Finishing pause %p\n", ioctlData->Irp));
|
|
|
|
ASSERT(state == CD_PAUSED);
|
|
|
|
ioctlData->Irp->IoStatus.Information = 0;
|
|
ioctlData->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
RedBookCompleteIoctl(DeviceExtension, ioctlData, FALSE);
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_SEEK_AUDIO_MSF: {
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"IoctlComp => Finishing seek %p\n", ioctlData->Irp));
|
|
|
|
ASSERT(state == CD_PLAYING);
|
|
|
|
DeviceExtension->Buffer.FirstPause = 1;
|
|
KeSetEvent(DeviceExtension->Thread.Events[EVENT_DIGITAL],
|
|
IO_CD_ROM_INCREMENT, FALSE);
|
|
ioctlData->Irp->IoStatus.Information = 0;
|
|
ioctlData->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
RedBookCompleteIoctl(DeviceExtension, ioctlData, FALSE);
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_STOP_AUDIO: {
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"IoctlComp => Finishing stop %p\n", ioctlData->Irp));
|
|
|
|
ASSERT(TEST_FLAG(state, CD_STOPPED));
|
|
|
|
ioctlData->Irp->IoStatus.Information = 0;
|
|
ioctlData->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
RedBookCompleteIoctl(DeviceExtension, ioctlData, FALSE);
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"IoctlComp => Unhandled Irp %p\n", ioctlData->Irp));
|
|
ASSERT(FALSE);
|
|
|
|
ioctlData->Irp->IoStatus.Information = 0;
|
|
ioctlData->Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
|
|
RedBookCompleteIoctl(DeviceExtension, ioctlData, FALSE);
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
RedBookCompleteIoctl(
|
|
IN PREDBOOK_DEVICE_EXTENSION DeviceExtension,
|
|
IN PREDBOOK_THREAD_IOCTL_DATA Context,
|
|
IN BOOLEAN SendToLowerDriver
|
|
)
|
|
{
|
|
PIRP irp = Context->Irp;
|
|
|
|
//
|
|
// only to be called from the thread
|
|
//
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
//
|
|
// should be properly setup for completion
|
|
//
|
|
|
|
if (DeviceExtension->Thread.IoctlCurrent == &Context->ListEntry) {
|
|
|
|
//
|
|
// an ioctl that required post-processing is finished.
|
|
// allow the next one to occur
|
|
//
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"CompleteIoctl => state-changing Irp %p completed\n",
|
|
irp));
|
|
DeviceExtension->Thread.IoctlCurrent = NULL;
|
|
|
|
}
|
|
|
|
ExFreePool(Context);
|
|
Context = NULL;
|
|
|
|
if (SendToLowerDriver) {
|
|
NTSTATUS status;
|
|
status = RedBookSendToNextDriver(DeviceExtension->SelfDeviceObject, irp);
|
|
IoReleaseRemoveLock(&DeviceExtension->RemoveLock, irp);
|
|
return status;
|
|
|
|
|
|
} else {
|
|
IoCompleteRequest(irp, IO_CD_ROM_INCREMENT);
|
|
IoReleaseRemoveLock(&DeviceExtension->RemoveLock, irp);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
RedBookThreadIoctlHandler(
|
|
IN PREDBOOK_DEVICE_EXTENSION DeviceExtension,
|
|
IN PLIST_ENTRY ListEntry
|
|
)
|
|
{
|
|
PREDBOOK_THREAD_IOCTL_DATA data;
|
|
PIO_STACK_LOCATION currentIrpStack;
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
//
|
|
// should never happen if a state-changing ioctl is in progress
|
|
//
|
|
|
|
ASSERT(DeviceExtension->Thread.IoctlCurrent == NULL);
|
|
|
|
//
|
|
// don't use stale info
|
|
//
|
|
|
|
RedBookCheckForDiscChangeAndFreeResources(DeviceExtension);
|
|
|
|
//
|
|
// get the ioctl that set this event and
|
|
// start working on state changes neccessary
|
|
//
|
|
|
|
data = CONTAINING_RECORD(ListEntry, REDBOOK_THREAD_IOCTL_DATA, ListEntry);
|
|
|
|
currentIrpStack = IoGetCurrentIrpStackLocation(data->Irp);
|
|
|
|
//
|
|
// now guaranteed it's ok to run this ioctl
|
|
// it's the responsibility of these routines to call RedBookCompleteIoctl()
|
|
// *** OR *** to set DeviceExtension->Thread.IoctlCurrent to
|
|
// Context->ListEntry if it requires post-processing, as this
|
|
// is the mechanism used to determine the ioctl is still inprogress
|
|
//
|
|
|
|
switch (currentIrpStack->Parameters.DeviceIoControl.IoControlCode) {
|
|
|
|
case IOCTL_CDROM_PLAY_AUDIO_MSF: {
|
|
RedBookDCPlay(DeviceExtension, data);
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_PAUSE_AUDIO: {
|
|
RedBookDCPause(DeviceExtension, data);
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_RESUME_AUDIO: {
|
|
RedBookDCResume(DeviceExtension, data);
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_STOP_AUDIO: {
|
|
RedBookDCStop(DeviceExtension, data);
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_SEEK_AUDIO_MSF: {
|
|
RedBookDCSeek(DeviceExtension, data);
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_READ_Q_CHANNEL: {
|
|
RedBookDCReadQ(DeviceExtension, data);
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_SET_VOLUME: {
|
|
RedBookDCSetVolume(DeviceExtension, data);
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_GET_VOLUME: {
|
|
RedBookDCGetVolume(DeviceExtension, data);
|
|
break;
|
|
}
|
|
|
|
case IOCTL_CDROM_CHECK_VERIFY:
|
|
case IOCTL_DISK_CHECK_VERIFY:
|
|
case IOCTL_STORAGE_CHECK_VERIFY:
|
|
case IOCTL_STORAGE_CHECK_VERIFY2: {
|
|
RedBookDCCheckVerify(DeviceExtension, data);
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
data->Irp->IoStatus.Status = STATUS_DEVICE_BUSY;
|
|
data->Irp->IoStatus.Information = 0;
|
|
RedBookCompleteIoctl(DeviceExtension, data, TRUE);
|
|
break;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
VOID
|
|
RedBookDCCheckVerify(
|
|
PREDBOOK_DEVICE_EXTENSION DeviceExtension,
|
|
PREDBOOK_THREAD_IOCTL_DATA Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
PIO_STACK_LOCATION currentIrpStack;
|
|
ULONG state;
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
state = GetCdromState(DeviceExtension);
|
|
|
|
currentIrpStack = IoGetCurrentIrpStackLocation(Context->Irp);
|
|
|
|
if (!TEST_FLAG(state, CD_PLAYING) && !TEST_FLAG(state, CD_PAUSED)) { // !handling ioctls
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCCheckVerify => not playing\n"));
|
|
RedBookCompleteIoctl(DeviceExtension, Context, TRUE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// data buffer is optional for this ioctl
|
|
//
|
|
|
|
if (currentIrpStack->Parameters.DeviceIoControl.OutputBufferLength) {
|
|
|
|
*((PULONG)Context->Irp->AssociatedIrp.SystemBuffer) =
|
|
DeviceExtension->CDRom.CheckVerify;
|
|
Context->Irp->IoStatus.Information = sizeof(ULONG);
|
|
|
|
} else {
|
|
|
|
Context->Irp->IoStatus.Information = 0;
|
|
|
|
}
|
|
|
|
Context->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
RedBookDCDefault(
|
|
PREDBOOK_DEVICE_EXTENSION DeviceExtension,
|
|
PREDBOOK_THREAD_IOCTL_DATA Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
ULONG state;
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
state = GetCdromState(DeviceExtension);
|
|
|
|
//
|
|
// IOCTLs are not all guaranteed to be called at passive irql,
|
|
// so this can never be paged code.
|
|
// there is a window of opportunity to send an ioctl while playing
|
|
// audio digitally, but it can be ignored. this allows much more
|
|
// pagable code.
|
|
//
|
|
|
|
if (!TEST_FLAG(state, CD_PLAYING) && !TEST_FLAG(state, CD_PAUSED)) { // !handling ioctls
|
|
|
|
RedBookCompleteIoctl(DeviceExtension, Context, TRUE);
|
|
|
|
} else {
|
|
|
|
//
|
|
// Complete the Irp
|
|
//
|
|
|
|
Context->Irp->IoStatus.Information = 0;
|
|
Context->Irp->IoStatus.Status = STATUS_DEVICE_BUSY;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
|
|
}
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
RedBookDCGetVolume(
|
|
PREDBOOK_DEVICE_EXTENSION DeviceExtension,
|
|
PREDBOOK_THREAD_IOCTL_DATA Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
PIO_STACK_LOCATION currentIrpStack;
|
|
NTSTATUS status;
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCGetVolume => Entering %p\n", Context->Irp));
|
|
|
|
//
|
|
// guaranteed the volume info will not change
|
|
//
|
|
|
|
RtlCopyMemory(Context->Irp->AssociatedIrp.SystemBuffer, // to
|
|
&DeviceExtension->CDRom.Volume, // from
|
|
sizeof(VOLUME_CONTROL));
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCGetVolume => volume was:"
|
|
" (hex) %2x %2x %2x %2x\n",
|
|
DeviceExtension->CDRom.Volume.PortVolume[0],
|
|
DeviceExtension->CDRom.Volume.PortVolume[1],
|
|
DeviceExtension->CDRom.Volume.PortVolume[2],
|
|
DeviceExtension->CDRom.Volume.PortVolume[3]));
|
|
|
|
//
|
|
// Complete the Irp (IoStatus.Information set above)
|
|
//
|
|
|
|
Context->Irp->IoStatus.Information = sizeof(VOLUME_CONTROL);
|
|
Context->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
RedBookDCPause(
|
|
PREDBOOK_DEVICE_EXTENSION DeviceExtension,
|
|
PREDBOOK_THREAD_IOCTL_DATA Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
ULONG state;
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
state = GetCdromState(DeviceExtension);
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCPause => Entering %p\n", Context->Irp));
|
|
|
|
if (!TEST_FLAG(state, CD_PLAYING)) {
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCPause => Not playing\n"));
|
|
Context->Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
|
|
Context->Irp->IoStatus.Information = 0;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, TRUE);
|
|
return;
|
|
|
|
}
|
|
|
|
if (TEST_FLAG(state, CD_PAUSED)) {
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCPause => Already paused %p\n", Context->Irp));
|
|
Context->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Context->Irp->IoStatus.Information = 0;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
|
|
} else {
|
|
|
|
//
|
|
// since setting to a temp state, it is not appropriate to
|
|
// complete the irp until the operation itself completes.
|
|
//
|
|
|
|
ASSERT(!TEST_FLAG(state, CD_PAUSING));
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCPause => Starting pause %p\n", Context->Irp));
|
|
DeviceExtension->Thread.IoctlCurrent = &Context->ListEntry;
|
|
state = SetCdromState(DeviceExtension, state, state | CD_PAUSING);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
RedBookDCPlay(
|
|
PREDBOOK_DEVICE_EXTENSION DeviceExtension,
|
|
PREDBOOK_THREAD_IOCTL_DATA Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
PCDROM_PLAY_AUDIO_MSF inputBuffer;
|
|
PIO_STACK_LOCATION thisIrpStack;
|
|
PIO_STACK_LOCATION nextIrpStack;
|
|
PREVENT_MEDIA_REMOVAL mediaRemoval;
|
|
ULONG sector;
|
|
ULONG i;
|
|
ULONG state;
|
|
NTSTATUS status;
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
inputBuffer = Context->Irp->AssociatedIrp.SystemBuffer;
|
|
thisIrpStack = IoGetCurrentIrpStackLocation(Context->Irp);
|
|
nextIrpStack = IoGetNextIrpStackLocation(Context->Irp);
|
|
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCPlay => Entering %p\n", Context->Irp));
|
|
|
|
status = RedBookCacheToc(DeviceExtension);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
Context->Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
|
|
Context->Irp->IoStatus.Information = 0;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
}
|
|
|
|
sector = MSF_TO_LBA(inputBuffer->EndingM,
|
|
inputBuffer->EndingS,
|
|
inputBuffer->EndingF);
|
|
|
|
DeviceExtension->CDRom.EndPlay = sector;
|
|
|
|
sector = MSF_TO_LBA(inputBuffer->StartingM,
|
|
inputBuffer->StartingS,
|
|
inputBuffer->StartingF);
|
|
|
|
DeviceExtension->CDRom.NextToRead = sector;
|
|
DeviceExtension->CDRom.NextToStream = sector;
|
|
DeviceExtension->CDRom.FinishedStreaming = sector;
|
|
|
|
//
|
|
// Make sure the ending sector is within disc
|
|
// bounds or return STATUS_INVALID_DEVICE_REQUEST?
|
|
// this will prevent success on play, followed by an
|
|
// immediate stop.
|
|
//
|
|
|
|
if (0) {
|
|
PCDROM_TOC toc = DeviceExtension->CDRom.Toc;
|
|
LONG track;
|
|
LONG endTrack;
|
|
|
|
//
|
|
// ensure end has an lba greater than start
|
|
//
|
|
|
|
if (DeviceExtension->CDRom.EndPlay <=
|
|
DeviceExtension->CDRom.NextToRead) {
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"Play => End sector (%x) must be more than start "
|
|
"sector (%x)\n",
|
|
DeviceExtension->CDRom.EndPlay,
|
|
DeviceExtension->CDRom.NextToRead
|
|
));
|
|
Context->Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
|
|
Context->Irp->IoStatus.Information = 0;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// what track(s) are we playing?
|
|
//
|
|
|
|
track = WhichTrackContainsThisLBA(toc, DeviceExtension->CDRom.NextToRead);
|
|
endTrack = WhichTrackContainsThisLBA(toc, DeviceExtension->CDRom.EndPlay);
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"Play => Playing sector %x to %x (track %x to %x)\n",
|
|
DeviceExtension->CDRom.NextToRead,
|
|
DeviceExtension->CDRom.EndPlay,
|
|
track,
|
|
endTrack));
|
|
|
|
//
|
|
// make sure the tracks are actually valid
|
|
//
|
|
|
|
if (track < 0 ||
|
|
endTrack < 0 ||
|
|
endTrack <= (toc->LastTrack - toc->FirstTrack)
|
|
) {
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"Play => Track %x is invalid\n", track));
|
|
Context->Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
|
|
Context->Irp->IoStatus.Information = 0;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
|
|
}
|
|
|
|
for (;track <= endTrack;track++) {
|
|
if (toc->TrackData[track].Adr & AUDIO_DATA_TRACK) {
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"Play => Track %x is not audio\n", track));
|
|
Context->Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
|
|
Context->Irp->IoStatus.Information = 0;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// if not paused, then state must equal stopped, which means we need
|
|
// to allocate the resources.
|
|
//
|
|
|
|
state = GetCdromState(DeviceExtension);
|
|
|
|
if (TEST_FLAG(state, CD_PAUSED)) {
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCPlay => Resuming playback?\n"));
|
|
|
|
} else {
|
|
|
|
//
|
|
// this function will allocate them iff they are not
|
|
// already allocated.
|
|
//
|
|
|
|
status = RedBookAllocatePlayResources(DeviceExtension);
|
|
if (!NT_SUCCESS(status)) {
|
|
Context->Irp->IoStatus.Status = STATUS_NO_MEMORY;
|
|
Context->Irp->IoStatus.Information = 0;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Set the new device state (thread will begin playing)
|
|
//
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCPlay => Setting state to CD_PLAYING\n"));
|
|
state = SetCdromState(DeviceExtension, state, CD_PLAYING);
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCPlay => Exiting successfully\n"));
|
|
|
|
//
|
|
// finish the request if it's a user
|
|
// request for a new play operation
|
|
//
|
|
|
|
Context->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Context->Irp->IoStatus.Information = 0;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
RedBookDCReadQ(
|
|
PREDBOOK_DEVICE_EXTENSION DeviceExtension,
|
|
PREDBOOK_THREAD_IOCTL_DATA Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
PCDROM_SUB_Q_DATA_FORMAT inputBuffer;
|
|
PIO_STACK_LOCATION currentIrpStack;
|
|
UCHAR formatCode;
|
|
ULONG state;
|
|
NTSTATUS status;
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
inputBuffer = Context->Irp->AssociatedIrp.SystemBuffer;
|
|
currentIrpStack = IoGetCurrentIrpStackLocation(Context->Irp);
|
|
state = GetCdromState(DeviceExtension);
|
|
|
|
if (!TEST_FLAG(state, CD_PLAYING) && !TEST_FLAG(state, CD_PAUSED)) { // !handling ioctls
|
|
|
|
//
|
|
// no need to handle this irp
|
|
//
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCReadQ => Not playing\n"));
|
|
RedBookCompleteIoctl(DeviceExtension, Context, TRUE);
|
|
return;
|
|
}
|
|
|
|
if (inputBuffer->Format != IOCTL_CDROM_CURRENT_POSITION) {
|
|
Context->Irp->IoStatus.Information = 0;
|
|
Context->Irp->IoStatus.Status = STATUS_DEVICE_BUSY;
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCReadQ => Bad Format %x\n", inputBuffer->Format));
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// we are in the midst of playback or pause. fake the information
|
|
// a real cdrom would have returned if it was playing audio at the
|
|
// same location that we are currently at.
|
|
//
|
|
|
|
{
|
|
PSUB_Q_CURRENT_POSITION outputBuffer;
|
|
PCDROM_TOC toc;
|
|
ULONG lbaTrack;
|
|
ULONG lbaRelative;
|
|
ULONG instantLba;
|
|
UCHAR timeAbsolute[3] = {0};
|
|
UCHAR timeRelative[3] = {0};
|
|
LONG trackNumber;
|
|
|
|
outputBuffer = Context->Irp->AssociatedIrp.SystemBuffer;
|
|
RtlZeroMemory(outputBuffer,
|
|
currentIrpStack->Parameters.DeviceIoControl.OutputBufferLength);
|
|
|
|
//
|
|
// Still playing audio
|
|
//
|
|
|
|
outputBuffer->Header.Reserved = 0;
|
|
if (TEST_FLAG(state, CD_PAUSED)) {
|
|
outputBuffer->Header.AudioStatus = AUDIO_STATUS_PAUSED;
|
|
} else if (TEST_FLAG(state, CD_PLAYING)) {
|
|
outputBuffer->Header.AudioStatus = AUDIO_STATUS_IN_PROGRESS;
|
|
} else {
|
|
ASSERT(!"State was invalid?");
|
|
outputBuffer->Header.AudioStatus = AUDIO_STATUS_IN_PROGRESS;
|
|
}
|
|
outputBuffer->Header.DataLength[0] =
|
|
(sizeof(SUB_Q_CURRENT_POSITION) - sizeof(SUB_Q_HEADER)) >> 8;
|
|
outputBuffer->Header.DataLength[1] =
|
|
(sizeof(SUB_Q_CURRENT_POSITION) - sizeof(SUB_Q_HEADER)) & 0xFF;
|
|
|
|
|
|
//
|
|
// we are in the thread, which alloc's/dealloc's the toc
|
|
//
|
|
|
|
toc = DeviceExtension->CDRom.Toc;
|
|
ASSERT(toc);
|
|
|
|
//
|
|
// we return the last played sector as a result per the spec
|
|
//
|
|
|
|
instantLba = DeviceExtension->CDRom.FinishedStreaming;
|
|
|
|
trackNumber = WhichTrackContainsThisLBA(toc, instantLba);
|
|
|
|
|
|
ASSERT(trackNumber >= 0);
|
|
|
|
outputBuffer->FormatCode = IOCTL_CDROM_CURRENT_POSITION;
|
|
outputBuffer->Control = toc->TrackData[trackNumber].Control;
|
|
outputBuffer->ADR = toc->TrackData[trackNumber].Adr;
|
|
outputBuffer->TrackNumber = toc->TrackData[trackNumber].TrackNumber;
|
|
|
|
//
|
|
// Get the track's LBA
|
|
//
|
|
|
|
lbaTrack = MSF_TO_LBA(toc->TrackData[trackNumber].Address[1],
|
|
toc->TrackData[trackNumber].Address[2],
|
|
toc->TrackData[trackNumber].Address[3]);
|
|
|
|
//
|
|
// Get the current play LBA
|
|
//
|
|
|
|
lbaRelative = instantLba;
|
|
|
|
//
|
|
// Subtract the track's LBA to get the relative LBA
|
|
//
|
|
|
|
lbaRelative -= lbaTrack;
|
|
|
|
//
|
|
// Finally convert it back to MSF
|
|
//
|
|
|
|
LBA_TO_MSF(instantLba,
|
|
timeAbsolute[0],
|
|
timeAbsolute[1],
|
|
timeAbsolute[2]);
|
|
LBA_TO_RELATIVE_MSF(lbaRelative,
|
|
timeRelative[0],
|
|
timeRelative[1],
|
|
timeRelative[2]);
|
|
|
|
outputBuffer->IndexNumber = (UCHAR)trackNumber;
|
|
outputBuffer->AbsoluteAddress[0] = 0;
|
|
outputBuffer->AbsoluteAddress[1] = timeAbsolute[0];
|
|
outputBuffer->AbsoluteAddress[2] = timeAbsolute[1];
|
|
outputBuffer->AbsoluteAddress[3] = timeAbsolute[2];
|
|
|
|
outputBuffer->TrackRelativeAddress[0] = 0;
|
|
outputBuffer->TrackRelativeAddress[1] = timeRelative[0];
|
|
outputBuffer->TrackRelativeAddress[2] = timeRelative[1];
|
|
outputBuffer->TrackRelativeAddress[3] = timeRelative[2];
|
|
|
|
//
|
|
// The one line debug info...
|
|
//
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctlV, "[redbook] "
|
|
"ReadQ => "
|
|
"Trk [%#02x] Indx [%#02x] "
|
|
"Abs [%#02d:%#02d.%#02d] Rel [%#02d:%#02d.%#02d]\n",
|
|
outputBuffer->TrackNumber,
|
|
trackNumber,
|
|
timeAbsolute[0], timeAbsolute[1], timeAbsolute[2],
|
|
timeRelative[0], timeRelative[1], timeRelative[2]));
|
|
|
|
}
|
|
//
|
|
// Complete the Irp
|
|
//
|
|
|
|
Context->Irp->IoStatus.Information = sizeof(SUB_Q_CURRENT_POSITION);
|
|
Context->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
RedBookDCResume(
|
|
PREDBOOK_DEVICE_EXTENSION DeviceExtension,
|
|
PREDBOOK_THREAD_IOCTL_DATA Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
ULONG state;
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
state = GetCdromState(DeviceExtension);
|
|
|
|
if (!TEST_FLAG(state, CD_PLAYING) && !TEST_FLAG(state, CD_PAUSED)) { // !handling ioctls
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCResume => Not Playing\n"));
|
|
RedBookCompleteIoctl(DeviceExtension, Context, TRUE);
|
|
return;
|
|
}
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCResume => Entering\n"));
|
|
|
|
if (TEST_FLAG(state, CD_PAUSED)) {
|
|
|
|
//
|
|
// we need to start the resume operation
|
|
//
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCResume => Resuming playback\n"));
|
|
state = SetCdromState(DeviceExtension, state, CD_PLAYING);
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCResume => Resume succeeded\n"));
|
|
|
|
} else {
|
|
|
|
//
|
|
// if not paused, return success
|
|
//
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCResume => Not paused -- succeeded\n"));
|
|
|
|
}
|
|
|
|
//
|
|
// always complete the Irp
|
|
//
|
|
|
|
Context->Irp->IoStatus.Information = 0;
|
|
Context->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
RedBookDCSeek(
|
|
PREDBOOK_DEVICE_EXTENSION DeviceExtension,
|
|
PREDBOOK_THREAD_IOCTL_DATA Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
same as a IOCTL_CDROM_STOP
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
ULONG state;
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCSeek => Entering\n"));
|
|
state = GetCdromState(DeviceExtension);
|
|
|
|
if (!TEST_FLAG(state, CD_PLAYING) && !TEST_FLAG(state, CD_PAUSED)) { // !handling ioctls
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCSeek => Not Playing\n"));
|
|
Context->Irp->IoStatus.Information = 0;
|
|
Context->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// stop the stream if currently playing
|
|
//
|
|
|
|
if (TEST_FLAG(state, CD_PAUSED)) {
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCSeek => Paused, setting to stopped\n"));
|
|
state = SetCdromState(DeviceExtension, state, CD_STOPPED);
|
|
Context->Irp->IoStatus.Information = 0;
|
|
Context->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// since setting to a temp state, it is not appropriate to
|
|
// complete the irp until the operation itself completes.
|
|
//
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCSeek => stopping the stream\n"));
|
|
DeviceExtension->Thread.IoctlCurrent = &Context->ListEntry;
|
|
state = SetCdromState(DeviceExtension, state, state | CD_STOPPING);
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
RedBookDCSetVolume(
|
|
PREDBOOK_DEVICE_EXTENSION DeviceExtension,
|
|
PREDBOOK_THREAD_IOCTL_DATA Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
PIO_STACK_LOCATION currentIrpStack;
|
|
ULONG state;
|
|
NTSTATUS status;
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCSetVolume => Entering\n"));
|
|
|
|
//
|
|
// guaranteed the volume info will not change right now
|
|
//
|
|
|
|
RtlCopyMemory(&DeviceExtension->CDRom.Volume, // to
|
|
Context->Irp->AssociatedIrp.SystemBuffer, // from
|
|
sizeof(VOLUME_CONTROL));
|
|
|
|
state = GetCdromState(DeviceExtension);
|
|
|
|
if (!TEST_FLAG(state, CD_PLAYING) && !TEST_FLAG(state, CD_PAUSED)) { // !handling ioctls
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCSetVolume => Not Playing\n"));
|
|
RedBookCompleteIoctl(DeviceExtension, Context, TRUE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// not set above since don't have volume control
|
|
//
|
|
|
|
RedBookKsSetVolume(DeviceExtension);
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctlV, "[redbook] "
|
|
"DCSetVolume => volume set to:"
|
|
" (hex) %2x %2x %2x %2x\n",
|
|
DeviceExtension->CDRom.Volume.PortVolume[0],
|
|
DeviceExtension->CDRom.Volume.PortVolume[1],
|
|
DeviceExtension->CDRom.Volume.PortVolume[2],
|
|
DeviceExtension->CDRom.Volume.PortVolume[3]));
|
|
|
|
//
|
|
// Complete the Irp (IoStatus.Information set above)
|
|
//
|
|
|
|
Context->Irp->IoStatus.Information = 0;
|
|
Context->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
RedBookDCStop(
|
|
PREDBOOK_DEVICE_EXTENSION DeviceExtension,
|
|
PREDBOOK_THREAD_IOCTL_DATA Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
ULONG state;
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCStop => Entering %p\n", Context->Irp));
|
|
state = GetCdromState(DeviceExtension);
|
|
|
|
if (!TEST_FLAG(state, CD_PLAYING) && !TEST_FLAG(state, CD_PAUSED)) { // !handling ioctls
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCStop => Stop when already stopped\n"));
|
|
Context->Irp->IoStatus.Information = 0;
|
|
Context->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Still playing audio. if paused, just call the stop finish routine
|
|
//
|
|
|
|
if (TEST_FLAG(state, CD_PAUSED)) {
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCStop => Stop when paused\n"));
|
|
state = SetCdromState(DeviceExtension, state, CD_STOPPED);
|
|
Context->Irp->IoStatus.Information = 0;
|
|
Context->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
RedBookCompleteIoctl(DeviceExtension, Context, FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// since setting to a temp state, it is not appropriate to
|
|
// complete the irp until the operation itself completes.
|
|
//
|
|
|
|
KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugIoctl, "[redbook] "
|
|
"DCStop => stopping the stream\n"));
|
|
DeviceExtension->Thread.IoctlCurrent = &Context->ListEntry;
|
|
state = SetCdromState(DeviceExtension, state, state | CD_STOPPING);
|
|
return;
|
|
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
VOID
|
|
RedBookCheckForDiscChangeAndFreeResources(
|
|
PREDBOOK_DEVICE_EXTENSION DeviceExtension
|
|
)
|
|
|
|
//
|
|
// if we've paused, and the disc has changed, don't
|
|
// want to be returning stale toc info when the player
|
|
// resumes playback.
|
|
//
|
|
|
|
{
|
|
PIRP irp;
|
|
PIO_STACK_LOCATION irpStack;
|
|
PULONG count;
|
|
ULONG state;
|
|
|
|
PAGED_CODE();
|
|
VerifyCalledByThread(DeviceExtension);
|
|
|
|
//
|
|
// only do this if we are in a PAUSED or STOPPED state
|
|
//
|
|
|
|
state = GetCdromState(DeviceExtension);
|
|
if ((!TEST_FLAG(state, CD_STOPPED)) &&
|
|
(!TEST_FLAG(state, CD_PAUSED))) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// resources might already be deallocated.
|
|
//
|
|
|
|
irp = DeviceExtension->Thread.CheckVerifyIrp;
|
|
if (irp == NULL) {
|
|
return;
|
|
}
|
|
|
|
irpStack = IoGetCurrentIrpStackLocation(irp);
|
|
|
|
#if DBG
|
|
{
|
|
//
|
|
// the irp must be setup when it's allocated. we rely on this.
|
|
//
|
|
|
|
ASSERT(irpStack->Parameters.DeviceIoControl.InputBufferLength == 0);
|
|
ASSERT(irpStack->Parameters.DeviceIoControl.OutputBufferLength ==
|
|
sizeof(ULONG));
|
|
ASSERT(irpStack->Parameters.DeviceIoControl.IoControlCode ==
|
|
IOCTL_CDROM_CHECK_VERIFY);
|
|
ASSERT(irpStack->Parameters.DeviceIoControl.Type3InputBuffer == NULL);
|
|
ASSERT(irp->AssociatedIrp.SystemBuffer != NULL);
|
|
}
|
|
#endif
|
|
|
|
count = (PULONG)(irp->AssociatedIrp.SystemBuffer);
|
|
*count = 0;
|
|
|
|
RedBookForwardIrpSynchronous(DeviceExtension, irp);
|
|
|
|
if (!NT_SUCCESS(irp->IoStatus.Status) ||
|
|
((*count) != DeviceExtension->CDRom.CheckVerify)
|
|
) {
|
|
|
|
//
|
|
// if the count has changed set the state to STOPPED.
|
|
// (old state is either STOPPED or PAUSED, so either one can
|
|
// seemlessly transition to the STOPPED state without any
|
|
// trouble.)
|
|
//
|
|
// also free currently held play resources
|
|
//
|
|
|
|
state = SetCdromState(DeviceExtension, state, CD_STOPPED);
|
|
RedBookDeallocatePlayResources(DeviceExtension);
|
|
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
ULONG
|
|
WhichTrackContainsThisLBA(
|
|
PCDROM_TOC Toc,
|
|
ULONG Lba
|
|
)
|
|
//
|
|
// returns -1 if not found
|
|
//
|
|
{
|
|
LONG trackNumber;
|
|
UCHAR msf[3] = {0};
|
|
|
|
PAGED_CODE();
|
|
|
|
LBA_TO_MSF(Lba, msf[0], msf[1], msf[2]);
|
|
|
|
for (trackNumber = Toc->LastTrack - Toc->FirstTrack;
|
|
trackNumber >= 0;
|
|
trackNumber-- ) {
|
|
|
|
//
|
|
// we have found the track if
|
|
// Minutes is less or
|
|
// Minutes is equal and Seconds is less or
|
|
// Minutes and Seconds are equal Frame is less or
|
|
// Minutes, Seconds, and Frame are equal
|
|
//
|
|
// the compiler optimizes this nicely.
|
|
//
|
|
|
|
if (Toc->TrackData[trackNumber].Address[1] < msf[0] ) {
|
|
break;
|
|
} else
|
|
if (Toc->TrackData[trackNumber].Address[1] == msf[0] &&
|
|
Toc->TrackData[trackNumber].Address[2] < msf[1] ) {
|
|
break;
|
|
} else
|
|
if (Toc->TrackData[trackNumber].Address[1] == msf[0] &&
|
|
Toc->TrackData[trackNumber].Address[2] == msf[1] &&
|
|
Toc->TrackData[trackNumber].Address[3] < msf[2] ) {
|
|
break;
|
|
} else
|
|
if (Toc->TrackData[trackNumber].Address[1] == msf[0] &&
|
|
Toc->TrackData[trackNumber].Address[2] == msf[1] &&
|
|
Toc->TrackData[trackNumber].Address[3] == msf[2] ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return trackNumber;
|
|
}
|
|
|
|
|