archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/drivers/wdm/capture/mini/msdv/msdvavc.c

2213 lines
80 KiB
Raw Blame History

/*++
Copyright (C) Microsoft Corporation, 1999 - 2000
Module Name:
MsdvAvc.c
Abstract:
Interface code with for issuing external device control commands.
Last changed by:
Author: Yee J. Wu
Environment:
Kernel mode only
Revision History:
$Revision:: $
$Date:: $
--*/
#include "strmini.h"
#include "ksmedia.h"
#include "1394.h"
#include "61883.h"
#include "avc.h"
#include "dbg.h"
#include "msdvfmt.h"
#include "msdvdef.h"
#include "MsdvUtil.h"
#include "MsdvAvc.h"
#include "EDevCtrl.h"
#define ALWAYS_SET_N_GET_RAW_AVC
PAVCCmdEntry
DVCRFindCmdEntryCompleted(
PDVCR_EXTENSION pDevExt,
DVCR_AVC_COMMAND idxDVCRCmd,
BYTE OpCodeToMatch,
AvcCommandType cmdTypeToMatch
);
NTSTATUS
DVGetExtDeviceProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
OUT PULONG pulActualBytesTransferred
);
NTSTATUS
DVSetExtDeviceProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
OUT ULONG *pulActualBytesTransferred
);
NTSTATUS
DVGetExtTransportProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
OUT ULONG *pulActualBytesTransferred
);
NTSTATUS
DVSetExtTransportProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
OUT ULONG *pulActualBytesTransferred
);
NTSTATUS
DVGetTimecodeReaderProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
OUT PULONG pulActualBytesTransferred
);
NTSTATUS
DVMediaSeekingProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
OUT PULONG pulActualBytesTransferred
);
#if 0 // Enable later
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, DVCRFindCmdEntryCompleted)
// #pragma alloc_text(PAGE, DVIssueAVCCommand)
#pragma alloc_text(PAGE, DVGetExtDeviceProperty)
#pragma alloc_text(PAGE, DVSetExtDeviceProperty)
#pragma alloc_text(PAGE, DVGetExtTransportProperty)
#pragma alloc_text(PAGE, DVSetExtTransportProperty)
#pragma alloc_text(PAGE, DVGetTimecodeReaderProperty)
#pragma alloc_text(PAGE, DVMediaSeekingProperty)
#pragma alloc_text(PAGE, DVGetDeviceProperty)
#pragma alloc_text(PAGE, DVSetDeviceProperty)
#endif
#endif
KSFCP_PACKET DVcrAVCCmdTable[] = {
// ctype subunitaddr opcode operands
{ DV_UNIT_INFO, -1, 0, CMD_STATUS, 5, AVC_CTYPE_STATUS, UNIT_TYPE_ID_DV, 0x30, 0xff, 0xff, 0xff, 0xff, 0xff}
,{ DV_SUBUNIT_INFO, -1, 0, CMD_STATUS, 5, AVC_CTYPE_STATUS, UNIT_TYPE_ID_DV, 0x31, 0x07, 0xff, 0xff, 0xff, 0xff}
,{ DV_CONNECT_AV_MODE, -1, 0, CMD_STATUS, 5, AVC_CTYPE_STATUS, UNIT_TYPE_ID_DV, 0x20, 0xf0, 0xff, 0xff, 0x20, 0x20}
,{ DV_VEN_DEP_CANON_MODE, -1, 0, CMD_STATUS, 7, AVC_CTYPE_STATUS, UNIT_TYPE_ID_VCR, 0x00, 0x00, 0x00, 0x85, 0x00, 0x10, 0x08, 0xff}
,{ DV_VEN_DEP_DVCPRO, -1, 0, CMD_STATUS, 7, AVC_CTYPE_STATUS, UNIT_TYPE_ID_DV, 0x00, 0x00, 0x80, 0x45, 0x82, 0x48, 0xff, 0xff}
,{ DV_IN_PLUG_SIGNAL_FMT, -1, 0, CMD_STATUS, 5, AVC_CTYPE_STATUS, UNIT_TYPE_ID_DV, 0x19, 0x00, 0xff, 0xff, 0xff, 0xff}
,{ DV_OUT_PLUG_SIGNAL_FMT, -1, 0, CMD_STATUS, 5, AVC_CTYPE_STATUS, UNIT_TYPE_ID_DV, 0x18, 0x00, 0xff, 0xff, 0xff, 0xff}
,{ VCR_TIMECODE_SEARCH, -1, 0, CMD_CONTROL, 5, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0x51, 0x20, 0x00, 0x00, 0x00, 0x00}
,{ VCR_TIMECODE_READ, -1, 0, CMD_STATUS, 5, AVC_CTYPE_STATUS, UNIT_TYPE_ID_VCR, 0x51, 0x71, 0xff, 0xff, 0xff, 0xff}
,{ VCR_ATN_SEARCH, -1, 0, CMD_CONTROL, 5, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0x52, 0x20, 0x00, 0x00, 0x00, 0x00}
,{ VCR_ATN_READ, -1, 0, CMD_STATUS, 5, AVC_CTYPE_STATUS, UNIT_TYPE_ID_VCR, 0x52, 0x71, 0xff, 0xff, 0xff, 0xff}
,{ VCR_RTC_SEARCH, -1, 0, CMD_CONTROL, 5, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0x57, 0x20, 0x00, 0x00, 0x00, 0x00}
,{ VCR_RTC_READ, -1, 0, CMD_STATUS, 5, AVC_CTYPE_STATUS, UNIT_TYPE_ID_VCR, 0x57, 0x71, 0xff, 0xff, 0xff, 0xff}
,{ VCR_OPEN_MIC_CLOSE, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0x60, 0x00}
,{ VCR_OPEN_MIC_READ, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0x60, 0x01}
,{ VCR_OPEN_MIC_WRITE, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0x60, 0x03}
,{ VCR_OPEN_MIC_STATUS, -1, 0, CMD_STATUS, 1, AVC_CTYPE_STATUS, UNIT_TYPE_ID_VCR, 0x60, 0xff}
,{ VCR_READ_MIC, -1, 0, CMD_CONTROL, -1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0x61}
,{ VCR_WRITE_MIC, -1, 0, CMD_CONTROL, -1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0x62}
,{ VCR_OUTPUT_SIGNAL_MODE, -1, 0, CMD_STATUS, 1, AVC_CTYPE_STATUS, UNIT_TYPE_ID_VCR, 0x78, 0xff}
,{ VCR_INPUT_SIGNAL_MODE, -1, 0, CMD_STATUS, 1, AVC_CTYPE_STATUS, UNIT_TYPE_ID_VCR, 0x79, 0xff}
,{ VCR_LOAD_MEDIUM_EJECT, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc1, 0x60}
,{ VCR_RECORD, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc2, 0x75}
,{ VCR_RECORD_PAUSE, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc2, 0x7d}
,{ VCR_PLAY_FORWARD_STEP, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc3, 0x30} // 00=AVC, 20=VCR, c3=Opcode, 30=Operand[0]
,{ VCR_PLAY_FORWARD_SLOWEST, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc3, 0x31}
,{ VCR_PLAY_FORWARD_SLOWEST2, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc3, 0x33}
,{ VCR_PLAY_FORWARD_FASTEST, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc3, 0x3f}
,{ VCR_PLAY_REVERSE_STEP, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc3, 0x40}
,{ VCR_PLAY_REVERSE_SLOWEST, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc3, 0x41}
,{ VCR_PLAY_REVERSE_SLOWEST2, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc3, 0x43}
,{ VCR_PLAY_REVERSE_FASTEST, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc3, 0x4f}
,{ VCR_PLAY_FORWARD, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc3, 0x75}
,{ VCR_PLAY_FORWARD_PAUSE, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc3, 0x7d}
,{ VCR_WIND_STOP, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc4, 0x60}
,{ VCR_WIND_REWIND, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc4, 0x65}
,{ VCR_WIND_FAST_FORWARD, -1, 0, CMD_CONTROL, 1, AVC_CTYPE_CONTROL,UNIT_TYPE_ID_VCR, 0xc4, 0x75}
,{ VCR_TRANSPORT_STATE, -1, 0, CMD_STATUS, 1, AVC_CTYPE_STATUS, UNIT_TYPE_ID_VCR, 0xd0, 0x7f}
,{ VCR_TRANSPORT_STATE_NOTIFY, -1, 0, CMD_NOTIFY, 1, AVC_CTYPE_NOTIFY, UNIT_TYPE_ID_VCR, 0xd0, 0x7f}
,{ VCR_MEDIUM_INFO, -1, 0, CMD_STATUS, 2, AVC_CTYPE_STATUS, UNIT_TYPE_ID_VCR, 0xda, 0x7f,0x7f}
,{ VCR_RAW_AVC, 1, 0, CMD_CONTROL | CMD_STATUS | CMD_NOTIFY | CMD_SPEC_INQ | CMD_GEN_INQ, 0}
};
void
DVCRXlateGetMediumInfo(
PMEDIUM_INFO pMediumInfo,
PBYTE pbOperand0,
PBYTE pbOperand1
)
{
switch(*pbOperand0) {
// Support for DigitalHi8; if we get this query, we treat DHi8 as a mini DV tape.
case 0x12: // DHi8
case 0x31:// DVCR standard cassette
case 0x32:// DVCR small cassette
case 0x33:// DVCR medium cassette
pMediumInfo->MediaPresent = TRUE;
pMediumInfo->MediaType = ED_MEDIA_DVC;
pMediumInfo->RecordInhibit = (*pbOperand1 & 0x01) == 0x01;
break;
case 0x22: // VHS cassette
pMediumInfo->MediaPresent = TRUE;
pMediumInfo->MediaType = ED_MEDIA_VHS;
pMediumInfo->RecordInhibit = (*pbOperand1 & 0x01) == 0x01;
break;
case 0x23:
pMediumInfo->MediaPresent = TRUE;
pMediumInfo->MediaType = ED_MEDIA_VHSC;
pMediumInfo->RecordInhibit = (*pbOperand1 & 0x01) == 0x01;
break;
case 0x60:
pMediumInfo->MediaPresent = FALSE;
pMediumInfo->MediaType = ED_MEDIA_NOT_PRESENT;
pMediumInfo->RecordInhibit = TRUE; // Cannot record if there is no tape.
break;
case 0x7e:
pMediumInfo->MediaPresent = TRUE;
pMediumInfo->MediaType = ED_MEDIA_UNKNOWN;
pMediumInfo->RecordInhibit = TRUE; // Actually cannot be determined
break;
default:
pMediumInfo->MediaPresent = TRUE;
pMediumInfo->MediaType = ED_MEDIA_UNKNOWN;
pMediumInfo->RecordInhibit = TRUE;
break;
}
// Reset command opcode/operands
*pbOperand0 = 0x7f;
*pbOperand1 = 0x7f;
}
void
DVCRXlateGetTransportState(
PTRANSPORT_STATE pXPrtState,
PBYTE pbOpcode,
PBYTE pbOperand0
)
{
TRACE(TL_FCP_TRACE,("\'DVCRXlateGetTransportState: OpCode %x, Operand %x\n", *pbOpcode, *pbOperand0));
switch(*pbOpcode) {
case OPC_LOAD_MEDIUM:
pXPrtState->Mode = ED_MEDIA_UNLOAD;
ASSERT(*pbOperand0 == 0x60);
break;
case OPC_RECORD:
pXPrtState->Mode = ED_MODE_RECORD;
switch(*pbOperand0) {
case 0x75: // RECORD
pXPrtState->State = ED_MODE_RECORD;
break;
case 0x7d: // RECORD_FREEZE
pXPrtState->State = ED_MODE_RECORD_FREEZE;
break;
default:
ASSERT(FALSE && "OPC_RECORD: Operand0 undefined!");
break;
}
break;
case OPC_PLAY:
pXPrtState->Mode = ED_MODE_PLAY;
switch(*pbOperand0) {
case 0x30: // NEXT FRAME
pXPrtState->State = ED_MODE_STEP_FWD;
break;
case 0x31: // SLOWEST FORWARD
case 0x32: // SLOW FORWARD 6
case 0x33: // SLOW FORWARD 5
case 0x34: // SLOW FORWARD 4
case 0x35: // SLOW FORWARD 3
case 0x36: // SLOW FORWARD 2
case 0x37: // SLOW FORWARD 1
pXPrtState->State = ED_MODE_PLAY_SLOWEST_FWD;
break;
case 0x38: // PLAY FORWARD 1
pXPrtState->State = ED_MODE_PLAY;
break;
case 0x39: // FAST FORWARD 1
case 0x3a: // FAST FORWARD 2
case 0x3b: // FAST FORWARD 3
case 0x3c: // FAST FORWARD 4
case 0x3d: // FAST FORWARD 5
case 0x3e: // FAST FORWARD 6
case 0x3f: // FASTEST FORWARD
pXPrtState->State = ED_MODE_PLAY_FASTEST_FWD;
break;
case 0x40: // PREVIOUS FRAME
pXPrtState->State = ED_MODE_STEP_REV;
break;
case 0x41: // SLOWEST REVERSE
case 0x42: // SLOW REVERSE 6
case 0x43: // SLOW REVERSE 5
case 0x44: // SLOW REVERSE 4
case 0x45: // SLOW REVERSE 3
case 0x46: // SLOW REVERSE 2
case 0x47: // SLOW REVERSE 1
pXPrtState->State = ED_MODE_PLAY_SLOWEST_REV;
break;
case 0x48: // X1 REVERSE
case 0x65: // REVERSE
pXPrtState->State = ED_MODE_REV_PLAY;
break;
case 0x49: // FAST REVERSE 1
case 0x4a: // FAST REVERSE 2
case 0x4b: // FAST REVERSE 3
case 0x4c: // FAST REVERSE 4
case 0x4d: // FAST REVERSE 5
case 0x4e: // FAST REVERSE 6
case 0x4f: // FASTEST REVERSE
pXPrtState->State = ED_MODE_PLAY_FASTEST_REV;
break;
case 0x75: // FORWARD
pXPrtState->State = ED_MODE_PLAY;
break;
case 0x6d: // REVERSE PAUSE
case 0x7d: // FORWARD PAUSE
pXPrtState->State = ED_MODE_FREEZE;
break;
default:
pXPrtState->State = 0;
ASSERT(FALSE && "OPC_PLAY: Operand0 undefined!");
break;
}
break;
case OPC_WIND:
//pXPrtState->Mode = ED_MODE_WIND;
switch(*pbOperand0) {
case 0x45: // HIGH SPEED REWIND
pXPrtState->State = ED_MODE_REW_FASTEST;
break;
case 0x60: // STOP
pXPrtState->State = ED_MODE_STOP;
break;
case 0x65: // REWIND
pXPrtState->State = ED_MODE_REW;
break;
case 0x75: // FAST FORWARD
pXPrtState->State = ED_MODE_FF;
break;
default:
TRACE(TL_FCP_ERROR,("DVCRXlateGetTransportState: OPC_WIND with unknown operand0 %x\n", *pbOperand0));
break;
}
// Thre is not a state defined for WIND
pXPrtState->Mode = pXPrtState->State;
break;
case OPC_TRANSPORT_STATE: // As a result of the notify command
break;
default:
ASSERT(FALSE && "OpCode undefined!");
break;
}
// Reset command opcode/operands
*pbOpcode = 0xd0;
*pbOperand0 = 0x7f;
}
void
DVCRXlateGetIOSignalMode(
PULONG pIOSignalMode,
PBYTE pbOperand0
)
{
switch(*pbOperand0) {
// Sony's digital Hi8 can take analog 8MM tape and output DV signal.
case 0x06: // Analog 8mm NTSC
case 0x0e: // Analog Hi8 NTSC
TRACE(TL_FCP_WARNING,("\'***** Signal mode:%x (8MM NTSC)\n", *pbOperand0));
case 0x00: // SD 525-60
*pIOSignalMode = ED_TRANSBASIC_SIGNAL_525_60_SD;
break;
case 0x04: // SDL 525-60
*pIOSignalMode = ED_TRANSBASIC_SIGNAL_525_60_SDL;
break;
// Sony's digital Hi8 can take analog 8MM tape and output DV signal.
case 0x86: // Analog 8mm PAL
case 0x8e: // Analog Hi8 PAL
TRACE(TL_FCP_WARNING,("\'***** Signal mode:%x (8MM PAL)\n", *pbOperand0));
case 0x80: // SD 625-50
*pIOSignalMode = ED_TRANSBASIC_SIGNAL_625_50_SD;
break;
case 0x84: // SDL 625-50
*pIOSignalMode = ED_TRANSBASIC_SIGNAL_625_50_SDL;
break;
default:
// This driver does not understand other format;
TRACE(TL_FCP_WARNING,("***** Unknown signal mode:%x\n", *pbOperand0));
ASSERT(FALSE && "Unknown IoSignal!");
break;
}
// Reset command opcode/operands
*pbOperand0 = 0xff;
}
NTSTATUS
DVCRXlateRawAVC(
PAVCCmdEntry pCmdEntry,
PVOID pProperty
)
{
PAVC_COMMAND_IRB pAvcIrb = pCmdEntry->pAvcIrb;
UCHAR ucRespCode = pAvcIrb->ResponseCode;
NTSTATUS Status;
PUCHAR pbRtnBuf;
//PKSPROPERTY_EXTDEVICE_S pExtDeviceProperty;
PKSPROPERTY_EXTXPORT_S pXPrtProperty;
PKSPROPERTY_TIMECODE_S pTmCdReaderProperty;
if(STATUS_SUCCESS != pCmdEntry->Status) {
TRACE(TL_FCP_ERROR,("\'** DVCRXlateRawAVC: Status:%x ** \n", pCmdEntry->Status));
return pCmdEntry->Status;
}
switch (pCmdEntry->idxDVCRCmd) {
case DV_UNIT_INFO:
pbRtnBuf = (PBYTE) pProperty;
memcpy(pbRtnBuf, pAvcIrb->Operands+1, 4);
break;
case DV_SUBUNIT_INFO:
case DV_IN_PLUG_SIGNAL_FMT:
case DV_OUT_PLUG_SIGNAL_FMT:
pbRtnBuf = (PBYTE) pProperty;
memcpy(pbRtnBuf, pAvcIrb->Operands+1, 4);
break;
// special case, return the response code in the first byte
case DV_CONNECT_AV_MODE:
pbRtnBuf = (PBYTE) pProperty;
pbRtnBuf[0] = ucRespCode;
memcpy(&pbRtnBuf[1], pAvcIrb->Operands, 5);
break;
// special case, return the response code in the first byte
case DV_VEN_DEP_CANON_MODE:
pbRtnBuf = (PBYTE) pProperty;
pbRtnBuf[0] = ucRespCode;
memcpy(&pbRtnBuf[1], pAvcIrb->Operands, 7);
break;
case VCR_TIMECODE_READ:
pTmCdReaderProperty = (PKSPROPERTY_TIMECODE_S) pProperty;
if(pAvcIrb->Operands[1] == 0xff ||
pAvcIrb->Operands[2] == 0xff ||
pAvcIrb->Operands[3] == 0xff ||
pAvcIrb->Operands[4] == 0xff ) {
TRACE(TL_FCP_WARNING,("\'TimeCodeRead: %.2x:%.2x:%.2x,%.2x\n", pAvcIrb->Operands[4], pAvcIrb->Operands[3], pAvcIrb->Operands[2], pAvcIrb->Operands[1]));
// Even though command succeded, but the data is not valid!
Status = STATUS_UNSUCCESSFUL;
} else {
// bswap them.
pTmCdReaderProperty->TimecodeSamp.timecode.dwFrames =
(((DWORD) pAvcIrb->Operands[4]) << 24) |
(((DWORD) pAvcIrb->Operands[3]) << 16) |
(((DWORD) pAvcIrb->Operands[2]) << 8) |
((DWORD) pAvcIrb->Operands[1]);
TRACE(TL_FCP_TRACE,("\'TimeCodeRead: %.2x:%.2x:%.2x,%.2x\n", pAvcIrb->Operands[4], pAvcIrb->Operands[3], pAvcIrb->Operands[2], pAvcIrb->Operands[1]));
}
break;
case VCR_ATN_READ:
pTmCdReaderProperty = (PKSPROPERTY_TIMECODE_S) pProperty;
if(pAvcIrb->Operands[1] == 0x00 &&
pAvcIrb->Operands[2] == 0x00 &&
pAvcIrb->Operands[3] == 0x00 ) {
// Even though command succeded, but the data is not valid!
Status = STATUS_UNSUCCESSFUL;
} else {
pTmCdReaderProperty->TimecodeSamp.dwUser =
pAvcIrb->Operands[1] & 0x01; // Get the Blank flag
// bswap them.
pTmCdReaderProperty->TimecodeSamp.timecode.dwFrames =
( (((DWORD) pAvcIrb->Operands[3]) << 16) |
(((DWORD) pAvcIrb->Operands[2]) << 8) |
(((DWORD) pAvcIrb->Operands[1]))
) >> 1;
}
break;
case VCR_INPUT_SIGNAL_MODE:
case VCR_OUTPUT_SIGNAL_MODE:
pXPrtProperty = (PKSPROPERTY_EXTXPORT_S) pProperty;
DVCRXlateGetIOSignalMode(&pXPrtProperty->u.SignalMode, &pAvcIrb->Operands[0]);
break;
case VCR_TRANSPORT_STATE:
case VCR_TRANSPORT_STATE_NOTIFY:
pXPrtProperty = (PKSPROPERTY_EXTXPORT_S) pProperty;
DVCRXlateGetTransportState(&pXPrtProperty->u.XPrtState, &pAvcIrb->Opcode, &pAvcIrb->Operands[0]);
break;
case VCR_MEDIUM_INFO:
pXPrtProperty = (PKSPROPERTY_EXTXPORT_S) pProperty;
DVCRXlateGetMediumInfo(&pXPrtProperty->u.MediumInfo, &pAvcIrb->Operands[0], &pAvcIrb->Operands[1]);
break;
case VCR_RAW_AVC:
// Do nothing.
break;
default:
// No translation necessary
TRACE(TL_FCP_TRACE,("\'No tranlsation: pCmdEntry:%x; idx:%d\n", pCmdEntry, pCmdEntry->idxDVCRCmd));
break;
}
return pCmdEntry->Status;
}
PAVCCmdEntry
DVCRFindCmdEntryCompleted(
PDVCR_EXTENSION pDevExt,
DVCR_AVC_COMMAND idxDVCRCmd,
BYTE OpCodeToMatch,
AvcCommandType cmdTypeToMatch
)
/*++
Routine Description:
Arguments:
Return Value:
PLIST_ENTRY
--*/
{
LIST_ENTRY *pEntry;
KIRQL OldIrql;
PAGED_CODE();
//
// Special case:
//
// ATN: Status 01 20 52; Control 00 20 52
// (resp) 0c 20 52 0f 20 52 (CtrlInterim)
//
// XPrtState: Status 01 20 d0; Notify 03 20 d0
// (resp) 0c 20 xx 0f 20 xx xx (NotifyInterim)
//
// Summary: if we keep cmdType and OpCode, it is unique.
//
KeAcquireSpinLock(&pDevExt->AVCCmdLock, &OldIrql);
pEntry = pDevExt->AVCCmdList.Flink;
while(pEntry != &pDevExt->AVCCmdList) {
PAVCCmdEntry pCmdEntry = (PAVCCmdEntry)pEntry;
if (pCmdEntry->idxDVCRCmd == idxDVCRCmd) {
//
// We only fetch if it is completed!
//
if(pCmdEntry->cmdState != CMD_STATE_ISSUED) {
if (pCmdEntry->cmdType == cmdTypeToMatch) {
// Control/GenInq/SpecInq: OpCode and Operand[n] remina unchanged.
if (pCmdEntry->OpCode == OpCodeToMatch) {
TRACE(TL_FCP_TRACE,("\'DVCRFindCmdEntryCompleted: (1) Found pCmdEntry:%x (%x, %x, %x)\n",
pCmdEntry, pCmdEntry->pAvcIrb, cmdTypeToMatch, OpCodeToMatch));
RemoveEntryList(&pCmdEntry->ListEntry); pDevExt->cntCommandQueued--;
InitializeListHead(&pCmdEntry->ListEntry); // used as a flag for ownership
// pIrp should be NULL (completed).
if(pCmdEntry->pIrp) {
TRACE(TL_FCP_ERROR,("\'*** FindCmdEntry: pCmdEntry:%x; pIrp:%x not completed\n", pCmdEntry, pCmdEntry->pIrp));
}
KeReleaseSpinLock(&pDevExt->AVCCmdLock, OldIrql);
return pCmdEntry; // Found
}
} else {
TRACE(TL_FCP_TRACE,("\'DVCRFindCmdEntryCompleted: cmdType %x != %x\n", pCmdEntry->cmdType, cmdTypeToMatch));
}
}
else {
TRACE(TL_FCP_TRACE,("\'DVCRFindCmdEntryCompleted: (0) Skip %x not completed (%x, %x) match entry %x\n",
pCmdEntry, cmdTypeToMatch, OpCodeToMatch));
}
}
pEntry = pEntry->Flink;
}
KeReleaseSpinLock(&pDevExt->AVCCmdLock, OldIrql);
TRACE(TL_FCP_TRACE,("\'DVCRFindCmdEntryCompleted: (a) No match\n"));
return NULL; // No match
}
void
DVAVCCmdResetAfterBusReset(
PDVCR_EXTENSION pDevExt
)
/*++
Routine Description:
Arguments:
Return Value:
Nothing
--*/
{
KIRQL OldIrql;
KeAcquireSpinLock(&pDevExt->AVCCmdLock, &OldIrql);
TRACE(TL_FCP_TRACE,("\'Flush AVCCmd: <enter> AVCCmd [completed %d]; CmdList:%x\n", pDevExt->cntCommandQueued, pDevExt->AVCCmdList));
// Clear the command list
while (!IsListEmpty(&pDevExt->AVCCmdList)) {
PAVCCmdEntry pCmdEntry = (PAVCCmdEntry)RemoveHeadList(&pDevExt->AVCCmdList); pDevExt->cntCommandQueued--;
InitializeListHead(&pCmdEntry->ListEntry);
TRACE(TL_FCP_TRACE,("\'Flush AVCCmd: Completed:%d; pCmdEntry:%x; cmdState:%d; cmdSt:%x\n",
pDevExt->cntCommandQueued, pCmdEntry, pCmdEntry->cmdState, pCmdEntry->Status));
switch(pCmdEntry->cmdState) {
case CMD_STATE_ISSUED:
case CMD_STATE_RESP_INTERIM: // AVC.sys may still has it!
TRACE(TL_FCP_WARNING,("BusReset: AbortAVC: IoCancelIrp(%x)!\n", pCmdEntry->pIrp));
ASSERT(pCmdEntry->pIrp != NULL);
IoCancelIrp(pCmdEntry->pIrp); // Calls DVIssueAVCCommandCR() with pIrp->Cancel
break;
// Completed command
case CMD_STATE_UNDEFINED:
TRACE(TL_FCP_ERROR,("DVAVCCmdResetAfterBusReset: Unexpected CMD state %d; pCmdEntry %x\n", pCmdEntry->cmdState, pCmdEntry));
case CMD_STATE_RESP_ACCEPTED:
case CMD_STATE_RESP_REJECTED:
case CMD_STATE_RESP_NOT_IMPL:
case CMD_STATE_ABORTED:
break;
default:
TRACE(TL_FCP_ERROR,("DVAVCCmdResetAfterBusReset: Unknown CMD state %d; pCmdEntry %x\n", pCmdEntry->cmdState, pCmdEntry));
ASSERT(FALSE && "Unknown cmdState\n");
break;
}
// We are guaranteed at this point that no one needs the
// results anymore so we will free the resources.
ExFreePool(pCmdEntry->pAvcIrb);
ExFreePool(pCmdEntry);
}
KeReleaseSpinLock(&pDevExt->AVCCmdLock, OldIrql);
#if DBG
if(pDevExt->cntCommandQueued != 0) {
TRACE(TL_FCP_ERROR,("\'Flush AVCCmd: <exit> AVCCmd [completed %d]; CmdList:%x\n", pDevExt->cntCommandQueued, pDevExt->AVCCmdList));
ASSERT(pDevExt->cntCommandQueued == 0 && "All commands should be cancelled or completed.");
}
#endif
}
NTSTATUS
DVIssueAVCCommandCR(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP pIrp,
IN PAVCCmdEntry pCmdEntry
)
/*++
Routine Description:
This is the completion routine for the AVC command when it is completed which imply that
the interim response will not be called here.
Arguments:
Note: pCmdEntry cannot be used if pIrp->Cancel.
Return Value:
Always STATUS_MORE_PROCESSING_REQUIRED.
Note: the real return is in pCmdEntry->Status.
--*/
{
KIRQL oldIrql;
if (!pIrp->Cancel) {
PDVCR_EXTENSION pDevExt = pCmdEntry->pDevExt;
BOOL bSignalInterimCotrolCompleted = FALSE;
BOOL bSignalInterimNotifyCompleted = FALSE;
PKSEVENT_ENTRY pEvent;
// Serialize AVC command response processing
KeAcquireSpinLock(&pDevExt->AVCCmdLock, &oldIrql);
ASSERT(pCmdEntry->pIrp == pIrp);
pCmdEntry->pIrp = NULL; // don't need this anymore
// Check if it's worthwhile to examine the response buffer
if (STATUS_SUCCESS == pIrp->IoStatus.Status) {
PAVC_COMMAND_IRB pAvcIrb = pCmdEntry->pAvcIrb;
// Check Opcode for return state
switch(pAvcIrb->ResponseCode) {
case AVC_RESPONSE_NOTIMPL:
pCmdEntry->cmdState = CMD_STATE_RESP_NOT_IMPL;
pCmdEntry->Status = STATUS_NOT_SUPPORTED; // -> ERROR_NOT_SUPPORTED
break;
case AVC_RESPONSE_ACCEPTED:
if(pCmdEntry->cmdState == CMD_STATE_RESP_INTERIM) {
if(pCmdEntry->cmdType == AVC_CTYPE_CONTROL) {
bSignalInterimCotrolCompleted = TRUE;
TRACE(TL_FCP_TRACE,("--> Accept: control interim\n"));
} else {
TRACE(TL_FCP_ERROR,("\'ACCEPT: Invalid cmdType:%d; pCmdExtry %x\n", pCmdEntry->cmdType, pCmdEntry));
ASSERT(pCmdEntry->cmdType == AVC_CTYPE_CONTROL && "Accept+Interim but not control cmd");
}
}
pCmdEntry->cmdState = CMD_STATE_RESP_ACCEPTED;
pCmdEntry->Status = STATUS_SUCCESS; // -> NOERROR
break;
case AVC_RESPONSE_REJECTED:
if(pCmdEntry->cmdState == CMD_STATE_RESP_INTERIM) {
if(pCmdEntry->cmdType == AVC_CTYPE_CONTROL) {
TRACE(TL_FCP_TRACE,("--> Reject: control interim\n"));
bSignalInterimCotrolCompleted = TRUE;
} else if(pCmdEntry->cmdType == AVC_CTYPE_NOTIFY) {
TRACE(TL_FCP_TRACE,("--> Reject: notify interim\n"));
bSignalInterimNotifyCompleted = TRUE;
} else {
TRACE(TL_FCP_ERROR,("REJECT: Invalid cmdType:%d; pCmdExtry %x\n", pCmdEntry->cmdType, pCmdEntry));
ASSERT((pCmdEntry->cmdType == AVC_CTYPE_CONTROL || pCmdEntry->cmdType == AVC_CTYPE_NOTIFY) && "Reject+Interim but not control or notify cmd");
}
}
pCmdEntry->cmdState = CMD_STATE_RESP_REJECTED;
pCmdEntry->Status = STATUS_REQUEST_NOT_ACCEPTED; // ERROR_REQ_NOT_ACCEPTED
break;
case AVC_RESPONSE_IN_TRANSITION:
pCmdEntry->cmdState = CMD_STATE_RESP_ACCEPTED;
pCmdEntry->Status = STATUS_SUCCESS; // -> NOERROR
break;
case AVC_RESPONSE_STABLE: // == AVC_RESPONSE_IMPLEMENTED:
pCmdEntry->cmdState = CMD_STATE_RESP_ACCEPTED;
pCmdEntry->Status = STATUS_SUCCESS; // -> NOERROR
break;
case AVC_RESPONSE_CHANGED:
#if DBG
if(pCmdEntry->cmdState != CMD_STATE_RESP_INTERIM) {
TRACE(TL_FCP_ERROR,("Err: Changed; pCmdExtry:%x; cmdState:%d\n", pCmdEntry, pCmdEntry->cmdState));
ASSERT(pCmdEntry->cmdState == CMD_STATE_RESP_INTERIM);
}
#endif
if(pCmdEntry->cmdType == AVC_CTYPE_NOTIFY) {
TRACE(TL_FCP_TRACE,("--> Changed: for notify interim\n"));
bSignalInterimNotifyCompleted = TRUE;
} else {
TRACE(TL_FCP_ERROR,("pCmdExtry %x\n", pCmdEntry));
ASSERT(pCmdEntry->cmdType == AVC_CTYPE_NOTIFY && "Changed but not notify cmd!");
}
pCmdEntry->cmdState = CMD_STATE_RESP_ACCEPTED;
pCmdEntry->Status = STATUS_SUCCESS; // -> NOERROR
break;
// AVC.sys should never return this response !!
case AVC_RESPONSE_INTERIM:
ASSERT( pAvcIrb->ResponseCode != AVC_RESPONSE_INTERIM && "CmpRoutine should not has this response!");
pCmdEntry->cmdState = CMD_STATE_RESP_INTERIM;
pCmdEntry->Status = STATUS_MORE_ENTRIES; // ov.Internal
break;
default:
TRACE(TL_FCP_ERROR,("pCmdEntry%x; State:%d; pAvcIrb:%x; RespCode:%x\n", pCmdEntry, pCmdEntry->cmdState, pAvcIrb, pAvcIrb->ResponseCode));
ASSERT(FALSE && "Undefined cmdState");
pCmdEntry->cmdState = CMD_STATE_UNDEFINED;
pCmdEntry->Status = STATUS_NOT_SUPPORTED; // ov.Internal
break;
}
#if DBG
if(pCmdEntry->cmdState != CMD_STATE_UNDEFINED) {
TRACE(TL_FCP_WARNING,("\' AVCRsp: %d:[%.2x %.2x %.2x %.2x]:[%.2x %.2x %.2x %.2x]; cmdSt:%d; St:%x\n",
pAvcIrb->OperandLength+3, // Resp+SuID+OpCd+Opr[]
pAvcIrb->ResponseCode,
pAvcIrb->SubunitAddr[0],
pAvcIrb->Opcode,
pAvcIrb->Operands[0],
pAvcIrb->Operands[1],
pAvcIrb->Operands[2],
pAvcIrb->Operands[3],
pAvcIrb->Operands[4],
pCmdEntry->cmdState,
pCmdEntry->Status
));
}
#endif
} else {
// Irp returns ERROR !!
if (STATUS_BUS_RESET == pIrp->IoStatus.Status || STATUS_REQUEST_ABORTED == pIrp->IoStatus.Status) {
TRACE(TL_FCP_WARNING,("Bus-Reset or abort (IoStatus.St:%x); pDevRemoved:%d; pCmdEntry:%x; OpC:%x\n", pIrp->IoStatus.Status, pDevExt->bDevRemoved, pCmdEntry, pCmdEntry->OpCode));
// ASSERT only if it was an ABORT while device was NOTt removed.
// ASSERT((pIrp->IoStatus.Status == STATUS_BUS_RESET || pDevExt->bDevRemoved) && "Device not removed but command was aborting ?");
// Busreset while there is an interim pending, signal its client to wake up
// and get the "final" (busreset) result.
if(pCmdEntry->cmdState == CMD_STATE_RESP_INTERIM) {
if(pCmdEntry->cmdType == AVC_CTYPE_CONTROL) {
TRACE(TL_FCP_TRACE,("\'--> BusRest: for control interim\n"));
bSignalInterimCotrolCompleted = TRUE;
} else if(pCmdEntry->cmdType == AVC_CTYPE_NOTIFY) {
TRACE(TL_FCP_TRACE,("\'--> BusRest: for notify interim\n"));
bSignalInterimNotifyCompleted = TRUE;
}
}
}
else {
TRACE(TL_FCP_WARNING,("\'IOCTL_AVC_CLASS Failed, pIrp->IoStatus.Status:%x\n", pIrp->IoStatus.Status));
}
pCmdEntry->cmdState = CMD_STATE_ABORTED;
// If the command was timeout, the application may want to try the command again.
// It is other abort, it might be caused by busreset or dev removal.
if(pIrp->IoStatus.Status == STATUS_TIMEOUT)
pCmdEntry->Status = pIrp->IoStatus.Status;
else if (pIrp->IoStatus.Status == STATUS_DEVICE_DATA_ERROR) // ERROR_CRC
pCmdEntry->Status = pIrp->IoStatus.Status;
else
pCmdEntry->Status = STATUS_REQUEST_ABORTED; // -> ERROR_REQUERT_ABORT
}
//
// If suceeded, translate the AVC response to COM property. if not
// interim's final reponse.
// raw AVC command response
//
if(STATUS_SUCCESS == pCmdEntry->Status &&
!bSignalInterimNotifyCompleted &&
!bSignalInterimCotrolCompleted &&
pCmdEntry->idxDVCRCmd != VCR_RAW_AVC
)
DVCRXlateRawAVC(
pCmdEntry,
pCmdEntry->pProperty
);
// Signal a KS event to inform its client that the final response
// has returned and come and get it.
if(bSignalInterimNotifyCompleted) {
pEvent = NULL;
// There might be multiple instances/threads of IAMExtTransport instance with the same KS event.
// There is only one device so they all enabled event are singalled.
do {
if(pEvent = StreamClassGetNextEvent((PVOID) pDevExt, 0, \
(GUID *)&KSEVENTSETID_EXTDEV_Command, KSEVENT_EXTDEV_COMMAND_NOTIFY_INTERIM_READY, pEvent)) {
// Make sure the right event and then signal it
if(pEvent->EventItem->EventId == KSEVENT_EXTDEV_COMMAND_NOTIFY_INTERIM_READY) {
StreamClassDeviceNotification(SignalDeviceEvent, pDevExt, pEvent);
TRACE(TL_FCP_WARNING,("\'->Signal NOTIFY_INTERIM ready; pEvent:%x, EventId %d.\n", pEvent, pEvent->EventItem->EventId));
}
}
} while (pEvent != NULL);
} else if(bSignalInterimCotrolCompleted) {
pEvent = NULL;
// There might be multiple instances/threads of IAMExtTransport instance with the same KS event.
// There is only one device so they all enabled event are singalled.
do {
if(pEvent = StreamClassGetNextEvent((PVOID) pDevExt, 0, \
(GUID *)&KSEVENTSETID_EXTDEV_Command, KSEVENT_EXTDEV_COMMAND_CONTROL_INTERIM_READY, pEvent)) {
// Make sure the right event and then signal it
if(pEvent->EventItem->EventId == KSEVENT_EXTDEV_COMMAND_CONTROL_INTERIM_READY) {
StreamClassDeviceNotification(SignalDeviceEvent, pDevExt, pEvent);
TRACE(TL_FCP_WARNING,("\'->Signal CONTROL_INTERIM ready; pEvent:%x, EventId %d.\n", pEvent, pEvent->EventItem->EventId));
}
}
} while (pEvent != NULL);
}
// Check that the command entry is ours only to process
// When a command is completed, it will be added to the list and therefore not empty.
// It is designed to be added to the list in this completino routine.
if (!IsListEmpty(&pCmdEntry->ListEntry)) {
if(bSignalInterimNotifyCompleted || bSignalInterimCotrolCompleted) {
// If final reponse is returned, we need to keep them in the list.
TRACE(TL_FCP_TRACE,("\'Final response is completed; stay in the list\n"));
KeReleaseSpinLock(&pDevExt->AVCCmdLock, oldIrql);
}
else {
// This is a undefined path!!!
// The command entry can only be in the list if it is interim of anykind.
// If it is an interim, it will not be removed in the completion routine.
ASSERT(FALSE && "Cannot complete an interim in CR\n");
}
}
else {
// This means that we have completed, but the code that issued the
// command is still executing, and hasn't had a chance to look at
// the results yet. Put this in the command list as a signal that
// we have completed and updated the command state, but are not
// planning to free the command resources.
InsertTailList(&pDevExt->AVCCmdList, &pCmdEntry->ListEntry); pDevExt->cntCommandQueued++;
TRACE(TL_FCP_TRACE,("\'Command completed and Queued(%d); pCmdEntry:%x.\n", pDevExt->cntCommandQueued, pCmdEntry));
KeReleaseSpinLock(&pDevExt->AVCCmdLock, oldIrql);
}
}
else {
TRACE(TL_FCP_WARNING,("DVIssueAVCCommandCR: pCmdEntry:%x; pIrp:%x cancelled\n", pCmdEntry, pIrp));
}
IoFreeIrp(pIrp);
return STATUS_MORE_PROCESSING_REQUIRED;
} // DVIssueAVCCommandCR
NTSTATUS
DVIssueAVCCommand (
IN PDVCR_EXTENSION pDevExt,
IN AvcCommandType cType,
IN DVCR_AVC_COMMAND idxAVCCmd,
IN PVOID pProperty
)
/*++
Routine Description:
Issue a FCP/AVC command.
Arguments:
Return Value:
NTSTATUS
--*/
{
NTSTATUS Status;
PAVCCmdEntry pCmdEntry;
PAVC_COMMAND_IRB pAvcIrb;
PIRP pIrp;
PIO_STACK_LOCATION NextIrpStack;
ULONGLONG tmStart;
DWORD dwElapsed;
KIRQL OldIrql;
LIST_ENTRY *pEntry;
PAGED_CODE();
if(pDevExt->bDevRemoved)
return STATUS_DEVICE_NOT_CONNECTED; // ERROR_NOT_READY
//
// Validate Command type; the command type that each entry of the command table support.
//
switch(cType) {
case AVC_CTYPE_CONTROL:
if((DVcrAVCCmdTable[idxAVCCmd].ulCmdSupported & CMD_CONTROL) != CMD_CONTROL)
return STATUS_NOT_SUPPORTED;
break;
case AVC_CTYPE_STATUS:
if((DVcrAVCCmdTable[idxAVCCmd].ulCmdSupported & CMD_STATUS) != CMD_STATUS)
return STATUS_NOT_SUPPORTED;
break;
case AVC_CTYPE_SPEC_INQ:
if((DVcrAVCCmdTable[idxAVCCmd].ulCmdSupported & CMD_SPEC_INQ) != CMD_SPEC_INQ)
return STATUS_NOT_SUPPORTED;
break;
case AVC_CTYPE_GEN_INQ:
if((DVcrAVCCmdTable[idxAVCCmd].ulCmdSupported & CMD_GEN_INQ) != CMD_GEN_INQ)
return STATUS_NOT_SUPPORTED;
break;
case AVC_CTYPE_NOTIFY:
if((DVcrAVCCmdTable[idxAVCCmd].ulCmdSupported & CMD_NOTIFY) != CMD_NOTIFY)
return STATUS_NOT_SUPPORTED;
break;
default:
TRACE(TL_FCP_ERROR,("DVIssueAVCCommand: Unknown or invalid cmdType: idx %d, ctype (%02x) not supported; (%02x %02x %02x) %d:[%.8x]\n",
idxAVCCmd,
cType,
DVcrAVCCmdTable[idxAVCCmd].CType,
DVcrAVCCmdTable[idxAVCCmd].SubunitAddr,
DVcrAVCCmdTable[idxAVCCmd].Opcode,
DVcrAVCCmdTable[idxAVCCmd].OperandLength,
(DWORD) *(&DVcrAVCCmdTable[idxAVCCmd].Operands[0])
));
return STATUS_NOT_SUPPORTED;
}
// Restrict only one command to be active at any time.
// "Active" mean, it is in the process of issuing the command to the device
// and is awaiting its first response.
// Even though there is only one device but there might be mulitple thread isssuing
// AVC commands at the same time. By design, application should serialize their command
// but they may not know what COM interface will result in an AVC command. In addition,
// this driver itsefl may issue command to the device. So flow control become necessary.
KeWaitForSingleObject( &pDevExt->hMutexIssueAVCCmd, Executive, KernelMode, FALSE, 0 );
// Check one more time for device removal
if(pDevExt->bDevRemoved) {
KeReleaseMutex(&pDevExt->hMutexIssueAVCCmd, FALSE);
TRACE(TL_FCP_WARNING,("** AVC command but device is removed!\n"));
return STATUS_DEVICE_NOT_CONNECTED; // ERROR_NOT_READY
}
// Most device cannot keep two command of same cmdType and OpCode at the same time
// Go thru list of queued (already issues) command, and search for a possible conflict.
KeAcquireSpinLock(&pDevExt->AVCCmdLock, &OldIrql);
pEntry = pDevExt->AVCCmdList.Flink;
while(pEntry != &pDevExt->AVCCmdList) {
pCmdEntry = (PAVCCmdEntry)pEntry;
// Skip the one that is already completed (many differnt command state).
if(pCmdEntry->cmdState == CMD_STATE_RESP_ACCEPTED ||
pCmdEntry->cmdState == CMD_STATE_RESP_REJECTED ||
pCmdEntry->cmdState == CMD_STATE_RESP_NOT_IMPL ||
pCmdEntry->cmdState == CMD_STATE_ABORTED) {
TRACE(TL_FCP_WARNING,("\'---- pCmdEntry:%x; cmdType:%x; OpCode:%x; completed.\n", pCmdEntry, pCmdEntry->cmdType, pCmdEntry->OpCode));
// Find a matching cmdType and OpCode.
} else if(pCmdEntry->cmdType == cType &&
pCmdEntry->OpCode == DVcrAVCCmdTable[idxAVCCmd].Opcode) {
// Conflict, return error.
TRACE(TL_FCP_ERROR,("---- Conflict pCmdEntry:%x; Current: cmdType:%x, OpCode:%x; rtn STATUS_DEVICE_NOT_READY\n",
pCmdEntry, cType, DVcrAVCCmdTable[idxAVCCmd].Opcode));
// ASSERT(FALSE && "Conflict: duplicate CMD.");
KeReleaseSpinLock(&pDevExt->AVCCmdLock, OldIrql);
KeReleaseMutex(&pDevExt->hMutexIssueAVCCmd, FALSE);
// ERROR_NOT_READY; device not ready for another command
return STATUS_DEVICE_NOT_READY;
}
pEntry = pEntry->Flink;
}
KeReleaseSpinLock(&pDevExt->AVCCmdLock, OldIrql);
// Create an AVC IRB and initialize it -
if(!(pAvcIrb = (AVC_COMMAND_IRB *) ExAllocatePool(NonPagedPool, sizeof(AVC_COMMAND_IRB)))) {
KeReleaseMutex(&pDevExt->hMutexIssueAVCCmd, FALSE);
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(pAvcIrb, sizeof(AVC_COMMAND_IRB));
pAvcIrb->Function = AVC_FUNCTION_COMMAND;
//
// Set the retry and timeout flag and value. These are adjusted (tuned) to
// some DV device that may not be "semi"-compliant (may take several reteies and
// may take more than 100msec)..
//
pAvcIrb->RetryFlag = 1; // Set to 1 in order to set Retries.
pAvcIrb->Retries = (UCHAR) pDevExt->AVCCmdRetries;
// - set the AVC command type (Control, Status, Notify, General Inquiry, Specific Inquiry)
pAvcIrb->CommandType = cType;
// - override the subunit address in the avc unit driver (if it even has one for us)
pAvcIrb->SubunitAddrFlag = 1;
pAvcIrb->SubunitAddr = &DVcrAVCCmdTable[idxAVCCmd].SubunitAddr;
pAvcIrb->Opcode = DVcrAVCCmdTable[idxAVCCmd].Opcode;
// - include alternate opcodes for the transport state opcode
if (pAvcIrb->Opcode == OPC_TRANSPORT_STATE) {
pAvcIrb->AlternateOpcodesFlag = 1;
pAvcIrb->AlternateOpcodes = pDevExt->TransportModes;
}
// - set up the operand list
pAvcIrb->OperandLength = DVcrAVCCmdTable[idxAVCCmd].OperandLength;
ASSERT(pAvcIrb->OperandLength <= MAX_AVC_OPERAND_BYTES);
RtlCopyMemory(pAvcIrb->Operands, DVcrAVCCmdTable[idxAVCCmd].Operands, pAvcIrb->OperandLength);
// Create an Irp and initialize it
if(!(pIrp = IoAllocateIrp(pDevExt->pBusDeviceObject->StackSize, FALSE))) {
ExFreePool(pAvcIrb); pAvcIrb = NULL;
KeReleaseMutex(&pDevExt->hMutexIssueAVCCmd, FALSE);
return STATUS_INSUFFICIENT_RESOURCES;
}
// Create an AVC Command entry and initialize it
if(!(pCmdEntry = (AVCCmdEntry *) ExAllocatePool(NonPagedPool, sizeof(AVCCmdEntry)))) {
ExFreePool(pAvcIrb); pAvcIrb = NULL;
IoFreeIrp(pIrp); pIrp = NULL;
KeReleaseMutex(&pDevExt->hMutexIssueAVCCmd, FALSE);
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(pCmdEntry, sizeof(AVCCmdEntry));
pCmdEntry->pDevExt = pDevExt; // So we can access pDevExt->AVCCmdList;
pCmdEntry->pProperty = pProperty;
pCmdEntry->cmdState = CMD_STATE_ISSUED;
pCmdEntry->Status = STATUS_UNSUCCESSFUL;
pCmdEntry->cmdType = cType;
pCmdEntry->OpCode = DVcrAVCCmdTable[idxAVCCmd].Opcode;
pCmdEntry->idxDVCRCmd = idxAVCCmd;
pCmdEntry->pAvcIrb = pAvcIrb;
pCmdEntry->pIrp = pIrp;
InitializeListHead(&pCmdEntry->ListEntry); // used as a flag for ownership
TRACE(TL_FCP_WARNING,("\'>>>> AVCCmd: %d:[%.2x %.2x %.2x %.2x]:[%.2x %.2x %.2x %.2x]\n",
pAvcIrb->OperandLength+3, // Resp+SuID+OpCd+Opr[]
cType,
pAvcIrb->SubunitAddr[0],
pAvcIrb->Opcode,
pAvcIrb->Operands[0],
pAvcIrb->Operands[1],
pAvcIrb->Operands[2],
pAvcIrb->Operands[3],
pAvcIrb->Operands[4]
));
// Finish initializing the Irp
NextIrpStack = IoGetNextIrpStackLocation(pIrp);
NextIrpStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
NextIrpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_AVC_CLASS;
NextIrpStack->Parameters.Others.Argument1 = pAvcIrb;
IoSetCompletionRoutine(pIrp, DVIssueAVCCommandCR, pCmdEntry, TRUE, TRUE, TRUE);
pIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
// Used to monitor response time of an AVC command
tmStart = GetSystemTime();
// Now make the call
// If encounter an interim response, STATUS_PENDING will be returned.
Status =
IoCallDriver(
pDevExt->pBusDeviceObject,
pIrp
);
dwElapsed = (DWORD) ((GetSystemTime() - tmStart)/10000); // Convert 100nsec unit to msec
#if DBG
if(dwElapsed > MAX_RESPONSE_TIME_FOR_ALERT) {
// NON-compliant behaviour
TRACE(TL_FCP_WARNING,("** ST:%x; AVC Cmd took %d msec to response; CmdType:%d; OpCd:%x\n", Status, dwElapsed, cType, DVcrAVCCmdTable[idxAVCCmd].Opcode));
} else {
TRACE(TL_FCP_TRACE,("** ST:%x; AVC Cmd took %d msec to response; CmdType:%d; OpCd:%x\n", Status, dwElapsed, cType, DVcrAVCCmdTable[idxAVCCmd].Opcode));
}
#endif
#ifdef SUPPORT_OPTIMIZE_AVCCMD_RETRIES
//
// Collect statistics of AVC command response time during driver loading phase
//
if(!pDevExt->DrvLoadCompleted) {
if(dwElapsed > pDevExt->AVCCmdRespTimeMax)
pDevExt->AVCCmdRespTimeMax = dwElapsed;
if(dwElapsed < pDevExt->AVCCmdRespTimeMin)
pDevExt->AVCCmdRespTimeMin = dwElapsed;
pDevExt->AVCCmdRespTimeSum += dwElapsed;
pDevExt->AVCCmdCount++;
}
#endif
// Interim response...
if (STATUS_PENDING == Status) {
// WORKITEM: control command can be in interim for a while!!!
// Some DV will return interim but it will completed it with a change quickly.
if(cType == AVC_CTYPE_CONTROL) {
#define MSDV_WAIT_CONTROL_CMD_INTERIM 300
TRACE(TL_FCP_WARNING,("\'!!!!!!!!!!! Control Interim-- Wait %d msec !!!!!!!!\n", MSDV_WAIT_CONTROL_CMD_INTERIM));
DVDelayExecutionThread(MSDV_WAIT_CONTROL_CMD_INTERIM);
#if DBG
if(DVTraceMask & TL_FCP_TRACE) {
ASSERT(!IsListEmpty(&pCmdEntry->ListEntry) && "Control Cmd was interim after wait.");
}
#endif
}
KeAcquireSpinLock(&pDevExt->AVCCmdLock, &OldIrql);
// Check that the Irp didn't complete between the return of IoCallDriver and now
if (IsListEmpty(&pCmdEntry->ListEntry)) {
// Enter INTERIM state
pCmdEntry->cmdState = CMD_STATE_RESP_INTERIM;
// Return STATUS_MORE_ENTRIES to inform caller that the command is pending.
pCmdEntry->Status = STATUS_MORE_ENTRIES; // xlate to ERROR_MORE_DATA; No yet done with this command so keep the entry in the list
// We have submitted a control or notify command, and have gotten
// an Interim response. Put the command in the list so it can be
// tracked for possible cancellation, and as an indication to the
// completion routine that we won't be releasing any resources here.
InsertTailList(&pDevExt->AVCCmdList, &pCmdEntry->ListEntry); pDevExt->cntCommandQueued++;
pCmdEntry->pProperty = NULL; // won't be using this, so get rid of it
TRACE(TL_FCP_TRACE,("\'->AVC command Irp is pending!\n"));
KeReleaseSpinLock(&pDevExt->AVCCmdLock, OldIrql);
KeReleaseMutex(&pDevExt->hMutexIssueAVCCmd, FALSE);
return pCmdEntry->Status;
} else {
// Although IoCallDriver indicated that the command was pending,
// it has since been completed. The completion routine saw that
// the command entry had not yet been added to the command list,
// so put it there to let us know that we need to retain control
// and free the resources.
//
// Temporarily change the status so the cleanup code path will
// be followed.
TRACE(TL_FCP_TRACE,("\'-> Cmd Rtns Pending but completed; treat as non-pending! ST:%x\n", pCmdEntry->Status));
Status = STATUS_SUCCESS;
}
KeReleaseSpinLock(&pDevExt->AVCCmdLock, OldIrql);
}
// Status from IoCallDriver can return:
// STATUS_PENDING (process above) // If control, we wait and see if it get completed (risky!!)
// STATUS_TIMEOUT
// STATUS_SUCCESS
if(STATUS_PENDING != Status) {
// The completion routine is usually the only one that frees the Irp. Is
// it possible that the completion routine never got called? This will let
// us know, since the completion routine will always make sure that the
// command entry's Irp pointer is cleared.
if(pCmdEntry->pIrp) {
// If for some reason the completion routine never got called, free the Irp
if(pCmdEntry->pIrp)
IoFreeIrp(pCmdEntry->pIrp);
pCmdEntry->pIrp = NULL;
}
}
//
// pCmdEntry->Status is the command response Status set in the completion routine, which can be
// STATUS_SUCCESS
// STATUS_REQ_NOT_ACCEP
// STATUS_NOT_SUPPORTED
// STATUS_MORE_ENTRIES // Should not happen!!
// STATUS_REQUEST_ABORTED
//
// One possible valid command from IoCallDriver is STATUS_TIMEOUT, and
// this shoull be returned, anything else we will get the status from pCmdEntry->Status
// which was set in the completion routine.
if (Status != STATUS_TIMEOUT)
Status = pCmdEntry->Status; // This Status is being returned from this functino
// Desiding if leaving the command response (entry) in the command list
#ifndef ALWAYS_SET_N_GET_RAW_AVC
// Not if it is an (1) interim (all STATUS_MORE_ENTRIES); or (2) suceeded RAW AVC response
if(STATUS_MORE_ENTRIES == Status ||
VCR_RAW_AVC == pCmdEntry->idxDVCRCmd && STATUS_SUCCESS == Status) {
#else
// Do not remove entrim response or any RAW AVC command response
if(STATUS_MORE_ENTRIES == Status ||
VCR_RAW_AVC == pCmdEntry->idxDVCRCmd) {
#endif
TRACE(TL_FCP_WARNING,("\'Status:%x; Do not remove (1) interim response or (2) raw AVC command\n", Status));
}
// Else we are done!
else {
// It's time to clean up the command
KeAcquireSpinLock(&pDevExt->AVCCmdLock, &OldIrql);
if (!IsListEmpty(&pCmdEntry->ListEntry)) {
RemoveEntryList(&pCmdEntry->ListEntry); pDevExt->cntCommandQueued--;
InitializeListHead(&pCmdEntry->ListEntry); // used as a flag for ownership
}
KeReleaseSpinLock(&pDevExt->AVCCmdLock, OldIrql);
// Free the resources
ExFreePool(pCmdEntry);
ExFreePool(pAvcIrb);
} // else
#if DBG
if(!NT_SUCCESS(Status)) {
TRACE(TL_FCP_WARNING,("\'**** DVIssueAVCCmd (exit): St:%x; pCmdEntry:%x; cmdQueued:%d\n", Status, pCmdEntry, pDevExt->cntCommandQueued));
}
#endif
KeReleaseMutex(&pDevExt->hMutexIssueAVCCmd, FALSE);
return Status;
}
#ifndef OATRUE
#define OATRUE (-1)
#endif
#ifndef OAFALSE
#define OAFALSE (0)
#endif
NTSTATUS
DVGetExtDeviceProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
OUT PULONG pulActualBytesTransferred
)
/*++
Routine Description:
Handle Get external device property.
Arguments:
pDevExt - Device's extension
pSPD - Stream property descriptor
pulActualBytesTransferred - Number of byte transferred.
Return Value:
NTSTATUS
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PKSPROPERTY_EXTDEVICE_S pExtDeviceProperty;
PAGED_CODE();
ASSERT(pDevExt);
ASSERT(pSPD);
ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_EXTDEVICE_S));
pExtDeviceProperty = (PKSPROPERTY_EXTDEVICE_S) pSPD->PropertyInfo; // pointer to the data
switch (pSPD->Property->Id) {
case KSPROPERTY_EXTDEVICE_ID:
if(pDevExt->ulVendorID) {
// It was not bswap in the monolithic version so for competibility,
// we will not bswap this.
pExtDeviceProperty->u.NodeUniqueID[0] = pDevExt->UniqueID.LowPart;
pExtDeviceProperty->u.NodeUniqueID[1] = pDevExt->UniqueID.HighPart;
// TRACE(TL_FCP_WARNING,("Vid:%x; Mid:%x\n", bswap(pDevExt->ulVendorID) >> 8, pDevExt->ulModelID ));
TRACE(TL_FCP_WARNING,("\'Low:%x; High:%x of UniqueID\n", pDevExt->UniqueID.LowPart, pDevExt->UniqueID.HighPart ));
Status = STATUS_SUCCESS;
} else {
TRACE(TL_FCP_ERROR,("Failed: Vid:%x; Mid:%x\n", bswap(pDevExt->ulVendorID) >> 8, pDevExt->ulModelID ));
Status = STATUS_UNSUCCESSFUL;
}
break;
case KSPROPERTY_EXTDEVICE_VERSION:
// AV/C VCR Subunit Specification 2.0.1
wcscpy(pExtDeviceProperty->u.pawchString, L"2.0.1");
Status = STATUS_SUCCESS;
break;
case KSPROPERTY_EXTDEVICE_POWER_STATE:
switch(pDevExt->PowerState) {
case PowerDeviceD3:
pExtDeviceProperty->u.PowerState = ED_POWER_OFF;
break;
case PowerDeviceD2:
case PowerDeviceD1:
pExtDeviceProperty->u.PowerState = ED_POWER_STANDBY;
break;
default:
case PowerDeviceD0:
pExtDeviceProperty->u.PowerState = ED_POWER_ON;
break;
}
Status = STATUS_SUCCESS;
break;
case KSPROPERTY_EXTDEVICE_PORT:
pExtDeviceProperty->u.DevPort = DEV_PORT_1394;
Status = STATUS_SUCCESS;
break;
case KSPROPERTY_EXTDEVICE_CAPABILITIES:
if((GetSystemTime() - pDevExt->tmLastFormatUpdate) > FORMAT_UPDATE_INTERVAL) {
// Refresh mode of operation whenever capabilities is queried
// since the mode of operation might have changed and is returned..
DVGetDevModeOfOperation(pDevExt);
// Since format can dynamically change, we will query new format here.
// Note: during data intersection, we compare FrameSize and that is
// format related.
if(!DVGetDevSignalFormat(pDevExt, KSPIN_DATAFLOW_OUT,0)) {
// If querying its format has failed, we cannot open this stream.
TRACE(TL_FCP_WARNING,("SRB_GET_DATA_INTERSECTION:Failed getting signal format.\n"));
}
// Update system time to reflect last update
pDevExt->tmLastFormatUpdate = GetSystemTime();
}
// Can record only in VCR mode and has input plug(s).
pExtDeviceProperty->u.Capabilities.CanRecord = ((pDevExt->ulDevType == ED_DEVTYPE_VCR) ? (pDevExt->NumInputPlugs > 0 ? OATRUE : OAFALSE): OAFALSE);
pExtDeviceProperty->u.Capabilities.CanRecordStrobe = OAFALSE;
pExtDeviceProperty->u.Capabilities.HasAudio = OATRUE;
pExtDeviceProperty->u.Capabilities.HasVideo = OATRUE;
pExtDeviceProperty->u.Capabilities.UsesFiles = OAFALSE;
pExtDeviceProperty->u.Capabilities.CanSave = OAFALSE;
pExtDeviceProperty->u.Capabilities.DeviceType = pDevExt->ulDevType;
pExtDeviceProperty->u.Capabilities.TCRead = OATRUE;
pExtDeviceProperty->u.Capabilities.TCWrite = OAFALSE; // DV decided
pExtDeviceProperty->u.Capabilities.CTLRead = OAFALSE;
pExtDeviceProperty->u.Capabilities.IndexRead = OAFALSE;
pExtDeviceProperty->u.Capabilities.Preroll = 0L; // NOT implemented, supposely can reg in INF and then read from registry
pExtDeviceProperty->u.Capabilities.Postroll = 0L; // NOT implemented, supposely can reg in INF and then read from registry
pExtDeviceProperty->u.Capabilities.SyncAcc = ED_CAPABILITY_UNKNOWN;
pExtDeviceProperty->u.Capabilities.NormRate = ((pDevExt->VideoFormatIndex == FMT_IDX_SD_DVCR_NTSC || pDevExt->VideoFormatIndex == FMT_IDX_SDL_DVCR_NTSC) ? ED_RATE_2997 : ED_RATE_25);
pExtDeviceProperty->u.Capabilities.CanPreview = OAFALSE; // View what is in the bus or tape
pExtDeviceProperty->u.Capabilities.CanMonitorSrc = OATRUE; // ViewFinder
pExtDeviceProperty->u.Capabilities.CanTest = OAFALSE; // To see if a function is iplemented
pExtDeviceProperty->u.Capabilities.VideoIn = OAFALSE;
pExtDeviceProperty->u.Capabilities.AudioIn = OAFALSE;
pExtDeviceProperty->u.Capabilities.Calibrate = OAFALSE;
pExtDeviceProperty->u.Capabilities.SeekType = ED_CAPABILITY_UNKNOWN;
TRACE(TL_FCP_INFO,("\'DVCRGetExtDeviceProperty: DeviceType %x\n", pExtDeviceProperty->u.Capabilities.DeviceType));
Status = STATUS_SUCCESS;
break;
default:
Status = STATUS_NOT_SUPPORTED;
break;
}
*pulActualBytesTransferred = (Status == STATUS_SUCCESS ? sizeof (KSPROPERTY_EXTDEVICE_S) : 0);
return Status;
}
NTSTATUS
DVSetExtDeviceProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
OUT ULONG *pulActualBytesTransferred
)
/*++
Routine Description:
Handle Set external device property.
Arguments:
pDevExt - Device's extension
pSPD - Stream property descriptor
pulActualBytesTransferred - Number of byte transferred.
Return Value:
NTSTATUS
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PKSPROPERTY_EXTDEVICE_S pExtDeviceProperty;
PAGED_CODE();
ASSERT(pDevExt);
ASSERT(pSPD);
ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_EXTDEVICE_S));
pExtDeviceProperty = (PKSPROPERTY_EXTDEVICE_S) pSPD->PropertyInfo; // pointer to the data
switch (pSPD->Property->Id) {
default:
Status = STATUS_NOT_SUPPORTED;
break;
}
*pulActualBytesTransferred = (Status == STATUS_SUCCESS ? sizeof (KSPROPERTY_EXTDEVICE_S) : 0);
return Status;
}
NTSTATUS
DVGetExtTransportProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
OUT ULONG *pulActualBytesTransferred
)
/*++
Routine Description:
Handle Get external transport property.
Arguments:
pDevExt - Device's extension
pSPD - Stream property descriptor
pulActualBytesTransferred - Number of byte transferred.
Return Value:
NTSTATUS
--*/
{
NTSTATUS Status = STATUS_NOT_SUPPORTED;
PKSPROPERTY_EXTXPORT_S pXPrtProperty;
DVCR_AVC_COMMAND idxDVCRCmd;
AvcCommandType cType = AVC_CTYPE_STATUS;
BOOL bHasTape = pDevExt->bHasTape;
PAVCCmdEntry pCmdEntry;
PAGED_CODE();
ASSERT(pDevExt);
ASSERT(pSPD);
ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_EXTXPORT_S));
pXPrtProperty = (PKSPROPERTY_EXTXPORT_S) pSPD->PropertyInfo; // pointer to the data
*pulActualBytesTransferred = 0;
switch (pSPD->Property->Id) {
case KSPROPERTY_EXTXPORT_CAPABILITIES:
return STATUS_NOT_IMPLEMENTED;
case KSPROPERTY_RAW_AVC_CMD:
pCmdEntry = DVCRFindCmdEntryCompleted(
pDevExt,
VCR_RAW_AVC,
DVcrAVCCmdTable[VCR_RAW_AVC].Opcode,
DVcrAVCCmdTable[VCR_RAW_AVC].CType
);
if(pCmdEntry) {
PAVC_COMMAND_IRB pAvcIrb;
pAvcIrb = pCmdEntry->pAvcIrb;
ASSERT(pAvcIrb);
#ifndef ALWAYS_SET_N_GET_RAW_AVC
// Only successful response has a valid response to return
if (pCmdEntry->cmdState == CMD_STATE_RESP_ACCEPTED) {
#else
// Any of these response codes has a response to return,
// include "reject", "not implemented" response code
if (pCmdEntry->cmdState == CMD_STATE_RESP_ACCEPTED ||
pCmdEntry->cmdState == CMD_STATE_RESP_REJECTED ||
pCmdEntry->cmdState == CMD_STATE_RESP_NOT_IMPL ||
pCmdEntry->cmdState == CMD_STATE_RESP_INTERIM) {
#endif
// bytes for operands plus response, subunit addr, and opcode
pXPrtProperty->u.RawAVC.PayloadSize = pAvcIrb->OperandLength + 3;
pXPrtProperty->u.RawAVC.Payload[0] = pAvcIrb->ResponseCode;
pXPrtProperty->u.RawAVC.Payload[1] = pAvcIrb->SubunitAddr[0];
pXPrtProperty->u.RawAVC.Payload[2] = pAvcIrb->Opcode;
RtlCopyMemory(&pXPrtProperty->u.RawAVC.Payload[3], pAvcIrb->Operands, pAvcIrb->OperandLength);
TRACE(TL_FCP_WARNING,("\'RawAVCResp: pEntry:%x; State:%x; Status:%x; Sz:%d; Rsp:%x;SuId:%x;OpCd:%x; Opr:[%x %x %x %x]\n",
pCmdEntry, pCmdEntry->cmdState, pCmdEntry->Status,
pXPrtProperty->u.RawAVC.PayloadSize,
pXPrtProperty->u.RawAVC.Payload[0],
pXPrtProperty->u.RawAVC.Payload[1],
pXPrtProperty->u.RawAVC.Payload[2],
pXPrtProperty->u.RawAVC.Payload[3],
pXPrtProperty->u.RawAVC.Payload[4],
pXPrtProperty->u.RawAVC.Payload[5],
pXPrtProperty->u.RawAVC.Payload[6]
));
// Final Status
#ifndef ALWAYS_SET_N_GET_RAW_AVC
Status = pCmdEntry->Status;
#else
// If not success, bytes transferred and data will not returned!
Status = STATUS_SUCCESS;
#endif
*pulActualBytesTransferred = sizeof (KSPROPERTY_EXTXPORT_S);
} else {
TRACE(TL_FCP_ERROR,("\'RawAVCResp: Found; but pCmdEntry:%x, unexpected cmdState:%d; ST:%x\n", pCmdEntry, pCmdEntry->cmdState, pCmdEntry->Status));
//ASSERT(pCmdEntry->cmdState == CMD_STATE_RESP_ACCEPTED && "Unexpected command state\n");
if(pCmdEntry->Status == STATUS_TIMEOUT)
Status = STATUS_TIMEOUT; // if timeout, application may want to try again.
else
Status = STATUS_REQUEST_ABORTED;
*pulActualBytesTransferred = 0;
}
// pIrp is NULL if it has been completed.
if(pCmdEntry->pIrp) {
TRACE(TL_FCP_ERROR,("RawAVCResp: pCmdEntry %x; ->pIrp:%x not completd yet!\n", pCmdEntry, pCmdEntry->pIrp));
ASSERT(pCmdEntry->pIrp == NULL && "pIrp is not completed!");
IoCancelIrp(pCmdEntry->pIrp);
}
// Not used in the completion routine if pIrp->Cancel
ExFreePool(pCmdEntry);
ExFreePool(pAvcIrb);
}
else {
TRACE(TL_FCP_ERROR,("\'RAW_AVC_CMD, did not find a match[%x]!\n",
*((DWORD *) &DVcrAVCCmdTable[VCR_RAW_AVC].CType) ));
*pulActualBytesTransferred = 0;
Status = STATUS_NOT_FOUND; // ERROR_MR_MID_NOT_FOUND
}
return Status;
case KSPROPERTY_EXTXPORT_INPUT_SIGNAL_MODE: // MPEG, D-VHS, Analog VHS etc.
idxDVCRCmd = VCR_INPUT_SIGNAL_MODE;
break;
case KSPROPERTY_EXTXPORT_OUTPUT_SIGNAL_MODE: // MPEG, D-VHS, Analog VHS etc.
idxDVCRCmd = VCR_OUTPUT_SIGNAL_MODE;
break;
case KSPROPERTY_EXTXPORT_MEDIUM_INFO: // cassettte_type and tape_grade_and_write_protect
idxDVCRCmd = VCR_MEDIUM_INFO;
break;
case KSPROPERTY_EXTXPORT_STATE:
idxDVCRCmd = VCR_TRANSPORT_STATE;
break;
case KSPROPERTY_EXTXPORT_STATE_NOTIFY:
// Get final result from previous set command
pCmdEntry = DVCRFindCmdEntryCompleted(
pDevExt,
VCR_TRANSPORT_STATE_NOTIFY,
DVcrAVCCmdTable[VCR_TRANSPORT_STATE_NOTIFY].Opcode,
DVcrAVCCmdTable[VCR_TRANSPORT_STATE_NOTIFY].CType
);
if(pCmdEntry) {
PAVC_COMMAND_IRB pAvcIrb;
pAvcIrb = pCmdEntry->pAvcIrb;
ASSERT(pCmdEntry->pAvcIrb);
TRACE(TL_FCP_WARNING,("\'->Notify Resp: pCmdEntry:%x; pIrb:%x; %d:[%.2x %.2x %.2x %.2x]\n",
pCmdEntry, pAvcIrb,
pAvcIrb->OperandLength + 3,
pAvcIrb->ResponseCode,
pAvcIrb->SubunitAddr[0],
pAvcIrb->Opcode,
pAvcIrb->Operands[0]
));
if(pCmdEntry->cmdState == CMD_STATE_RESP_ACCEPTED)
Status =
DVCRXlateRawAVC(
pCmdEntry,
pXPrtProperty
);
// pIrp is NULL if it has been completed.
if(pCmdEntry->pIrp) {
TRACE(TL_FCP_ERROR,("XPrtNotifyResp: pCmdEntry %x; ->pIrp:%x not completed; IoCancelIrp(pIrp)\n", pCmdEntry, pCmdEntry->pIrp));
IoCancelIrp(pCmdEntry->pIrp);
}
// These two are not touched in the CompletionRoutine if pIrp->Cancel
ExFreePool(pCmdEntry);
ExFreePool(pAvcIrb);
*pulActualBytesTransferred = STATUS_SUCCESS == Status ? sizeof (KSPROPERTY_EXTXPORT_S) : 0;
}
else {
TRACE(TL_FCP_ERROR,("EXTXPORT_STATE_NOTIFY: no match!\n"));
*pulActualBytesTransferred = 0;
Status = STATUS_NOT_FOUND; // ERROR_MR_MID_NOT_FOUND
}
return Status;
default:
TRACE(TL_FCP_ERROR,("DVCRGetExtTransportProperty: NOT_IMPLEMENTED Property->Id %d\n", pSPD->Property->Id));
return STATUS_NOT_SUPPORTED;
}
Status = DVIssueAVCCommand(pDevExt, cType, idxDVCRCmd, (PVOID) pXPrtProperty);
TRACE(TL_FCP_TRACE,("\'DVCRGetExtTransportProperty: idxDVCRCmd %d, cmdType %d, Status %x\n", idxDVCRCmd, cType, Status));
*pulActualBytesTransferred = (Status == STATUS_SUCCESS ? sizeof (KSPROPERTY_EXTXPORT_S) : 0);
if(STATUS_SUCCESS == Status &&
idxDVCRCmd == VCR_MEDIUM_INFO) {
// Update Media info
pDevExt->bHasTape = pXPrtProperty->u.MediumInfo.MediaPresent;
pDevExt->bWriteProtected = pXPrtProperty->u.MediumInfo.RecordInhibit;
TRACE(TL_FCP_TRACE,("\'bHasTape: IN(%d):OUT(%d), ulDevType %d\n", bHasTape, pDevExt->bHasTape, pDevExt->ulDevType));
}
return Status;
}
NTSTATUS
DVSetExtTransportProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
OUT ULONG *pulActualBytesTransferred
)
/*++
Routine Description:
Handle Set external transport property.
Arguments:
pDevExt - Device's extension
pSPD - Stream property descriptor
pulActualBytesTransferred - Number of byte transferr
Return Value:
NTSTATUS
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PKSPROPERTY_EXTXPORT_S pXPrtProperty;
DVCR_AVC_COMMAND idxDVCRCmd;
AvcCommandType cType = AVC_CTYPE_CONTROL;
PAGED_CODE();
ASSERT(pDevExt);
ASSERT(pSPD);
ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_EXTXPORT_S));
pXPrtProperty = (PKSPROPERTY_EXTXPORT_S) pSPD->PropertyInfo; // pointer to the data
*pulActualBytesTransferred = 0;
switch (pSPD->Property->Id) {
case KSPROPERTY_EXTXPORT_STATE:
switch (pXPrtProperty->u.XPrtState.Mode) {
// RECORD
case ED_MODE_RECORD:
idxDVCRCmd = VCR_RECORD;
break;
case ED_MODE_RECORD_FREEZE:
idxDVCRCmd = VCR_RECORD_PAUSE;
break;
// PLAY
case ED_MODE_STEP_FWD:
idxDVCRCmd = VCR_PLAY_FORWARD_STEP;
break;
case ED_MODE_PLAY_SLOWEST_FWD:
// DVCPRO does not seem to support the standard play slow fwd so this is an alternate
if(pDevExt->bDVCPro)
idxDVCRCmd = VCR_PLAY_FORWARD_SLOWEST2;
else
idxDVCRCmd = VCR_PLAY_FORWARD_SLOWEST;
break;
case ED_MODE_PLAY_FASTEST_FWD:
idxDVCRCmd = VCR_PLAY_FORWARD_FASTEST;
break;
case ED_MODE_STEP_REV:
idxDVCRCmd = VCR_PLAY_REVERSE_STEP;
break;
case ED_MODE_PLAY_SLOWEST_REV:
// DVCPRO does not seem to support the standard play slow rev so this is an alternate
if(pDevExt->bDVCPro)
idxDVCRCmd = VCR_PLAY_REVERSE_SLOWEST2;
else
idxDVCRCmd = VCR_PLAY_REVERSE_SLOWEST;
break;
case ED_MODE_PLAY_FASTEST_REV:
idxDVCRCmd = VCR_PLAY_REVERSE_FASTEST;
break;
case ED_MODE_PLAY:
idxDVCRCmd = VCR_PLAY_FORWARD;
break;
case ED_MODE_FREEZE:
idxDVCRCmd = VCR_PLAY_FORWARD_PAUSE;
break;
// WIND
case ED_MODE_STOP:
idxDVCRCmd = VCR_WIND_STOP;
break;
case ED_MODE_FF:
idxDVCRCmd = VCR_WIND_FAST_FORWARD;
break;
case ED_MODE_REW:
idxDVCRCmd = VCR_WIND_REWIND;
break;
default:
TRACE(TL_FCP_ERROR,("XPrtState.Mode %d not supported\n", pXPrtProperty->u.XPrtState.Mode));
return STATUS_NOT_SUPPORTED;
}
break;
case KSPROPERTY_EXTXPORT_STATE_NOTIFY:
idxDVCRCmd = VCR_TRANSPORT_STATE_NOTIFY;
cType = AVC_CTYPE_NOTIFY;
TRACE(TL_FCP_TRACE,("\'->Notify XPrt State Cmd issued.\n"));
break;
case KSPROPERTY_EXTXPORT_LOAD_MEDIUM:
idxDVCRCmd = VCR_LOAD_MEDIUM_EJECT;
break;
case KSPROPERTY_EXTXPORT_TIMECODE_SEARCH:
idxDVCRCmd = VCR_TIMECODE_SEARCH;
TRACE(TL_FCP_WARNING,("\'KSPROPERTY_EXTXPORT_TIMECODE_SEARCH NOT_SUPPORTED\n"));
*pulActualBytesTransferred = 0;
return STATUS_NOT_SUPPORTED;
case KSPROPERTY_EXTXPORT_ATN_SEARCH:
idxDVCRCmd = VCR_ATN_SEARCH;
TRACE(TL_FCP_WARNING,("\'KSPROPERTY_EXTXPORT_ATN_SEARCH NOT_SUPPORTED\n"));
*pulActualBytesTransferred = 0;
return STATUS_NOT_SUPPORTED;
case KSPROPERTY_EXTXPORT_RTC_SEARCH:
idxDVCRCmd = VCR_RTC_SEARCH;
TRACE(TL_FCP_WARNING,("\'KSPROPERTY_EXTXPORT_RTC_SEARCH NOT_SUPPORTED\n"));
*pulActualBytesTransferred = 0;
return STATUS_NOT_SUPPORTED;
case KSPROPERTY_RAW_AVC_CMD:
idxDVCRCmd = VCR_RAW_AVC;
if(pXPrtProperty->u.RawAVC.PayloadSize <= MAX_FCP_PAYLOAD_SIZE) {
DVcrAVCCmdTable[idxDVCRCmd].CType = pXPrtProperty->u.RawAVC.Payload[0];
DVcrAVCCmdTable[idxDVCRCmd].SubunitAddr = pXPrtProperty->u.RawAVC.Payload[1];
DVcrAVCCmdTable[idxDVCRCmd].Opcode = pXPrtProperty->u.RawAVC.Payload[2];
DVcrAVCCmdTable[idxDVCRCmd].OperandLength = pXPrtProperty->u.RawAVC.PayloadSize - 3;
RtlCopyMemory(DVcrAVCCmdTable[idxDVCRCmd].Operands, pXPrtProperty->u.RawAVC.Payload + 3, DVcrAVCCmdTable[idxDVCRCmd].OperandLength);
// extract command type; for RAW AVC, it can be anything.
cType = pXPrtProperty->u.RawAVC.Payload[0];
TRACE(TL_FCP_WARNING,("\'DVCRSetExtTransportProperty: Set*, cType %x, PayLoadSize %d, PayLoad %x %x %x %x\n",
cType,
pXPrtProperty->u.RawAVC.PayloadSize,
pXPrtProperty->u.RawAVC.Payload[0],
pXPrtProperty->u.RawAVC.Payload[1],
pXPrtProperty->u.RawAVC.Payload[2],
pXPrtProperty->u.RawAVC.Payload[3]
));
} else {
Status = STATUS_INVALID_PARAMETER;
*pulActualBytesTransferred = 0;
return Status;
}
break;
default:
TRACE(TL_FCP_ERROR,("DVCRSetExtTransportProperty: NOT_IMPLEMENTED Property->Id %d\n", pSPD->Property->Id));
return STATUS_NOT_SUPPORTED;
}
Status = DVIssueAVCCommand(pDevExt, cType, idxDVCRCmd, (PVOID) pXPrtProperty);
#ifdef SUPPORT_XPRT_STATE_WAIT_FOR_STABLE
#ifdef READ_CUTOMIZE_REG_VALUES
// Wait for the transport state change to be stablized.
// This is only necessary for DV camcorder that reject (or not accept) command following
// a transport state change. Most of application will issue a transport state control
// command follows by a query transport state status command. The later command usually
// failed. A wait will allow some time for the transport mechanism to stablized and therefore
// accepting command again. This ought to be done in a registry set in an INF file.
if(STATUS_SUCCESS == Status &&
(KSPROPERTY_EXTXPORT_STATE == pSPD->Property->Id ||
(VCR_RAW_AVC == pSPD->Property->Id && cType == AVC_CTYPE_CONTROL &&
(pXPrtProperty->u.RawAVC.Payload[2] == OPC_RECORD ||
pXPrtProperty->u.RawAVC.Payload[2] == OPC_PLAY ||
pXPrtProperty->u.RawAVC.Payload[2] == OPC_WIND
)
)
)
) {
#define MAX_XPRT_WAIT 5000
if(pDevExt->XprtStateChangeWait > MAX_XPRT_WAIT)
pDevExt->XprtStateChangeWait = MAX_XPRT_WAIT;
if(pDevExt->XprtStateChangeWait > 0) {
TRACE(TL_FCP_WARNING,("^^^^^^ Delay %d msec for Xprt state to stablized!^^^^^^\n", pDevExt->XprtStateChangeWait));
DVDelayExecutionThread(pDevExt->XprtStateChangeWait);
}
}
#endif
#endif
TRACE(TL_FCP_TRACE,("\'DVCRSetExtTransportProperty: idxDVCRCmd %d, Status %x\n", idxDVCRCmd, Status));
*pulActualBytesTransferred = (Status == STATUS_SUCCESS ? sizeof (PKSPROPERTY_EXTXPORT_S) : 0);
return Status;
}
NTSTATUS
DVGetTimecodeReaderProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
OUT PULONG pulActualBytesTransferred
)
/*++
Routine Description:
Arguments:
Return Value:
NTSTATUS
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PKSPROPERTY_TIMECODE_S pTmCdReaderProperty;
DVCR_AVC_COMMAND idxDVCRCmd;
PAGED_CODE();
ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_TIMECODE_S));
pTmCdReaderProperty = (PKSPROPERTY_TIMECODE_S) pSPD->PropertyInfo; // pointer to the data
*pulActualBytesTransferred = 0;
switch (pSPD->Property->Id) {
case KSPROPERTY_TIMECODE_READER:
idxDVCRCmd = VCR_TIMECODE_READ;
#ifdef MSDV_SUPPORT_EXTRACT_SUBCODE_DATA
// There can only be one active stream.
if(pDevExt->cndStrmOpen == 1 &&
pDevExt->paStrmExt[pDevExt->idxStreamNumber]->StreamState == KSSTATE_RUN) {
if(pDevExt->paStrmExt[pDevExt->idxStreamNumber]->bTimecodeUpdated) {
// Once it is read, it is stale.
pDevExt->paStrmExt[pDevExt->idxStreamNumber]->bTimecodeUpdated = FALSE;
pTmCdReaderProperty->TimecodeSamp.timecode.dwFrames =
(((DWORD) pDevExt->paStrmExt[pDevExt->idxStreamNumber]->Timecode[0]) << 24) |
(((DWORD) pDevExt->paStrmExt[pDevExt->idxStreamNumber]->Timecode[1]) << 16) |
(((DWORD) pDevExt->paStrmExt[pDevExt->idxStreamNumber]->Timecode[2]) << 8) |
((DWORD) pDevExt->paStrmExt[pDevExt->idxStreamNumber]->Timecode[3]);
*pulActualBytesTransferred = (Status == STATUS_SUCCESS ? sizeof (KSPROPERTY_TIMECODE_S) : 0);
return STATUS_SUCCESS;
}
else {
TRACE(TL_FCP_TRACE,("\'bTimecode stale, issue AVC command to read it.\n"));
}
}
#endif
break;
case KSPROPERTY_ATN_READER:
idxDVCRCmd = VCR_ATN_READ;
#ifdef MSDV_SUPPORT_EXTRACT_SUBCODE_DATA
// There can only be one active stream.
if(pDevExt->cndStrmOpen == 1 &&
pDevExt->paStrmExt[pDevExt->idxStreamNumber]->StreamState == KSSTATE_RUN) {
if(pDevExt->paStrmExt[pDevExt->idxStreamNumber]->bATNUpdated) {
// Once it is read, it is stale.
pDevExt->paStrmExt[pDevExt->idxStreamNumber]->bATNUpdated = FALSE;
pTmCdReaderProperty->TimecodeSamp.timecode.dwFrames =
pDevExt->paStrmExt[pDevExt->idxStreamNumber]->AbsTrackNumber >> 1;
pTmCdReaderProperty->TimecodeSamp.dwUser =
pDevExt->paStrmExt[pDevExt->idxStreamNumber]->AbsTrackNumber & 0x00000001;
*pulActualBytesTransferred = (Status == STATUS_SUCCESS ? sizeof (KSPROPERTY_TIMECODE_S) : 0);
return STATUS_SUCCESS;
}
else {
TRACE(TL_FCP_WARNING,("\'bATN stale, issue AVC command to read it.\n"));
}
}
#endif
break;
case KSPROPERTY_RTC_READER:
idxDVCRCmd = VCR_RTC_READ;
break;
default:
TRACE(TL_FCP_ERROR,("DVCRGetTimecodeReaderProperty: NOT_IMPLEMENTED Property->Id %d\n", pSPD->Property->Id));
return STATUS_NOT_SUPPORTED;
}
Status =
DVIssueAVCCommand(
pDevExt,
AVC_CTYPE_STATUS,
idxDVCRCmd,
(PVOID) pTmCdReaderProperty
);
TRACE(TL_FCP_TRACE,("\'DVCRGetTimecodeReaderProperty: idxDVCRCmd %d, Status %x\n", idxDVCRCmd, Status));
*pulActualBytesTransferred = (Status == STATUS_SUCCESS ? sizeof (KSPROPERTY_TIMECODE_S) : 0);
return Status;
}
NTSTATUS
DVMediaSeekingProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
OUT PULONG pulActualBytesTransferred
)
/*++
Routine Description:
Arguments:
Return Value:
NTSTATUS
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
GUID * pTimeFormatGuid;
KSMULTIPLE_ITEM * pMultipleItem;
PAGED_CODE();
*pulActualBytesTransferred = 0;
switch (pSPD->Property->Id) {
case KSPROPERTY_MEDIASEEKING_FORMATS:
// Its is KSMULTIPLE_ITEM so it is a two step process to return the data:
// (1) return size in pActualBytesTransferred with STATUS_BUFFER_OVERFLOW
// (2) 2nd time to get its actual data.
if(pSPD->PropertyOutputSize == 0) {
*pulActualBytesTransferred = sizeof(KSMULTIPLE_ITEM) + sizeof(GUID);
Status = STATUS_BUFFER_OVERFLOW;
} else if(pSPD->PropertyOutputSize >= (sizeof(KSMULTIPLE_ITEM) + sizeof(GUID))) {
pMultipleItem = (KSMULTIPLE_ITEM *) pSPD->PropertyInfo; // pointer to the data
pMultipleItem->Count = 1;
pMultipleItem->Size = sizeof(KSMULTIPLE_ITEM) + sizeof(GUID);
pTimeFormatGuid = (GUID *) (pMultipleItem + 1); // pointer to the data
memcpy(pTimeFormatGuid, &KSTIME_FORMAT_MEDIA_TIME, sizeof(GUID));
*pulActualBytesTransferred = sizeof(KSMULTIPLE_ITEM) + sizeof(GUID);
Status = STATUS_SUCCESS;
} else {
TRACE(TL_FCP_ERROR,("DVCRMediaSeekingProperty: KSPROPERTY_MEDIASEEKING_FORMAT; STATUS_INVALID_PARAMETER\n"));
Status = STATUS_INVALID_PARAMETER;
}
break;
default:
TRACE(TL_FCP_ERROR,("\'DVCRMediaSeekingProperty:Not supported ID %d\n", pSPD->Property->Id));
return STATUS_NOT_SUPPORTED;
}
return Status;
}
NTSTATUS
DVGetDeviceProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
IN PULONG pulActualBytesTransferred
)
/*++
Routine Description:
Handles Get operations for all adapter properties.
Arguments:
Return Value:
NTSTATUS
--*/
{
NTSTATUS Status;
PAGED_CODE();
if (IsEqualGUID (&PROPSETID_EXT_DEVICE, &pSPD->Property->Set)) {
Status =
DVGetExtDeviceProperty(
pDevExt,
pSPD,
pulActualBytesTransferred
);
}
else
if (IsEqualGUID (&PROPSETID_EXT_TRANSPORT, &pSPD->Property->Set)) {
Status =
DVGetExtTransportProperty(
pDevExt,
pSPD,
pulActualBytesTransferred
);
}
else
if (IsEqualGUID (&PROPSETID_TIMECODE_READER, &pSPD->Property->Set)) {
Status =
DVGetTimecodeReaderProperty(
pDevExt,
pSPD,
pulActualBytesTransferred
);
}
else
if (IsEqualGUID (&KSPROPSETID_MediaSeeking, &pSPD->Property->Set)) {
Status =
DVMediaSeekingProperty(
pDevExt,
pSPD,
pulActualBytesTransferred
);
} else {
//
// We should never get here
//
Status = STATUS_NOT_SUPPORTED;
TRACE(TL_FCP_ERROR,("get unknown property\n"));
ASSERT(FALSE);
}
return Status;
}
NTSTATUS
DVSetDeviceProperty(
IN PDVCR_EXTENSION pDevExt,
IN PSTREAM_PROPERTY_DESCRIPTOR pSPD,
IN PULONG pulActualBytetransferred
)
/*++
Routine Description:
Handles Set operations for all adapter properties.
Arguments:
Return Value:
NTSTATUS
--*/
{
NTSTATUS Status;
PAGED_CODE();
if (IsEqualGUID (&PROPSETID_EXT_DEVICE, &pSPD->Property->Set)) {
Status =
DVSetExtDeviceProperty(
pDevExt,
pSPD,
pulActualBytetransferred
);
}
else
if (IsEqualGUID (&PROPSETID_EXT_TRANSPORT, &pSPD->Property->Set)) {
Status =
DVSetExtTransportProperty(
pDevExt,
pSPD,
pulActualBytetransferred
);
}
else {
Status = STATUS_NOT_SUPPORTED;
//
// We should never get here
//
TRACE(TL_FCP_ERROR,("set unknown property\n"));
ASSERT(FALSE);
}
return Status;
}