able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/wdm/dvd/mini/dxr2/adapter.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

2204 lines
58 KiB
C
Raw Blame History

/******************************************************************************\
* *
* ADAPTER.C - Adapter control related code. *
* *
* Copyright (c) C-Cube Microsystems 1996 - 1999 *
* All Rights Reserved. *
* *
* Use of C-Cube Microsystems code is governed by terms and conditions *
* stated in the accompanying licensing statement. *
* *
\******************************************************************************/
#include "Headers.h"
#pragma hdrstop
#include "vidstrm.h"
#include "audstrm.h"
#include "sbpstrm.h"
#include "ccaption.h"
#ifdef ENCORE
#include "avwinwdm.h"
#include "anlgstrm.h"
#else
#include "vpestrm.h"
#include "dataXfer.h"
#endif
#include "zivaguid.h"
#include "boardio.h"
#include "bmaster.h"
#include "cl6100.h"
#include "Hwif.h"
static VOID HwInitialize( IN PHW_STREAM_REQUEST_BLOCK pSrb );
static VOID HwUninitialize( IN PHW_STREAM_REQUEST_BLOCK pSrb );
static VOID AdapterOpenStream( PHW_STREAM_REQUEST_BLOCK pSrb );
static VOID AdapterCloseStream( PHW_STREAM_REQUEST_BLOCK pSrb );
static VOID AdapterStreamInfo( PHW_STREAM_REQUEST_BLOCK pSrb );
static VOID AdapterGetDataIntersection( PHW_STREAM_REQUEST_BLOCK pSrb );
static VOID BeginHwInitialize( IN PHW_STREAM_REQUEST_BLOCK pSrb );
static VOID HighPriorityInit( IN PHW_STREAM_REQUEST_BLOCK pSrb );
static VOID PassiveInit( IN PHW_STREAM_REQUEST_BLOCK pSrb );
static VOID HighPriorityInit( IN PHW_STREAM_REQUEST_BLOCK pSrb );
VOID STREAMAPI AdapterReleaseCurrentSrb( PHW_STREAM_REQUEST_BLOCK pSrb );
#pragma alloc_text( page, HwInitialize )
#pragma alloc_text( page, HwUninitialize )
#if 0
static void STREAMAPI CreateFile(PHW_STREAM_REQUEST_BLOCK pSrb );
OBJECT_ATTRIBUTES InitializedAttributes;
IO_STATUS_BLOCK IOStatusBlock;
HANDLE Handle;
WCHAR wPath[] = L"ohm.dat";
UNICODE_STRING pathUnicodeString;
LARGE_INTEGER AllocSize ;
long dwCountTotal=0;
#endif
PHW_DEVICE_EXTENSION pDevEx;
/******************************************************************************
Adapter Based Request Handling Routines
******************************************************************************/
/*
** AdapterReceivePacket()
**
** Main entry point for receiving adapter based request SRBs. This routine
** will always be called at High Priority.
**
** Note: This is an asyncronous entry point. The request does not complete
** on return from this function, the request only completes when a
** StreamClassDeviceNotification on this request block, of type
** DeviceRequestComplete, is issued.
**
** Arguments:
**
** pSrb - Pointer to the STREAM_REQUEST_BLOCK
** pSrb->HwDeviceExtension - will be the hardware device extension for
** as initialised in HwInitialise
**
** Returns:
**
** Side Effects: none
*/
VOID STREAMAPI AdapterReceivePacket( IN PHW_STREAM_REQUEST_BLOCK pSrb )
{
PHW_DEVICE_EXTENSION pHwDevExt = (PHW_DEVICE_EXTENSION)pSrb->CommandData.ConfigInfo->HwDeviceExtension;
DebugPrint(( DebugLevelVerbose, "ZiVA: Begin AdapterReceivePacket->" ));
#ifdef DEBUG
if( KeGetCurrentIrql() <= DISPATCH_LEVEL )
{
DebugPrint(( DebugLevelError, "IRQL is screwed!\n" ));
ASSERT( FALSE );
MonoOutSetBlink( TRUE );
MonoOutStr( "IRQL" );
MonoOutSetBlink( FALSE );
}
#endif
switch( pSrb->Command )
{
case SRB_INITIALIZE_DEVICE:
DebugPrint(( DebugLevelVerbose, "SRB_INITIALIZE_DEVICE\n" ));
// HwInitialize( pSrb );
// break;
BeginHwInitialize( pSrb ); //MS update
return;
case SRB_UNINITIALIZE_DEVICE:
DebugPrint(( DebugLevelVerbose, "SRB_UNINITIALIZE_DEVICE\n" ));
HwUninitialize( pSrb );
break;
case SRB_OPEN_STREAM:
DebugPrint(( DebugLevelVerbose, "SRB_OPEN_STREAM\n" ));
AdapterOpenStream( pSrb );
break;
case SRB_CLOSE_STREAM:
DebugPrint(( DebugLevelVerbose, "SRB_CLOSE_STREAM\n" ));
AdapterCloseStream( pSrb );
break;
case SRB_GET_STREAM_INFO:
DebugPrint(( DebugLevelVerbose, "SRB_GET_STREAM_INFO\n" ));
AdapterStreamInfo( pSrb );
break;
case SRB_GET_DATA_INTERSECTION:
DebugPrint(( DebugLevelVerbose, "SRB_GET_DATA_INTERSECTION\n" ));
AdapterGetDataIntersection( pSrb );
break;
case SRB_GET_DEVICE_PROPERTY:
AdapterGetProperty( pSrb );
MonoOutStr("SRB_GET_DEVICE_PROPERTY");
break;
case SRB_SET_DEVICE_PROPERTY:
AdapterSetProperty( pSrb );
MonoOutStr("SRB_SET_DEVICE_PROPERTY");
break;
case SRB_CHANGE_POWER_STATE:
DebugPrint(( DebugLevelVerbose, "SRB_CHANGE_POWER_STATE\n" ));
#if defined(DECODER_DVDPC)
if (pSrb->CommandData.DeviceState == PowerDeviceD0)
{
//
// bugbug - need to turn power back on here.
//
// Vinod.
//sri ZivaHw_Initialize(pHwDevExt);
// Commented for bug fix on GateWay Chameleon
}
else
{
//
// bugbug - need to turn power off here, as well as disabling
// interrupts.
//
//DisableIT();
}
#endif
pSrb->Status = STATUS_SUCCESS;
break;
case SRB_PAGING_OUT_DRIVER:
DebugPrint(( DebugLevelVerbose, "SRB_PAGING_OUT_DRIVER\n" ));
//TRAP
//DisableIT();
pSrb->Status = STATUS_SUCCESS;
break;
default:
DebugPrint(( DebugLevelInfo, "!!!! UNKNOWN COMMAND !!!! :::> %X\n", pSrb->Command ));
// This is a request that we do not understand. Indicate invalid
// command and complete the request
pSrb->Status = STATUS_NOT_IMPLEMENTED;
}
AdapterReleaseRequest( pSrb );
DebugPrint(( DebugLevelVerbose, "ZiVA: End AdapterReceivePacket\n" ));
}
/******************************************************************************/
/******************* Adapter Initialization Section *************************/
/******************************************************************************/
/*
** BeginHwInitialize()
**
** Stub for the init sequence
**
** Arguments:
**
** pSRB - pointer to the request packet for the initialise command
**
** ->ConfigInfo - provides the I/O port, memory windows, IRQ, and DMA levels
** that should be used to access this instance of the device
**
** Returns:
**
**
**
** Side Effects: none
*/
static VOID BeginHwInitialize( IN PHW_STREAM_REQUEST_BLOCK pSrb )
{
PPORT_CONFIGURATION_INFORMATION ConfigInfo = pSrb->CommandData.ConfigInfo;
PHW_DEVICE_EXTENSION pHwDevExt = (PHW_DEVICE_EXTENSION)ConfigInfo->HwDeviceExtension;
DebugPrint(( DebugLevelVerbose, "ZiVA: BeginHwInitialize()\n" ));
StreamClassCallAtNewPriority(NULL, pHwDevExt, Low, PassiveInit, pSrb);
return;
}
/*
** PassiveInit()
**
** Passive level callback for the init sequence
**
** Arguments:
**
** pSRB - pointer to the request packet for the initialise command
**
** ->ConfigInfo - provides the I/O port, memory windows, IRQ, and DMA levels
** that should be used to access this instance of the device
**
** Returns:
**
**
**
** Side Effects: none
*/
static VOID PassiveInit( IN PHW_STREAM_REQUEST_BLOCK pSrb )
{
PPORT_CONFIGURATION_INFORMATION ConfigInfo = pSrb->CommandData.ConfigInfo;
PHW_DEVICE_EXTENSION pHwDevExt = (PHW_DEVICE_EXTENSION)ConfigInfo->HwDeviceExtension;
InitializeHost(pSrb);
StreamClassCallAtNewPriority(NULL, pHwDevExt, LowToHigh, HighPriorityInit, pSrb);
return;
}
/*
** HighPriorityInit()
**
** High priority callback for the init sequence
**
** Arguments:
**
** pSRB - pointer to the request packet for the initialise command
**
** ->ConfigInfo - provides the I/O port, memory windows, IRQ, and DMA levels
** that should be used to access this instance of the device
**
** Returns:
**
**
**
** Side Effects: none
*/
static VOID HighPriorityInit( IN PHW_STREAM_REQUEST_BLOCK pSrb )
{
HwInitialize(pSrb);
AdapterReleaseRequest( pSrb );
}
/*
** HwInitialize()
**
** Initializes an adapter accessed through the information provided in the
** ConfigInfo structure
**
** Arguments:
**
** pSRB - pointer to the request packet for the initialise command
**
** ->ConfigInfo - provides the I/O port, memory windows, IRQ, and DMA levels
** that should be used to access this instance of the device
**
** Returns:
**
** STATUS_SUCCESS - if the card initializes correctly
** STATUS_NO_SUCH_DEVICE - or other if the card is not found, or does
** not initialize correctly.
**
**
** Side Effects: none
*/
static VOID HwInitialize( IN PHW_STREAM_REQUEST_BLOCK pSrb )
{
PPORT_CONFIGURATION_INFORMATION ConfigInfo = pSrb->CommandData.ConfigInfo;
PHW_DEVICE_EXTENSION pHwDevExt = (PHW_DEVICE_EXTENSION)ConfigInfo->HwDeviceExtension;
ULONG dwSize;
DebugPrint(( DebugLevelVerbose, "ZiVA: Begin HwInitialize()\n" ));
// InitializeHost(pSrb);
pHwDevExt->bVideoStreamOpened = FALSE;
pHwDevExt->bAudioStreamOpened = FALSE;
pHwDevExt->bSubPictureStreamOpened = FALSE;
pHwDevExt->bOverlayInitialized = FALSE;
pHwDevExt->nAnalogStreamOpened = 0;
pHwDevExt->iTotalOpenedStreams = 0;
pHwDevExt->bVideoCanAuthenticate = FALSE;
pHwDevExt->bAudioCanAuthenticate = FALSE;
pHwDevExt->bSubPictureCanAuthenticate = FALSE;
pHwDevExt->iStreamToAuthenticateOn = -1;
pHwDevExt->bValidSPU = FALSE;
pHwDevExt->hli.StartPTM = 0;
pHwDevExt->pCurrentVideoSrb = NULL;
pHwDevExt->dwCurrentVideoSample = 0;
pHwDevExt->pCurrentAudioSrb = NULL;
pHwDevExt->dwCurrentAudioSample = 0;
pHwDevExt->pCurrentSubPictureSrb = NULL;
pHwDevExt->dwCurrentSubPictureSample = 0;
pHwDevExt->CurrentlySentStream = ZivaNumberOfStreams; // Just make sure it is none of them
pHwDevExt->wNextSrbOrderNumber = 0;
pHwDevExt->bInterruptPending = FALSE;
pHwDevExt->bPlayCommandPending = FALSE;
pHwDevExt->bScanCommandPending = FALSE;
pHwDevExt->bSlowCommandPending = FALSE;
pHwDevExt->nStopCount = 0;
pHwDevExt->nPauseCount = 0;
pHwDevExt->nPlayCount = 0;
pHwDevExt->nTimeoutCount = AUTHENTICATION_TIMEOUT_COUNT;
pHwDevExt->NewRate = 10000;
pHwDevExt->bToBeDiscontinued = FALSE;
pHwDevExt->bDiscontinued = FALSE;
pHwDevExt->bAbortAtPause = FALSE;
pHwDevExt->bRateChangeFromSlowMotion = FALSE;
pHwDevExt->dwVideoDataUsed =0;
pHwDevExt->dwAudioDataUsed =0;
pHwDevExt->dwSubPictureDataUsed =0;
pHwDevExt->bEndFlush = FALSE;
pHwDevExt->bTimerScheduled = FALSE;
pHwDevExt->dwCurrentVideoPage = 0;
pHwDevExt->dwCurrentAudioPage = 0;
pHwDevExt->dwCurrentSubPicturePage = 0;
pHwDevExt->bStreamNumberCouldBeChanged = FALSE;
pHwDevExt->wCurrentStreamNumber = -1;
pHwDevExt->bSwitchDecryptionOn = FALSE;
pHwDevExt->zInitialState = ZIVA_STATE_STOP;
pHwDevExt->bHliPending = FALSE;
pHwDevExt->gdwCount = 0;
pHwDevExt->dwFirstVideoOrdNum = -1;
pHwDevExt->dwFirstAudioOrdNum = -1;
pHwDevExt->dwFirstSbpOrdNum = -1;
pHwDevExt->dwVSyncCount =0;
pHwDevExt->nApsMode = -1;
pHwDevExt->VidSystem = -1;
pHwDevExt->ulLevel =0;
pHwDevExt->fAtleastOne = TRUE;
pHwDevExt->dwPrevSTC = 0;
pHwDevExt->bTrickModeToPlay =FALSE;
pHwDevExt->prevStrm =0;
pHwDevExt->fFirstSTC = FALSE;
pHwDevExt->cCCRec=0;
pHwDevExt->cCCDeq=0;
pHwDevExt->cCCCB=0;
pHwDevExt->cCCQ=0;
pHwDevExt->pstroCC = NULL;
pHwDevExt->dwUserDataSize=0;
pHwDevExt->fReSync = FALSE;
pHwDevExt->bInitialized = TRUE;
pDevEx = pHwDevExt ;
pHwDevExt->pPhysicalDeviceObj = ConfigInfo->PhysicalDeviceObject;
pHwDevExt->pDiscKeyBufferLinear = (PUCHAR)StreamClassGetDmaBuffer( pHwDevExt );
pHwDevExt->pDiscKeyBufferPhysical = StreamClassGetPhysicalAddress(
pHwDevExt,
NULL,
pHwDevExt->pDiscKeyBufferLinear,
DmaBuffer,
&dwSize );
// Indicate the size of the structure necessary to describe all streams
// that are supported by this hardware
ConfigInfo->StreamDescriptorSize = sizeof( HW_STREAM_HEADER )+ // Stream header and
ZivaNumberOfStreams * sizeof( HW_STREAM_INFORMATION ); // stream descriptors
pHwDevExt->pCCDevEx = pHwDevExt;
pSrb->Status = STATUS_SUCCESS;
#if defined (LOAD_UCODE_FROM_FILE)
// Do nothing.
#else
if( !ZivaHw_Initialize( pHwDevExt ) || !InitializeOutputStream( pSrb ))
pSrb->Status = STATUS_IO_DEVICE_ERROR;
#endif
DebugPrint(( DebugLevelVerbose, "ZiVA: End HwInitialize()\n" ));
}
/*
** HwUninitialize()
**
** Release all resources and clean up the hardware
**
** Arguments:
**
** DeviceExtension - pointer to the deviceextension structure for the
** the device to be free'd
**
** Returns:
**
** Side Effects: none
*/
static VOID HwUninitialize( IN PHW_STREAM_REQUEST_BLOCK pSrb )
{
DebugPrint(( DebugLevelVerbose, "ZiVA: Begin HwUninitialize()\n" ));
#ifdef ENCORE
AnalogUninitialize( pSrb );
#else
pSrb->Status = STATUS_SUCCESS;
#endif
DebugPrint(( DebugLevelVerbose, "ZiVA: End HwUninitialize()\n" ));
}
/*
** AdapterOpenStream()
**
** This routine is called when an OpenStream SRB request is received
**
** Arguments:
**
** pSrb - pointer to stream request block for the Open command
**
** Returns:
**
** Side Effects: none
*/
static VOID AdapterOpenStream( PHW_STREAM_REQUEST_BLOCK pSrb )
{
int i;
PHW_DEVICE_EXTENSION pHwDevExt = (PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension;
DebugPrint(( DebugLevelVerbose, "ZiVA: Begin AdapterOpenStream\n" ));
pSrb->Status = STATUS_TOO_MANY_NODES;
for( i = 0; i < SIZEOF_ARRAY( infoStreams ); i++ )
{
if( infoStreams[i].hwStreamObject.StreamNumber == pSrb->StreamObject->StreamNumber )
{ // This is the stream we're interested in.
// Then copy stream object structure into passed buffer
PVOID pHwStreamExtension = pSrb->StreamObject->HwStreamExtension;
*(pSrb->StreamObject) = infoStreams[i].hwStreamObject;
pSrb->StreamObject->HwStreamExtension = pHwStreamExtension;
pSrb->StreamObject->HwDeviceExtension = pHwDevExt;
pSrb->Status = STATUS_SUCCESS;
break;
}
}
if( pSrb->Status == STATUS_SUCCESS )
{
++pHwDevExt->iTotalOpenedStreams;
++pHwDevExt->nStopCount;
++pHwDevExt->nPauseCount;
++pHwDevExt->nPlayCount;
switch( pSrb->StreamObject->StreamNumber )
{
case ZivaVideo:
pHwDevExt->bVideoStreamOpened = TRUE;
#if defined(DECODER_DVDPC) || defined(EZDVD)
ProcessVideoFormat( pSrb->CommandData.OpenFormat, pHwDevExt );
#endif
break;
case ZivaAudio:
pHwDevExt->bAudioStreamOpened = TRUE;
pHwDevExt->pstroAud = pSrb->StreamObject;
break;
case ZivaSubpicture:
pHwDevExt->bSubPictureStreamOpened = TRUE;
break;
#ifdef ENCORE
case ZivaAnalog:
++pHwDevExt->nAnalogStreamOpened;
AnalogOpenStream( pSrb );
break;
#endif
#if defined(DECODER_DVDPC) || defined(EZDVD)
case ZivaYUV:
pHwDevExt->pstroYUV = pSrb->StreamObject;
pSrb->StreamObject->HwEventRoutine = (PHW_EVENT_ROUTINE) CycEvent;
break;
#endif
case ZivaCCOut:
pHwDevExt->pstroCC = pSrb->StreamObject;
break;
default:
ASSERT( FALSE );
}
}
else
DebugPrint(( DebugLevelWarning, "ZiVA: !!! Strange Stream Number\n" ));
if ( pHwDevExt->iTotalOpenedStreams == 1 )
{
pHwDevExt->dwVideoDataUsed = 0;
pHwDevExt->dwAudioDataUsed = 0;
pHwDevExt->dwSubPictureDataUsed = 0;
pHwDevExt->bStreamNumberCouldBeChanged = FALSE;
pHwDevExt->wCurrentStreamNumber = -1;
pHwDevExt->bSwitchDecryptionOn = FALSE;
pHwDevExt->zInitialState = ZIVA_STATE_STOP;
pHwDevExt->bEndFlush = FALSE;
pHwDevExt->bTimerScheduled = FALSE;
if ( !ZivaHw_Initialize( pHwDevExt ) )
{
DebugPrint((DebugLevelFatal,"ZiVA: Could not Initialize the HW on first Stream Open\n"));
pSrb->Status = STATUS_NOT_IMPLEMENTED;
}
}
DebugPrint(( DebugLevelVerbose, "ZiVA: End AdapterOpenStream\n" ));
}
/*
** AdapterCloseStream()
**
** Close the requested data stream
**
** Arguments:
**
** pSrb the request block requesting to close the stream
**
** Returns:
**
** Side Effects: none
*/
static VOID AdapterCloseStream( PHW_STREAM_REQUEST_BLOCK pSrb )
{
PHW_DEVICE_EXTENSION pHwDevExt = (PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension;
DebugPrint(( DebugLevelVerbose, "ZiVA: Begin AdapterCloseStream\n" ));
pSrb->Status = STATUS_SUCCESS;
ASSERT( pHwDevExt->nStopCount == pHwDevExt->iTotalOpenedStreams );
ASSERT( pHwDevExt->nPauseCount == pHwDevExt->iTotalOpenedStreams );
ASSERT( pHwDevExt->nPlayCount == pHwDevExt->iTotalOpenedStreams );
--pHwDevExt->iTotalOpenedStreams;
--pHwDevExt->nStopCount;
--pHwDevExt->nPauseCount;
--pHwDevExt->nPlayCount;
// Determine which stream number is being closed. This number indicates
// the offset into the array of streaminfo structures that was filled out
// in the AdapterStreamInfo call.
switch( pSrb->StreamObject->StreamNumber )
{
case ZivaVideo:
pHwDevExt->bVideoStreamOpened = FALSE;
break;
case ZivaAudio:
pHwDevExt->bAudioStreamOpened = FALSE;
pHwDevExt->pstroAud = NULL;
break;
case ZivaSubpicture:
pHwDevExt->bSubPictureStreamOpened = FALSE;
break;
#ifdef ENCORE
case ZivaAnalog:
--pHwDevExt->nAnalogStreamOpened;
AnalogCloseStream( pSrb );
break;
#endif
#if defined(DECODER_DVDPC) || defined(EZDVD)
case ZivaYUV:
pHwDevExt->pstroYUV = NULL;
pHwDevExt->VideoPort = 0; // Disable
break;
#endif
case ZivaCCOut:
CleanCCQueue(pHwDevExt);
pHwDevExt->pstroCC = NULL;
break;
default:
++pHwDevExt->iTotalOpenedStreams;
++pHwDevExt->nStopCount;
++pHwDevExt->nPauseCount;
++pHwDevExt->nPlayCount;
DebugPrint(( DebugLevelWarning, "ZiVA: !!! Strange Stream Number\n" ));
ASSERT( FALSE );
pSrb->Status = STATUS_NOT_IMPLEMENTED;
//TRAP
}
//
// Reset the Authenticated Stream if anyone is being closed
//
pHwDevExt->iStreamToAuthenticateOn = -1;
//
// Reset the HW on last Stream Close
//
if( pHwDevExt->iTotalOpenedStreams == 0 )
{
pHwDevExt->wNextSrbOrderNumber = 0;
// Make sure next Authentication request will be postponed
// until "last packet" flag has come on each stream.
AdapterClearAuthenticationStatus( pHwDevExt );
// Clean up the hardware
if( !ZivaHw_Reset() )
{
DebugPrint(( DebugLevelError, "ZiVA: Could not Reset the HW on last Stream Closed\n" ));
pSrb->Status = STATUS_IO_DEVICE_ERROR;
}
#if defined(ENCORE)
else
AnalogCloseStream( pSrb );
#endif
}
#ifdef DEBUG
if( pHwDevExt->iTotalOpenedStreams < 0 )
DebugPrint(( DebugLevelWarning, "ZiVA: !!!!!!!!!!!!!!!!!! Open/Close streams mismatch !!!!!!!!!!!!!!!!\n" ));
#endif
DebugPrint(( DebugLevelVerbose, "ZiVA: End AdapterCloseStream\n" ));
}
void AdapterInitLocals(PHW_DEVICE_EXTENSION pHwDevExt)
{
pHwDevExt->pCurrentVideoSrb = NULL;
pHwDevExt->dwCurrentVideoSample = 0;
pHwDevExt->pCurrentAudioSrb = NULL;
pHwDevExt->dwCurrentAudioSample = 0;
pHwDevExt->pCurrentSubPictureSrb = NULL;
pHwDevExt->dwCurrentSubPictureSample = 0;
pHwDevExt->CurrentlySentStream = ZivaNumberOfStreams; // Just make sure it is none of them
pHwDevExt->bInterruptPending = FALSE;
pHwDevExt->bPlayCommandPending = FALSE;
pHwDevExt->bScanCommandPending = FALSE;
pHwDevExt->bSlowCommandPending = FALSE;
pHwDevExt->bHliPending = FALSE;
pHwDevExt->NewRate = 10000;
pHwDevExt->dwVideoDataUsed = 0;
pHwDevExt->dwCurrentVideoPage = 0;
pHwDevExt->dwCurrentAudioPage = 0;
pHwDevExt->dwCurrentSubPicturePage = 0;
pHwDevExt->dwAudioDataUsed = 0;
pHwDevExt->dwSubPictureDataUsed = 0;
pHwDevExt->bToBeDiscontinued = FALSE;
pHwDevExt->bDiscontinued = FALSE;
pHwDevExt->bAbortAtPause = FALSE;
pHwDevExt->bRateChangeFromSlowMotion = FALSE;
pHwDevExt->gdwCount = 0;
pHwDevExt->dwFirstVideoOrdNum = -1;
pHwDevExt->dwFirstAudioOrdNum = -1;
pHwDevExt->dwFirstSbpOrdNum = -1;
pHwDevExt->dwVSyncCount =0;
pHwDevExt->nApsMode = -1;
pHwDevExt->VidSystem = -1;
pHwDevExt->ulLevel =0;
pHwDevExt->fAtleastOne = TRUE;
//temp pHwDevExt->dwPrevSTC = 0;
pHwDevExt->bTrickModeToPlay =FALSE;
pHwDevExt->prevStrm =0;
pHwDevExt->fFirstSTC = TRUE;
pHwDevExt->cCCRec=0;
pHwDevExt->cCCDeq=0;
pHwDevExt->cCCCB=0;
pHwDevExt->cCCQ=0;
// pHwDevExt->pstroCC = NULL;
// pHwDevExt->dwUserDataBuffer[]={0};
pHwDevExt->dwUserDataSize=0;
pHwDevExt->fReSync = FALSE;
CleanCCQueue(pHwDevExt);
#ifdef EZDVD
ZivaHw_Initialize(pHwDevExt);
#endif
}
/*
** AdapterStreamInfo()
**
** Returns the information of all streams that are supported by the
** mini-driver
**
** Arguments:
**
** pSrb - Pointer to the STREAM_REQUEST_BLOCK
** pSrb->HwDeviceExtension - will be the hardware device extension for
** as initialised in HwInitialise
**
** Returns:
**
** Side Effects: none
*/
static VOID AdapterStreamInfo( PHW_STREAM_REQUEST_BLOCK pSrb )
{
int i;
PHW_DEVICE_EXTENSION pdevext = (PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension;
PHW_STREAM_HEADER pStrHdr = &(pSrb->CommandData.StreamBuffer->StreamHeader);
PHW_STREAM_INFORMATION pstrinfo = &(pSrb->CommandData.StreamBuffer->StreamInfo);
DebugPrint(( DebugLevelVerbose, "ZiVA: Begin AdapterStreamInfo\n" ));
// Fill stream header structure
pStrHdr->NumberOfStreams = ZivaNumberOfStreams;
pStrHdr->SizeOfHwStreamInformation = sizeof( HW_STREAM_INFORMATION );
pStrHdr->Topology = (PKSTOPOLOGY)&Topology;
#ifdef ENCORE
pStrHdr->NumDevPropArrayEntries = SIZEOF_ARRAY( psEncore );
pStrHdr->DevicePropertiesArray = (PKSPROPERTY_SET)psEncore;
#else
pStrHdr->NumDevPropArrayEntries = 0;
pStrHdr->DevicePropertiesArray = NULL;
#endif
for( i = 0; i < SIZEOF_ARRAY( infoStreams ); i++, pstrinfo++ )
{ // Copy stream information structure into passed buffer
*pstrinfo = infoStreams[i].hwStreamInfo;
}
pSrb->Status = STATUS_SUCCESS;
DebugPrint(( DebugLevelVerbose, "ZiVA: End AdapterStreamInfo\n" ));
}
/*
** AdapterGetDataIntersection()
**
**
**
** Arguments:
**
**
**
** Returns:
**
** Side Effects:
*/
static VOID AdapterGetDataIntersection( PHW_STREAM_REQUEST_BLOCK pSrb )
{
PSTREAM_DATA_INTERSECT_INFO IntersectInfo = pSrb->CommandData.IntersectInfo;
PKSDATARANGE DataRange = IntersectInfo->DataRange;
PKSDATAFORMAT* pFormat;
ULONG i, formatSize;
if( IntersectInfo->StreamNumber >= ZivaNumberOfStreams )
{ // Incorrect stream number
pSrb->Status = STATUS_NOT_IMPLEMENTED;
return;
}
pSrb->Status = STATUS_NO_MATCH;
#if defined (ENCORE)
if( IntersectInfo->StreamNumber == ZivaAnalog )
{
PKSDATAFORMAT pFrmt = (PKSDATAFORMAT)&ZivaFormatAnalogOverlayOut;
pFormat = &pFrmt;
}
/* else if(IntersectInfo->StreamNumber == ZivaCCOut)
{
// *pFormat = &hwfmtiCCOut;
// formatSize = sizeof hwfmtiCCOut;
MonoOutStr("CCOut");
pFormat = infoStreams[IntersectInfo->StreamNumber].hwStreamInfo.StreamFormatsArray;
}*/
else
#endif
pFormat = infoStreams[IntersectInfo->StreamNumber].hwStreamInfo.StreamFormatsArray;
for( i = 0; i < infoStreams[IntersectInfo->StreamNumber].hwStreamInfo.NumberOfFormatArrayEntries;
pFormat++, i++ )
{ // Check format
formatSize = (*pFormat)->FormatSize;
#if defined (ENCORE)
if( IntersectInfo->StreamNumber != ZivaAnalog && DataRange->FormatSize != formatSize )
continue;
#endif
if( IsEqualGUID( &DataRange->MajorFormat, &((*pFormat)->MajorFormat) ) &&
IsEqualGUID( &DataRange->SubFormat, &((*pFormat)->SubFormat) ) &&
IsEqualGUID( &DataRange->Specifier, &((*pFormat)->Specifier) ) )
{
pSrb->Status = STATUS_SUCCESS;
break;
}
}
if( pSrb->Status != STATUS_SUCCESS )
return;
// Check to see if the size of the passed in buffer is a ULONG.
// if so, this indicates that we are to return only the size
// needed, and not return the actual data.
if( IntersectInfo->SizeOfDataFormatBuffer != sizeof( ULONG ) )
{ //
// we are to copy the data, not just return the size
//
if( IntersectInfo->SizeOfDataFormatBuffer < formatSize )
pSrb->Status = STATUS_BUFFER_TOO_SMALL;
else
{
RtlCopyMemory( IntersectInfo->DataFormatBuffer, *pFormat, formatSize );
pSrb->ActualBytesTransferred = formatSize;
pSrb->Status = STATUS_SUCCESS;
}
}
else // if sizeof ULONG specified
{
// Caller wants just the size of the buffer. Get that.
*(PULONG)IntersectInfo->DataFormatBuffer = formatSize;
pSrb->ActualBytesTransferred = sizeof( ULONG );
} // if sizeof ULONG
}
VOID STREAMAPI adapterUpdateNextSrbOrderNumberOnDiscardSrb( PHW_STREAM_REQUEST_BLOCK pSrb )
{
PHW_DEVICE_EXTENSION pHwDevExt = (PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension;
ULONG ulSample;
KSSTREAM_HEADER * pHeader;
WORD wMaxDiscardedOrderNumber = 0;
for( ulSample = 0; ulSample < pSrb->NumberOfBuffers; ulSample++ )
{
pHeader = ((PKSSTREAM_HEADER)pSrb->CommandData.DataBufferArray) + ulSample;
wMaxDiscardedOrderNumber = max( (WORD)((pHeader->TypeSpecificFlags) >> 16), wMaxDiscardedOrderNumber );
}
if ( wMaxDiscardedOrderNumber >= pHwDevExt->wNextSrbOrderNumber )
{
pHwDevExt->wNextSrbOrderNumber = wMaxDiscardedOrderNumber + 1;
MonoOutStr( "<<< Updating NextSrbOrderNumber to " );
MonoOutULong( pHwDevExt->wNextSrbOrderNumber );
MonoOutStr( " >>>" );
}
return ;
}
/*
** MoveToNextSample()
**
** This routine is being called when there is a need to move
** to the next Sample(buffer) in the current Srb.
**
** Arguments:
** pSrb - the request block to advance Sample Number.
**
** Returns:
** TRUE - Successfuly moved to next Sample
** FALSE - There was no more samples and current Srb was released
**
** Side Effects: unknown
*/
BOOLEAN STREAMAPI MoveToNextSample( PHW_STREAM_REQUEST_BLOCK pSrb )
{
PHW_DEVICE_EXTENSION pHwDevExt = (PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension;
DWORD* pdwCurrentSrbSample;
DWORD* pdwCurrentSrbPage;
switch( pSrb->StreamObject->StreamNumber )
{
case ZivaVideo:
pdwCurrentSrbSample = &pHwDevExt->dwCurrentVideoSample;
pdwCurrentSrbPage = &pHwDevExt->dwCurrentVideoPage;
break;
case ZivaAudio:
pdwCurrentSrbSample = &pHwDevExt->dwCurrentAudioSample;
pdwCurrentSrbPage = &pHwDevExt->dwCurrentAudioPage;
break;
case ZivaSubpicture:
pdwCurrentSrbSample = &pHwDevExt->dwCurrentSubPictureSample;
pdwCurrentSrbPage = &pHwDevExt->dwCurrentSubPicturePage;
break;
default:
MonoOutStr( "!!!!!!!!!!!!!!!!!!! WRONG STREAM # IN MoveToNextSample ROUTINE !!!!!!!!!!!!!!!!!!!!!!!!!!!" );
return FALSE;
}
// if(dwDataUsed == 0)
// {
(*pdwCurrentSrbSample)++;
// pHwDevExt->wNextSrbOrderNumber++;
// }
(*pdwCurrentSrbPage)++;
if( *pdwCurrentSrbSample >= pSrb->NumberOfBuffers)
{
if( *pdwCurrentSrbSample > pSrb->NumberOfBuffers )
{
MonoOutSetBlink( TRUE );
MonoOutStr( "<<< Current sample number is higher than the number of buffers >>>" );
MonoOutSetBlink( FALSE );
}
// MonoOutStr("MoveToNextSample()::RSRB");
AdapterReleaseCurrentSrb( pSrb );
return FALSE;
}
return TRUE;
}
VOID CancelPacket( PHW_STREAM_REQUEST_BLOCK pSrb, BOOL bCancel )
{
PHW_DEVICE_EXTENSION pHwDevExt = (PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension;
ULONG ulSample;
PKSSTREAM_HEADER pHeader;
WORD wMaxOrder = 0, wMinOrder = 0xFFFF;
#ifdef DEBUG
LPSTR pszFuncString, pszPacketString = NULL;
pszFuncString = bCancel ? "Cancel" : "Timeout";
DebugPrint(( DebugLevelVerbose,"ZiVA: Adapter%sPacket ->", pszFuncString ));
MonoOutSetUnderscore( TRUE );
MonoOutChar( ' ' );
MonoOutStr( pszFuncString );
MonoOutStr( "->" );
#endif
if( !(pSrb->Flags & SRB_HW_FLAGS_DATA_TRANSFER) )
{
DebugPrint(( DebugLevelVerbose," As a Control\n" ));
MonoOutStr( "(Control or Device)" );
AdapterReleaseRequest( pSrb );
return;
}
// We need to find this packet, pull it off our queues, and cancel it
// Try to find this Srb in the Pending List. If it's there just
// empty the slot
if(bCancel)
{
if( pHwDevExt->pCurrentVideoSrb == pSrb )
{
#ifdef DEBUG
pszPacketString = "Video";
#endif
pHwDevExt->pCurrentVideoSrb = NULL;
pHwDevExt->dwCurrentVideoSample = 0;
pHwDevExt->dwCurrentVideoPage = 0;
pHwDevExt->dwVideoDataUsed =0;
}
else if( pHwDevExt->pCurrentAudioSrb == pSrb )
{
#ifdef DEBUG
pszPacketString = "Audio";
#endif
pHwDevExt->pCurrentAudioSrb = NULL;
pHwDevExt->dwCurrentAudioSample = 0;
pHwDevExt->dwCurrentAudioPage = 0;
pHwDevExt->dwAudioDataUsed = 0;
}
else if( pHwDevExt->pCurrentSubPictureSrb == pSrb )
{
#ifdef DEBUG
pszPacketString = "Subpicture";
#endif
pHwDevExt->pCurrentSubPictureSrb = NULL;
pHwDevExt->dwCurrentSubPictureSample = 0;
pHwDevExt->dwCurrentSubPicturePage = 0;
pHwDevExt->dwSubPictureDataUsed = 0;
}
}
else //added 11/6/98
{
if( pHwDevExt->bInterruptPending )
MoveToNextSample( pSrb );
}
#ifdef DEBUG
if( pszPacketString )
{
DebugPrint(( DebugLevelVerbose, pszPacketString ));
MonoOutStr( pszPacketString );
}
#endif
// Reset the HW if it was the currently sending Srb.
// It usually means that hardware messed up so we'll schedule "play",
// "slow motion" or "scan" commands if one of them was in effect, reset
// hardware and cancel this packet
if( pHwDevExt->CurrentlySentStream == (ZIVA_STREAM)pSrb->StreamObject->StreamNumber )
{
ZIVA_STATE zState;
DebugPrint(( DebugLevelVerbose, "Current" ));
MonoOutStr( " Current Strm# " );
MonoOutInt( pSrb->StreamObject->StreamNumber );
// This request is in a middle of a Bus Master transferring and most likely
// that the interrupt is pending. If so we have to reset the
// Bus Master device.
if( pHwDevExt->bInterruptPending )
{
pHwDevExt->bInterruptPending = FALSE;
MonoOutStr( " Cancel pending interrupt" );
}
// Lets do a clean start (Abort->Play) for the upcoming stream
zState = ZivaHw_GetState();
if( zState != ZIVA_STATE_STOP )
{
MonoOutStr( " Aborting" );
if( !ZivaHw_Abort() )
ZivaHw_Reset();
pHwDevExt->bInterruptPending = FALSE;
pHwDevExt->bScanCommandPending = TRUE;
}
// Clean the CurrentlySentStream
pHwDevExt->CurrentlySentStream = ZivaNumberOfStreams;
}
if(bCancel)
pSrb->Status = STATUS_CANCELLED;
// It is necessary to call the request back correctly. Determine which type of
// command it is and then find all stream commands, and do stream notifications
switch( pSrb->Flags & (SRB_HW_FLAGS_DATA_TRANSFER | SRB_HW_FLAGS_STREAM_REQUEST) )
{
case SRB_HW_FLAGS_STREAM_REQUEST | SRB_HW_FLAGS_DATA_TRANSFER:
DebugPrint(( DebugLevelVerbose," As a Data\n" ));
MonoOutStr( "(Data)" );
// Find the smallest and the biggest discarded order number in this packet
for( ulSample = 0; ulSample < pSrb->NumberOfBuffers; ulSample++ )
{
pHeader = (PKSSTREAM_HEADER)pSrb->CommandData.DataBufferArray + ulSample;
wMaxOrder = max( (WORD)(pHeader->TypeSpecificFlags >> 16), wMaxOrder );
wMinOrder = min( (WORD)(pHeader->TypeSpecificFlags >> 16), wMinOrder );
}
MonoOutStr( " Min:" );
MonoOutInt( wMinOrder );
MonoOutStr( " Max:" );
MonoOutInt( wMaxOrder );
MonoOutStr( " Curr:" );
MonoOutInt( pHwDevExt->wNextSrbOrderNumber );
if(bCancel)
{
if( /*wMinOrder <= pHwDevExt->wNextSrbOrderNumber &&*/
wMaxOrder >= pHwDevExt->wNextSrbOrderNumber )
{
pHwDevExt->wNextSrbOrderNumber = wMaxOrder + 1;
MonoOutStr( "<<< Updating NextSrbOrderNumber to " );
MonoOutULong( pHwDevExt->wNextSrbOrderNumber );
MonoOutStr( " >>>" );
}
else
MonoOutChar( ' ' );
MonoOutStr("Cancel::ARR");
AdapterReleaseRequest( pSrb );
}
else
{
if(pHwDevExt->pCurrentSubPictureSrb)
{
pHeader = (PKSSTREAM_HEADER)pHwDevExt->pCurrentSubPictureSrb->CommandData.DataBufferArray ;
pHeader += pHwDevExt->dwCurrentSubPictureSample;
wMinOrder = min( (WORD)(pHeader->TypeSpecificFlags >> 16), wMinOrder );
}
if(pHwDevExt->pCurrentVideoSrb)
{
pHeader = (PKSSTREAM_HEADER)pHwDevExt->pCurrentVideoSrb->CommandData.DataBufferArray ;
pHeader += pHwDevExt->dwCurrentVideoSample;
wMinOrder = min( (WORD)(pHeader->TypeSpecificFlags >> 16), wMinOrder );
}
if(pHwDevExt->pCurrentAudioSrb)
{
pHeader = (PKSSTREAM_HEADER)pHwDevExt->pCurrentAudioSrb->CommandData.DataBufferArray ;
pHeader += pHwDevExt->dwCurrentAudioSample;
wMinOrder = min( (WORD)(pHeader->TypeSpecificFlags >> 16), wMinOrder );
}
pHwDevExt->wNextSrbOrderNumber = wMinOrder ;
AdapterSendData(pHwDevExt);
}
MonoOutStr( "(Current->" );
if( pHwDevExt->pCurrentVideoSrb )
MonoOutStr( "V" );
if( pHwDevExt->pCurrentAudioSrb )
MonoOutStr( "A" );
if( pHwDevExt->pCurrentSubPictureSrb )
MonoOutStr( "S" );
if( !pHwDevExt->pCurrentVideoSrb && !pHwDevExt->pCurrentAudioSrb && !pHwDevExt->pCurrentSubPictureSrb )
MonoOutStr( "Queue empty" );
MonoOutStr( ")" );
break;
case SRB_HW_FLAGS_STREAM_REQUEST:
DebugPrint(( DebugLevelVerbose," As a Control\n" ));
MonoOutStr( "(Control)" );
AdapterReleaseRequest( pSrb );
break;
default:
// this must be a device request. Use device notifications
DebugPrint(( DebugLevelVerbose," As a Device\n" ));
MonoOutStr( "(Device)" );
AdapterReleaseRequest( pSrb );
}
MonoOutSetUnderscore( FALSE );
DebugPrint(( DebugLevelVerbose, "ZiVA: End Adapter%sPacket\n", pszFuncString ));
}
/*** AdapterCancelPacket()
**
** Request to cancel a packet that is currently in process in the minidriver
**
** Arguments:
**
** pSrb - pointer to request packet to cancel
**
** Returns:
**
** Side Effects: none
*/
VOID STREAMAPI AdapterCancelPacket( PHW_STREAM_REQUEST_BLOCK pSrb )
{
CancelPacket( pSrb, TRUE );
}
/*
** AdapterTimeoutPacket()
**
** This routine is called when a packet has been in the minidriver for
** too long. The adapter must decide what to do with the packet
**
** Arguments:
**
** pSrb - pointer to the request packet that timed out
**
** Returns:
**
** Side Effects: none
*/
VOID STREAMAPI AdapterTimeoutPacket( PHW_STREAM_REQUEST_BLOCK pSrb )
{
PHW_DEVICE_EXTENSION pHwDevExt = (PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension;
// If this is a data request, and the device is paused (we probably have run out of
// data buffer) or busy with overlay calibration we need more time, so just reset the
// timer, and let the packet continue
if( ZivaHw_GetState() == ZIVA_STATE_PAUSE
#ifdef ENCORE
|| pHwDevExt->nVGAMode != AP_KNOWNMODE
#endif
)
{
DebugPrint(( DebugLevelVerbose, "Timeout: Stream is PAUSED\n" ));
// reset the timeout counter, and continue
pSrb->TimeoutCounter = pSrb->TimeoutOriginal;
return;
}
CleanCCQueue(pHwDevExt);
CancelPacket( pSrb, FALSE );
}
void FinishCurrentPacketAndSendNextOne( PHW_DEVICE_EXTENSION pHwDevExt )
{
DWORD dwSample;
PHW_STREAM_REQUEST_BLOCK pSrb = NULL;
DWORD dwCurBuf=0;
switch( pHwDevExt->CurrentlySentStream )
{
case ZivaVideo:
pSrb = pHwDevExt->pCurrentVideoSrb;
++pHwDevExt->dwCurrentVideoPage;
if(pHwDevExt->dwVideoDataUsed <= 0)
{
pHwDevExt->wNextSrbOrderNumber++;
++pHwDevExt->dwCurrentVideoSample;
dwCurBuf = pHwDevExt->dwCurrentVideoSample;
}
dwSample = pHwDevExt->dwCurrentVideoPage;
break;
case ZivaAudio:
pSrb = pHwDevExt->pCurrentAudioSrb;
++pHwDevExt->dwCurrentAudioPage;
if(pHwDevExt->dwAudioDataUsed <= 0)
{
pHwDevExt->wNextSrbOrderNumber++;
++pHwDevExt->dwCurrentAudioSample;
dwCurBuf = pHwDevExt->dwCurrentAudioSample;
}
dwSample = pHwDevExt->dwCurrentAudioPage;
break;
case ZivaSubpicture:
pSrb = pHwDevExt->pCurrentSubPictureSrb;
++pHwDevExt->dwCurrentSubPicturePage;
if(pHwDevExt->dwSubPictureDataUsed <= 0)
{
pHwDevExt->wNextSrbOrderNumber++;
++pHwDevExt->dwCurrentSubPictureSample;
dwCurBuf = pHwDevExt->dwCurrentSubPictureSample;
}
dwSample = pHwDevExt->dwCurrentSubPicturePage;
break;
}
if( pSrb )
{
if( ( dwSample >= pSrb->NumberOfPhysicalPages) || (dwCurBuf >= pSrb->NumberOfBuffers))
{
if( dwSample > pSrb->NumberOfPhysicalPages)
{
MonoOutSetBlink( TRUE );
MonoOutStr( "<<< Current sample number is higher than the number of buffers >>>" );
MonoOutSetBlink( FALSE );
}
//tmp MonoOutStr("RSRB");
AdapterReleaseCurrentSrb( pSrb );
}
// Clean the CurrentlySentStream
pHwDevExt->CurrentlySentStream = ZivaNumberOfStreams;
// Send next chunk of data
AdapterSendData( pHwDevExt );
}
}
UINT AdapterPrepareDataForSending( PHW_DEVICE_EXTENSION pHwDevExt,
PHW_STREAM_REQUEST_BLOCK pCurrentStreamSrb,
DWORD dwCurrentStreamSample,
PHW_STREAM_REQUEST_BLOCK* ppSrb, DWORD* pdwSample,
DWORD* dwCurrentSample,DWORD dwCurrentPage,
LONG* pdwDataUsed)
{
PKSSTREAM_HEADER pHeader;
static DWORD wPrevOrderNumber=0xfff;
// Check if this guy has any data to send
pHeader = (PKSSTREAM_HEADER)pCurrentStreamSrb->CommandData.DataBufferArray+dwCurrentStreamSample;
if(pHeader == NULL)
{
MonoOutStr("PHeader NULL");
MoveToNextSample( pCurrentStreamSrb );
pHwDevExt->wNextSrbOrderNumber++;
// Sorry, but we have to start all over again...
return TRUE;
}
if( pHeader->OptionsFlags & KSSTREAM_HEADER_OPTIONSF_TYPECHANGED )
{
MonoOutStr( "!!!! Skipping TYPECHANGED buffer !!!!" );
MoveToNextSample( pCurrentStreamSrb );
// Sorry, but we have to start all over again...
return TRUE;
}
if( (WORD)(pHeader->TypeSpecificFlags >> 16) == pHwDevExt->wNextSrbOrderNumber )
{
if( !pHeader->DataUsed )
{
MonoOutStr( "!!!! DataUsed is 0 !!!!" );
MoveToNextSample( pCurrentStreamSrb );
pHwDevExt->wNextSrbOrderNumber++;
// Sorry, but we have to start all over again...
return TRUE;
}
// Found our SRB
if((*pdwDataUsed <= 0))
{
*pdwDataUsed += pHeader->DataUsed;
if(*pdwDataUsed == 0)
{
MoveToNextSample(pCurrentStreamSrb);
pHwDevExt->wNextSrbOrderNumber++;
return TRUE;
}
}
if(pHeader->PresentationTime.Time)
pHwDevExt->VideoSTC = pHeader->PresentationTime.Time;
*ppSrb = pCurrentStreamSrb;
*pdwSample = dwCurrentPage;
*dwCurrentSample = dwCurrentStreamSample;
}
return FALSE;
}
UpdateOrdinalNumber(IN PHW_DEVICE_EXTENSION pHwDevExt)
{
if(( (pHwDevExt->pCurrentVideoSrb) || (pHwDevExt->pCurrentAudioSrb) || (pHwDevExt->pCurrentSubPictureSrb)) )
{
PKSSTREAM_HEADER pHeader;
WORD wMinOrder = 0xFFFF;
if( pHwDevExt->pCurrentVideoSrb )
{
pHeader = (PKSSTREAM_HEADER)(pHwDevExt->pCurrentVideoSrb->CommandData.DataBufferArray)+
pHwDevExt->dwCurrentVideoSample;
wMinOrder = (WORD)(pHeader->TypeSpecificFlags >> 16);
}
if( pHwDevExt->pCurrentAudioSrb )
{
pHeader = (PKSSTREAM_HEADER)(pHwDevExt->pCurrentAudioSrb->CommandData.DataBufferArray)+
pHwDevExt->dwCurrentAudioSample;
wMinOrder = min( (WORD)(pHeader->TypeSpecificFlags >> 16), wMinOrder );
}
if( pHwDevExt->pCurrentSubPictureSrb )
{
pHeader = (PKSSTREAM_HEADER)(pHwDevExt->pCurrentSubPictureSrb->CommandData.DataBufferArray)+
pHwDevExt->dwCurrentSubPictureSample;
wMinOrder = min( (WORD)(pHeader->TypeSpecificFlags >> 16), wMinOrder );
}
ASSERT( wMinOrder != 0xFFFF );
pHwDevExt->wNextSrbOrderNumber = wMinOrder;
MonoOutSetBlink( TRUE );
MonoOutStr( "<<< Self recovering NextSrbOrderNumber to " );
MonoOutULong( pHwDevExt->wNextSrbOrderNumber );
MonoOutStr( " >>>" );
MonoOutSetBlink( FALSE );
}
}
BOOLEAN CanUpdateOrdinalNumber(IN PHW_DEVICE_EXTENSION pHwDevExt)
{
BOOLEAN bReturn = FALSE;
if(pHwDevExt->bScanCommandPending)
{
if((pHwDevExt->NewRate == 10000) || (pHwDevExt->bRateChangeFromSlowMotion) )
{
pHwDevExt->bRateChangeFromSlowMotion = FALSE;
if(pHwDevExt->bDiscontinued)
{
pHwDevExt->bDiscontinued = FALSE;
UpdateOrdinalNumber(pHwDevExt);
bReturn = TRUE;
}
}
}
return bReturn;
}
void IssuePendingCommands(PHW_DEVICE_EXTENSION pHwDevExt)
{
pHwDevExt->bEndFlush = FALSE;
pHwDevExt->bTimerScheduled = FALSE;
DisableThresholdInt();
if( pHwDevExt->bPlayCommandPending == TRUE )
{ // If "Play" command is pending - it's time to fire it
pHwDevExt->bPlayCommandPending = FALSE;
ZivaHw_FlushBuffers( );
pHwDevExt->bInterruptPending = FALSE;
if( !ZivaHw_Play() )
DebugPrint(( DebugLevelInfo, "ZiVA: !!!!!!!!! Play command did not succeed !!!!!!!!!\n" ));
}
if( pHwDevExt->bScanCommandPending == TRUE )
{
pHwDevExt->bScanCommandPending = FALSE;
if(pHwDevExt->NewRate == 10000)
{
ZivaHw_Abort();//sri
pHwDevExt->bInterruptPending = FALSE;
ZivaHw_Play();
}
else if(pHwDevExt->NewRate < 10000)
{
ZivaHw_Abort();//sri
pHwDevExt->bInterruptPending = FALSE;
ZivaHw_Scan();
}
else
{
ZivaHw_Abort();//sri
pHwDevExt->bInterruptPending = FALSE;
ZivaHw_SlowMotion( 8 );
}
}
}
void CallAdapterSendAtALaterTime( PHW_DEVICE_EXTENSION pHwDevExt )
{
// UpdateOrdinalNumber(pHwDevExt);
MonoOutStr("CallAdapterSendAtALaterTime");
if(pHwDevExt->bTimerScheduled)
{
pHwDevExt->bTimerScheduled = FALSE;
MonoOutStr("CallAdapterSend");
UpdateOrdinalNumber(pHwDevExt);
AdapterSendData(pHwDevExt);
}
}
BOOL UpdateOrdNum_MinOfAllThree(PHW_DEVICE_EXTENSION pHwDevExt)
{
if( ((!pHwDevExt->bVideoStreamOpened || pHwDevExt->pCurrentVideoSrb) &&
(!pHwDevExt->bAudioStreamOpened || pHwDevExt->pCurrentAudioSrb) &&
(!pHwDevExt->bSubPictureStreamOpened || pHwDevExt->pCurrentSubPictureSrb))
)
{
PKSSTREAM_HEADER pHeader;
WORD wMinOrder = 0xFFFF;
if( pHwDevExt->pCurrentVideoSrb )
{
pHeader = (PKSSTREAM_HEADER)(pHwDevExt->pCurrentVideoSrb->CommandData.DataBufferArray)+
pHwDevExt->dwCurrentVideoSample;
wMinOrder = (WORD)(pHeader->TypeSpecificFlags >> 16);
}
if( pHwDevExt->pCurrentAudioSrb )
{
pHeader = (PKSSTREAM_HEADER)(pHwDevExt->pCurrentAudioSrb->CommandData.DataBufferArray)+
pHwDevExt->dwCurrentAudioSample;
wMinOrder = min( (WORD)(pHeader->TypeSpecificFlags >> 16), wMinOrder );
}
if( pHwDevExt->pCurrentSubPictureSrb )
{
pHeader = (PKSSTREAM_HEADER)(pHwDevExt->pCurrentSubPictureSrb->CommandData.DataBufferArray)+
pHwDevExt->dwCurrentSubPictureSample;
wMinOrder = min( (WORD)(pHeader->TypeSpecificFlags >> 16), wMinOrder );
}
ASSERT( wMinOrder != 0xFFFF );
pHwDevExt->wNextSrbOrderNumber = wMinOrder;
MonoOutSetBlink( TRUE );
MonoOutStr( "<<< Self recovering NextSrbOrderNumber to " );
MonoOutULong( pHwDevExt->wNextSrbOrderNumber );
MonoOutStr( " >>>" );
MonoOutSetBlink( FALSE );
return TRUE;
}
else
return FALSE;
}
/*BOOL StartUpDiscontinue(PHW_DEVICE_EXTENSION pHwDevExt)
{
if(pHwDevExt->dwFirstVideoOrdNum != -1)
wMinOrder = min( (WORD)pHwDevExt->dwFirstVideoOrdNum, wMinOrder );
if(pHwDevExt->dwFirstAudioOrdNum != -1)
wMinOrder = min( (WORD)pHwDevExt->dwFirstAudioOrdNum, wMinOrder );
if(pHwDevExt->dwFirstSbpOrdNum != -1)
wMinOrder = min( (WORD)pHwDevExt->dwFirstSbpOrdNum, wMinOrder );
if((wMinOrder != -1) && (wMinOrder > pHwDevExt->wNextSrbOrderNumber) )
{
pHwDevExt->wNextSrbOrderNumber = wMinOrder ;
return TRUE;
}
else
return FALSE;
}*/
/*
** AdapterSendData()
**
** This routine is being scheduled by the either one of the input
** streams when it receives data or by the ISR when sending of the
** previos block is completed and there still Srbs pending.
**
** Arguments:
**
** pHwDevExt - the hardware device extension.
**
** Returns: none
**
** Side Effects: none
*/
VOID STREAMAPI AdapterSendData( IN PHW_DEVICE_EXTENSION pHwDevExt )
{
PHW_STREAM_REQUEST_BLOCK pSrb;
DWORD dwPageToSend;
DWORD dwCurrentSample;
#ifndef DECODER_DVDPC
if(pHwDevExt->bAbortAtPause)
return;
#endif
// Check if HW is not busy and there is something to send
if( pHwDevExt->bInterruptPending ||
(pHwDevExt->pCurrentVideoSrb == NULL &&
pHwDevExt->pCurrentAudioSrb == NULL && pHwDevExt->pCurrentSubPictureSrb == NULL) )
return;
// Find the next Sample by the order number
for( ;; )
{
pSrb = NULL;
if( pHwDevExt->pCurrentVideoSrb &&
AdapterPrepareDataForSending( pHwDevExt, pHwDevExt->pCurrentVideoSrb,
pHwDevExt->dwCurrentVideoSample, &pSrb, &dwPageToSend,&dwCurrentSample,
pHwDevExt->dwCurrentVideoPage,&pHwDevExt->dwVideoDataUsed) )
continue;
if( pHwDevExt->pCurrentAudioSrb && pSrb == NULL &&
AdapterPrepareDataForSending( pHwDevExt, pHwDevExt->pCurrentAudioSrb,
pHwDevExt->dwCurrentAudioSample, &pSrb, &dwPageToSend,&dwCurrentSample,
pHwDevExt->dwCurrentAudioPage,&pHwDevExt->dwAudioDataUsed) )
continue;
if( pHwDevExt->pCurrentSubPictureSrb && pSrb == NULL &&
AdapterPrepareDataForSending( pHwDevExt, pHwDevExt->pCurrentSubPictureSrb,
pHwDevExt->dwCurrentSubPictureSample, &pSrb, &dwPageToSend,&dwCurrentSample,
pHwDevExt->dwCurrentSubPicturePage,&pHwDevExt->dwSubPictureDataUsed) )
continue;
if( pSrb != NULL ) // Found the right SRB
{
pHwDevExt->CurrentlySentStream = pSrb->StreamObject->StreamNumber;
break;
}
if(CanUpdateOrdinalNumber(pHwDevExt))
{
UpdateOrdinalNumber(pHwDevExt);
continue;
}
if(pHwDevExt->bEndFlush)
{
pHwDevExt->bEndFlush = FALSE;
MonoOutStr("Timer Scheduled for AdapterSendData");
StreamClassScheduleTimer( NULL, pHwDevExt,
400000,
(PHW_TIMER_ROUTINE)CallAdapterSendAtALaterTime,
pHwDevExt );
pHwDevExt->bTimerScheduled = TRUE;
}
if(UpdateOrdNum_MinOfAllThree(pHwDevExt))
continue;
// if(StartUpDiscontinue(pHwDevExt))
// continue;
MonoOutStr( "!! CD !!" );
//MonoOutStr( "!!!!!!!!!!!!!!! COUNTER DISCONTINUITY !!!!!!!!!!!!!!!!!!!" );
// Clean the CurrentlySentStream
pHwDevExt->CurrentlySentStream = ZivaNumberOfStreams;
return;
}
XferData(pSrb,pHwDevExt,dwPageToSend,dwCurrentSample);
}
/*
** AdapterReleaseCurrentSrb()
**
** This routine is called by the AdapterSendData() and HWInterrupt() functions
** when there is no more data in the Currently processing Srb.
**
** Arguments:
**
** pSrb - the request block to release.
**
** Returns:
**
** Side Effects: none
*/
VOID STREAMAPI AdapterReleaseCurrentSrb( PHW_STREAM_REQUEST_BLOCK pSrb )
{
PHW_DEVICE_EXTENSION pHwDevExt = (PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension;
PKSSTREAM_HEADER pHeader;
pSrb->Status = STATUS_SUCCESS;
// Clear the CurrentSrb and Sample count for this Srb
switch( pSrb->StreamObject->StreamNumber )
{
case ZivaVideo:
pHwDevExt->pCurrentVideoSrb = NULL;
pHwDevExt->dwCurrentVideoSample = 0;
pHwDevExt->dwCurrentVideoPage = 0;
pHwDevExt->dwVideoDataUsed=0;
break;
case ZivaAudio:
pHwDevExt->pCurrentAudioSrb = NULL;
pHwDevExt->dwCurrentAudioSample = 0;
pHwDevExt->dwCurrentAudioPage = 0;
pHwDevExt->dwAudioDataUsed=0;
break;
case ZivaSubpicture:
pHwDevExt->pCurrentSubPictureSrb = NULL;
pHwDevExt->dwCurrentSubPictureSample = 0;
pHwDevExt->dwCurrentSubPicturePage = 0;
pHwDevExt->dwSubPictureDataUsed=0;
break;
default:
MonoOutStr( "!!!!!!!! Releasing Srb for UNKNOWN stream !!!!!!!!" );
}
// Check if this is the last Srb for current title
pHeader = (PKSSTREAM_HEADER)pSrb->CommandData.DataBufferArray+pSrb->NumberOfBuffers-1;
if( pHeader->TypeSpecificFlags & KS_AM_UseNewCSSKey )
{
switch( pSrb->StreamObject->StreamNumber )
{
case ZivaVideo:
MonoOutStr( "!!! Last video Srb !!!" );
pHwDevExt->bVideoCanAuthenticate = TRUE;
break;
case ZivaAudio:
MonoOutStr( "!!! Last audio Srb !!!" );
pHwDevExt->bAudioCanAuthenticate = TRUE;
break;
case ZivaSubpicture:
MonoOutStr( "!!! Last SP Srb !!!" );
pHwDevExt->bSubPictureCanAuthenticate = TRUE;
break;
default:
MonoOutStr( "!!!!!!!! Last Srb for UNKNOWN stream !!!!!!!!" );
}
}
AdapterReleaseRequest( pSrb );
}
/*
** AdapterReleaseRequest()
**
** This routine is called when any of the open pins (streams) wants
** to dispose an used request block.
**
** Arguments:
**
** pSrb - the request block to release.
**
** Returns:
**
** Side Effects: none
*/
VOID STREAMAPI AdapterReleaseRequest( PHW_STREAM_REQUEST_BLOCK pSrb )
{
if( pSrb->Status == STATUS_PENDING )
MonoOutStr( " !!! Srb is PENDING - not releasing !!! " );
else
{
if( pSrb->Flags & SRB_HW_FLAGS_STREAM_REQUEST )
{
if( pSrb->Flags & SRB_HW_FLAGS_DATA_TRANSFER )
{
StreamClassStreamNotification( ReadyForNextStreamDataRequest, pSrb->StreamObject );
// MonoOutStr(" Release D");
}
else
{
StreamClassStreamNotification( ReadyForNextStreamControlRequest, pSrb->StreamObject );
// MonoOutStr(" Release C");
}
StreamClassStreamNotification( StreamRequestComplete, pSrb->StreamObject, pSrb );
}
else
{
StreamClassDeviceNotification( ReadyForNextDeviceRequest, pSrb->HwDeviceExtension );
StreamClassDeviceNotification( DeviceRequestComplete, pSrb->HwDeviceExtension, pSrb );
}
}
}
/*
** AdapterCanAuthenticateNow()
**
** This routine is called when Authentication request was made by the
** Class Driver.
**
** Arguments:
**
** pHwDevExt - hardware device extension.
**
** Returns:
**
** TRUE if Authentication is allowed at this moment, FALSE otherwise.
**
** Side Effects: none
*/
BOOL STREAMAPI AdapterCanAuthenticateNow( IN PHW_DEVICE_EXTENSION pHwDevExt )
{
if( (pHwDevExt->bVideoStreamOpened == FALSE ||
(pHwDevExt->bVideoStreamOpened == TRUE && pHwDevExt->bVideoCanAuthenticate == TRUE)) &&
(pHwDevExt->bAudioStreamOpened == FALSE ||
(pHwDevExt->bAudioStreamOpened == TRUE && pHwDevExt->bAudioCanAuthenticate == TRUE)) &&
(pHwDevExt->bSubPictureStreamOpened == FALSE ||
(pHwDevExt->bSubPictureStreamOpened == TRUE && pHwDevExt->bSubPictureCanAuthenticate == TRUE)) )
return TRUE;
return FALSE;
}
/*
** AdapterClearAuthenticationStatus()
**
** This routine is called when Authentication and key exchange was
** completed.
**
** Arguments:
**
** pHwDevExt - hardware device extension.
**
** Returns:
**
** Side Effects: none
*/
VOID STREAMAPI AdapterClearAuthenticationStatus( IN PHW_DEVICE_EXTENSION pHwDevExt )
{
pHwDevExt->bVideoCanAuthenticate = FALSE;
pHwDevExt->bAudioCanAuthenticate = FALSE;
pHwDevExt->bSubPictureCanAuthenticate = FALSE;
}
/*
** AdapterSetState()
**
** Sets the current state
**
** Arguments:
**
** pSrb - pointer to the stream request block for properties
**
** Returns:
**
** Side Effects: none
*/
BOOL AdapterSetState( PHW_STREAM_REQUEST_BLOCK pSrb )
{
PHW_DEVICE_EXTENSION pHwDevExt = (PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension;
PHW_STREAM_EXTENSION pStreamExt = (PHW_STREAM_EXTENSION)pSrb->StreamObject->HwStreamExtension;
DebugPrint(( DebugLevelVerbose, "ZiVA: AdapterSetState() -> " ));
pSrb->Status = STATUS_SUCCESS;
// Execute appropriate command only when it comes for every stream
switch( pSrb->CommandData.StreamState )
{
case KSSTATE_STOP:
pStreamExt->ksState = pSrb->CommandData.StreamState;
#ifdef ENCORE
if( pSrb->StreamObject->StreamNumber == ZivaAnalog && pHwDevExt->nAnalogStreamOpened > 1 )
pHwDevExt->nStopCount -= pHwDevExt->nAnalogStreamOpened-1;
#endif
if( --pHwDevExt->nStopCount == 0 )
{
// ZwClose(Handle);
pHwDevExt->nStopCount = pHwDevExt->iTotalOpenedStreams;
DebugPrint(( DebugLevelVerbose, "Stop" ));
if( !ZivaHw_Abort() )
pSrb->Status = STATUS_IO_DEVICE_ERROR;
else
pHwDevExt->bInterruptPending = FALSE;
AdapterInitLocals(pHwDevExt);
}
break;
case KSSTATE_PAUSE:
pStreamExt->ksState = pSrb->CommandData.StreamState;
pStreamExt->bCanBeRun = TRUE;
if( (ZivaHw_GetState( ) == ZIVA_STATE_SCAN) || (ZivaHw_GetState( ) ==ZIVA_STATE_SLOWMOTION) )//sri
pHwDevExt->bAbortAtPause = TRUE;
#ifdef ENCORE
if( pSrb->StreamObject->StreamNumber == ZivaAnalog && pHwDevExt->nAnalogStreamOpened > 1 )
pHwDevExt->nPauseCount -= pHwDevExt->nAnalogStreamOpened-1;
#endif
if( --pHwDevExt->nPauseCount == 0 )
{
pHwDevExt->nPauseCount = pHwDevExt->iTotalOpenedStreams;
DebugPrint(( DebugLevelVerbose, "Pause" ));
if( !ZivaHw_Pause() )
{
MonoOutStr("Pause Failed");
pSrb->Status = STATUS_IO_DEVICE_ERROR;
}
}
break;
case KSSTATE_RUN:
pStreamExt->ksState = pSrb->CommandData.StreamState;
#ifdef ENCORE
if( pSrb->StreamObject->StreamNumber == ZivaAnalog && pHwDevExt->nAnalogStreamOpened > 1 )
pHwDevExt->nPlayCount -= pHwDevExt->nAnalogStreamOpened-1;
#endif
if( --pHwDevExt->nPlayCount == 0 )
{
pHwDevExt->nPlayCount = pHwDevExt->iTotalOpenedStreams;
DebugPrint(( DebugLevelVerbose, "Run" ));
// We could be resuming playback here after Pause mode
if(pHwDevExt->bAbortAtPause)
{
pHwDevExt->bAbortAtPause = FALSE;
ZivaHw_Abort();
#ifdef DECODER_DVDPC
if( !ZivaHw_Play() ) // Just run the hardware
pSrb->Status = STATUS_IO_DEVICE_ERROR;
// pHwDevExt->bPlayCommandPending = TRUE;
// AdapterSendData(pHwDevExt);
#endif
#ifndef DECODER_DVDPC
pHwDevExt->bInterruptPending = FALSE;
pHwDevExt->bPlayCommandPending = TRUE;
FinishCurrentPacketAndSendNextOne( pHwDevExt );
AdapterSendData(pHwDevExt);
#endif
}
else
{
if( pHwDevExt->bInterruptPending )
{
if( !ZivaHw_Play() ) // Just run the hardware
pSrb->Status = STATUS_IO_DEVICE_ERROR;
}
else
{
// Since Authentication and Key Exchange comes in between
// "Run" command and actual data sending and ZiVA Microcode
// cannot sustain it - postpone issuing Play command to ZiVA
// until first packet of the data arrives.
pHwDevExt->bPlayCommandPending = TRUE;
// Kick the Adapter to start transferring data
AdapterSendData( pHwDevExt );
}
}
EnableVideo(pSrb);
}
break;
}
DebugPrint(( DebugLevelVerbose, "\nZiVA: End AdapterSetState()\n" ));
return TRUE;
}
/*
** AdapterReleaseControlRequest()
**
** This routine is called when any of the open pins (streams) wants
** to dispose an used control request block.
**
** Arguments:
**
** pSrb - the request block to release.
**
** Returns:
**
** Side Effects: none
*/
VOID STREAMAPI AdapterReleaseControlRequest( PHW_STREAM_REQUEST_BLOCK pSrb )
{
if ( pSrb->Status == STATUS_PENDING )
{
MonoOutStr( " !!! Srb is PENDING - not releasing !!! " );
}
else
{
StreamClassStreamNotification( ReadyForNextStreamControlRequest,
pSrb->StreamObject);
StreamClassStreamNotification( StreamRequestComplete,
pSrb->StreamObject,
pSrb);
// MonoOutStr(" Release ");
}
}
/*
** AdapterReleaseDataRequest()
**
** This routine is called when any of the open pins (streams) wants
** to dispose an used data request block.
**
** Arguments:
**
** pSrb - the request block to release.
**
** Returns:
**
** Side Effects: none
*/
VOID STREAMAPI AdapterReleaseDataRequest( PHW_STREAM_REQUEST_BLOCK pSrb )
{
if ( pSrb->Status == STATUS_PENDING )
{
MonoOutStr( " !!! Srb is PENDING - not releasing !!! " );
}
else
{
StreamClassStreamNotification( ReadyForNextStreamDataRequest,
pSrb->StreamObject);
StreamClassStreamNotification( StreamRequestComplete,
pSrb->StreamObject,
pSrb);
// MonoOutStr(" ReleaseData ");
}
}
/*
** AdapterReleaseDeviceRequest()
**
** This routine is called when any of the open pins (streams) wants
** to dispose an used device request block.
**
** Arguments:
**
** pSrb - the request block to release.
**
** Returns:
**
** Side Effects: none
*/
VOID STREAMAPI AdapterReleaseDeviceRequest( PHW_STREAM_REQUEST_BLOCK pSrb )
{
StreamClassDeviceNotification( ReadyForNextDeviceRequest,
pSrb->HwDeviceExtension);
StreamClassDeviceNotification( DeviceRequestComplete,
pSrb->HwDeviceExtension,
pSrb);
}
VOID STREAMAPI AdapterReleaseCtrlDataSrb( PHW_STREAM_REQUEST_BLOCK pSrb )
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
KSSTREAM_HEADER *pHeader;
//
// Clear the CurrentSrb and Sample count for this Srb
//
pSrb->Status = STATUS_SUCCESS;
//
// Check if this is the last Srb for current title
//
pHeader = ((KSSTREAM_HEADER *)(pSrb->CommandData.DataBufferArray)) ;
if ( pHeader->TypeSpecificFlags & KS_AM_UseNewCSSKey )
{
switch ( pSrb->StreamObject->StreamNumber )
{
case ZivaVideo:
pHwDevExt->bVideoCanAuthenticate = TRUE;
break;
case ZivaAudio:
pHwDevExt->bAudioCanAuthenticate = TRUE;
break;
case ZivaSubpicture:
pHwDevExt->bSubPictureCanAuthenticate = TRUE;
break;
default:
MonoOutStr( "!!!!!!!! Last Srb for UNKNOWN stream !!!!!!!!" );
}
}
AdapterReleaseDataRequest( pSrb );
}
BOOL CheckAndReleaseIfCtrlPkt(PHW_STREAM_REQUEST_BLOCK pSrb)
{
KSSTREAM_HEADER *pHeader;
pHeader = ((PKSSTREAM_HEADER)pSrb->CommandData.DataBufferArray);
if (pHeader->TypeSpecificFlags & KS_AM_UseNewCSSKey)
{
if (pSrb->NumberOfBuffers == 0)
{
AdapterReleaseCtrlDataSrb(pSrb);
return TRUE;
}
else if (pSrb->NumberOfBuffers == 1)
{
BYTE *pData;
DWORD dwDataUsed;
pData = pHeader->Data;
dwDataUsed = pHeader->DataUsed;
if ((dwDataUsed == 0) ||
(pData && *((DWORD*)pData) != 0xBA010000))
{
AdapterReleaseCtrlDataSrb(pSrb);
return TRUE;;
}
}
}
return FALSE;
}
#if 0
static void STREAMAPI CreateFile(PHW_STREAM_REQUEST_BLOCK pSrb )
{
NTSTATUS ntStatus;
ASSERT( pSrb->Status == STATUS_PENDING );
RtlInitUnicodeString (&pathUnicodeString,wPath);
InitializeObjectAttributes(&InitializedAttributes,&pathUnicodeString,OBJ_CASE_INSENSITIVE,NULL,NULL);
// InitializedAttributes.Length = 2048;
// AllocSize.QuadPart=0xffff;
// ntStatus = ZwCreateFile(&Handle,FILE_WRITE_DATA,
// &InitializedAttributes,&IOStatusBlock,
// 0,FILE_ATTRIBUTE_NORMAL,0,FILE_SUPERSEDE,
// FILE_NO_INTERMEDIATE_BUFFERING,NULL,0);
ntStatus = ZwCreateFile( &Handle,
GENERIC_WRITE,
&InitializedAttributes,
&IOStatusBlock,
NULL, // alloc size = none
FILE_ATTRIBUTE_NORMAL,
0,
FILE_CREATE,
FILE_WRITE_THROUGH,
NULL, // eabuffer
0 ); // ealength
if(NT_SUCCESS(ntStatus))
MonoOutStr("File Creation success");
MonoOutULong(IOStatusBlock.Information);
if( (IOStatusBlock.Information == FILE_CREATED) || (IOStatusBlock.Information == FILE_OPENED) )
MonoOutStr("File Creation success");
else
MonoOutStr("File Creation failed");
pSrb->Status = STATUS_SUCCESS;
StreamClassCallAtNewPriority( pSrb->StreamObject, pSrb->HwDeviceExtension, LowToHigh,
(PHW_PRIORITY_ROUTINE)AdapterReleaseRequest, pSrb );
}
#endif
/*WriteFile()
{
if(STATUS_SUCCESS != ZwWriteFile(Handle,NULL,NULL,NULL,&IOStatusBlock,pdwPhysAddress ,dwCount,NULL,NULL))
MonoOutStr("WriteOperationFailed");
}*/
Reference in a new issue View git blame Copy permalink