asyncapi.c

关于1394diag的资料和源代码的实例

            RtlCopyMemory(pBuffer, Data, nLength);
            break;
        }
        else if (AsyncAddressData->AsyncAddressList.Flink == &deviceExtension->AsyncAddressData) {

            AsyncAddressData = NULL;
            break;
        }
        else
            AsyncAddressData = (PASYNC_ADDRESS_DATA)AsyncAddressData->AsyncAddressList.Flink;
    }

    KeReleaseSpinLock(&deviceExtension->AsyncSpinLock, Irql);

    // never found an entry...
    if (!AsyncAddressData) {

        ntStatus = STATUS_INVALID_PARAMETER;
    }

    EXIT("t1394Diag_SetAddressData", ntStatus);
    return(ntStatus);
} // t1394Diag_SetAddressData

NTSTATUS
t1394Diag_AsyncRead(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN ULONG            bRawMode,
    IN ULONG            bGetGeneration,
    IN IO_ADDRESS       DestinationAddress,
    IN ULONG            nNumberOfBytesToRead,
    IN ULONG            nBlockSize,
    IN ULONG            fulFlags,
    IN ULONG            ulGeneration,
    IN OUT PULONG       Data
    )
{
    NTSTATUS            ntStatus = STATUS_SUCCESS;
    PDEVICE_EXTENSION   deviceExtension = DeviceObject->DeviceExtension;
    PIRB                pIrb;
    PMDL                pMdl;

    ENTER("t1394Diag_AsyncRead");

    TRACE(TL_TRACE, ("bRawMode = %d\n", bRawMode));
    TRACE(TL_TRACE, ("bGetGeneration = %d\n", bGetGeneration));
    TRACE(TL_TRACE, ("DestinationAddress.IA_Destination_ID.NA_Bus_Number = 0x%x\n", DestinationAddress.IA_Destination_ID.NA_Bus_Number));
    TRACE(TL_TRACE, ("DestinationAddress.IA_Destination_ID.NA_Node_Number = 0x%x\n", DestinationAddress.IA_Destination_ID.NA_Node_Number));
    TRACE(TL_TRACE, ("DestinationAddress.IA_Destination_Offset.Off_High = 0x%x\n", DestinationAddress.IA_Destination_Offset.Off_High));
    TRACE(TL_TRACE, ("DestinationAddress.IA_Destination_Offset.Off_Low = 0x%x\n", DestinationAddress.IA_Destination_Offset.Off_Low));
    TRACE(TL_TRACE, ("nNumberOfBytesToRead = 0x%x\n", nNumberOfBytesToRead));
    TRACE(TL_TRACE, ("nBlockSize = 0x%x\n", nBlockSize));
    TRACE(TL_TRACE, ("fulFlags = 0x%x\n", fulFlags));
    TRACE(TL_TRACE, ("ulGeneration = 0x%x\n", ulGeneration));
    TRACE(TL_TRACE, ("Data = 0x%x\n", Data));

    pIrb = ExAllocatePool(NonPagedPool, sizeof(IRB));

    if (!pIrb) {

        TRACE(TL_ERROR, ("Failed to allocate pIrb!\n"));
        TRAP;

        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit_AsyncRead;
    } // if

    pIrb->FunctionNumber = REQUEST_ASYNC_READ;
    pIrb->Flags = 0;
    pIrb->u.AsyncRead.DestinationAddress = DestinationAddress;
    pIrb->u.AsyncRead.nNumberOfBytesToRead = nNumberOfBytesToRead;
    pIrb->u.AsyncRead.nBlockSize = nBlockSize;
    pIrb->u.AsyncRead.fulFlags = fulFlags;

    if (bGetGeneration)
        pIrb->u.AsyncRead.ulGeneration = deviceExtension->GenerationCount;
    else
        pIrb->u.AsyncRead.ulGeneration = ulGeneration;
        
    pMdl = MmCreateMdl(NULL, Data, nNumberOfBytesToRead);
    MmBuildMdlForNonPagedPool(pMdl);
    
    pIrb->u.AsyncRead.Mdl = pMdl;

    if (bRawMode)
        ntStatus = t1394Diag_SubmitIrpSynch(deviceExtension->PortDeviceObject, Irp, pIrb);
    else
        ntStatus = t1394Diag_SubmitIrpSynch(deviceExtension->StackDeviceObject, Irp, pIrb);

    if (!NT_SUCCESS(ntStatus)) {

        TRACE(TL_ERROR, ("SubmitIrpSync failed = 0x%x\n", ntStatus));

        if (ntStatus != STATUS_INVALID_GENERATION) {
            TRAP;
        }
    }
    else {

    }

    if (pMdl)
        ExFreePool(pMdl);

    if (pIrb)
        ExFreePool(pIrb);

Exit_AsyncRead:

    EXIT("t1394Diag_AsyncRead", ntStatus);
    return(ntStatus);
} // t1394Diag_AsyncRead

NTSTATUS
t1394Diag_AsyncWrite(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN ULONG            bRawMode,
    IN ULONG            bGetGeneration,
    IN IO_ADDRESS       DestinationAddress,
    IN ULONG            nNumberOfBytesToWrite,
    IN ULONG            nBlockSize,
    IN ULONG            fulFlags,
    IN ULONG            ulGeneration,
    IN OUT PULONG       Data
    )
{
    NTSTATUS            ntStatus = STATUS_SUCCESS;
    PDEVICE_EXTENSION   deviceExtension = DeviceObject->DeviceExtension;
    PIRB                pIrb;
    PMDL                pMdl;

    ENTER("t1394Diag_AsyncWrite");

    TRACE(TL_TRACE, ("bRawMode = %d\n", bRawMode));
    TRACE(TL_TRACE, ("bGetGeneration = %d\n", bGetGeneration));
    TRACE(TL_TRACE, ("DestinationAddress.IA_Destination_ID.NA_Bus_Number = 0x%x\n", DestinationAddress.IA_Destination_ID.NA_Bus_Number));
    TRACE(TL_TRACE, ("DestinationAddress.IA_Destination_ID.NA_Node_Number = 0x%x\n", DestinationAddress.IA_Destination_ID.NA_Node_Number));
    TRACE(TL_TRACE, ("DestinationAddress.IA_Destination_Offset.Off_High = 0x%x\n", DestinationAddress.IA_Destination_Offset.Off_High));
    TRACE(TL_TRACE, ("DestinationAddress.IA_Destination_Offset.Off_Low = 0x%x\n", DestinationAddress.IA_Destination_Offset.Off_Low));
    TRACE(TL_TRACE, ("nNumberOfBytesToWrite = 0x%x\n", nNumberOfBytesToWrite));
    TRACE(TL_TRACE, ("nBlockSize = 0x%x\n", nBlockSize));
    TRACE(TL_TRACE, ("fulFlags = 0x%x\n", fulFlags));
    TRACE(TL_TRACE, ("ulGeneration = 0x%x\n", ulGeneration));
    TRACE(TL_TRACE, ("Data = 0x%x\n", Data));

    if (nNumberOfBytesToWrite == 0) {

        TRACE(TL_ERROR, ("Invalid nNumberOfBytesToWrite size!\n"));
        TRAP;

        ntStatus = STATUS_INVALID_PARAMETER;
        goto Exit_AsyncWrite;
    }

    pIrb = ExAllocatePool(NonPagedPool, sizeof(IRB));

    if (!pIrb) {

        TRACE(TL_ERROR, ("Failed to allocate pIrb!\n"));
        TRAP;

        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit_AsyncWrite;
    } // if

    pIrb->FunctionNumber = REQUEST_ASYNC_WRITE;
    pIrb->Flags = 0;
    pIrb->u.AsyncWrite.DestinationAddress = DestinationAddress;
    pIrb->u.AsyncWrite.nNumberOfBytesToWrite = nNumberOfBytesToWrite;
    pIrb->u.AsyncWrite.nBlockSize = nBlockSize;
    pIrb->u.AsyncWrite.fulFlags = fulFlags;

    if (bGetGeneration)
        pIrb->u.AsyncRead.ulGeneration = deviceExtension->GenerationCount;
    else
        pIrb->u.AsyncRead.ulGeneration = ulGeneration;

    pMdl = MmCreateMdl(NULL, Data, nNumberOfBytesToWrite);
    MmBuildMdlForNonPagedPool(pMdl);

    pIrb->u.AsyncWrite.Mdl = pMdl;

    if (bRawMode)
        ntStatus = t1394Diag_SubmitIrpSynch(deviceExtension->PortDeviceObject, Irp, pIrb);
    else
        ntStatus = t1394Diag_SubmitIrpSynch(deviceExtension->StackDeviceObject, Irp, pIrb);

    if (!NT_SUCCESS(ntStatus)) {

        TRACE(TL_ERROR, ("SubmitIrpSync failed = 0x%x\n", ntStatus));

        if (ntStatus != STATUS_INVALID_GENERATION) {
            TRAP;
        }
    }
    else {

    }

    if (pMdl)
        ExFreePool(pMdl);

    if (pIrb)
        ExFreePool(pIrb);

Exit_AsyncWrite:

    EXIT("t1394Diag_AsyncWrite", ntStatus);
    return(ntStatus);
} // t1394Diag_AsyncWrite

NTSTATUS
t1394Diag_AsyncLock(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN ULONG            bRawMode,
    IN ULONG            bGetGeneration,
    IN IO_ADDRESS       DestinationAddress,
    IN ULONG            nNumberOfArgBytes,
    IN ULONG            nNumberOfDataBytes,
    IN ULONG            fulTransactionType,
    IN ULONG            fulFlags,
    IN ULONG            Arguments[2],
    IN ULONG            DataValues[2],
    IN ULONG            ulGeneration,
    IN OUT PVOID        Buffer
    )
{
    NTSTATUS            ntStatus = STATUS_SUCCESS;
    PDEVICE_EXTENSION   deviceExtension = DeviceObject->DeviceExtension;
    PIRB                pIrb;

    ENTER("t1394Diag_AsyncLock");

    TRACE(TL_TRACE, ("bRawMode = %d\n", bRawMode));
    TRACE(TL_TRACE, ("bGetGeneration = %d\n", bGetGeneration));
    TRACE(TL_TRACE, ("DestinationAddress.IA_Destination_ID.NA_Bus_Number = 0x%x\n", DestinationAddress.IA_Destination_ID.NA_Bus_Number));
    TRACE(TL_TRACE, ("DestinationAddress.IA_Destination_ID.NA_Node_Number = 0x%x\n", DestinationAddress.IA_Destination_ID.NA_Node_Number));
    TRACE(TL_TRACE, ("DestinationAddress.IA_Destination_Offset.Off_High = 0x%x\n", DestinationAddress.IA_Destination_Offset.Off_High));
    TRACE(TL_TRACE, ("DestinationAddress.IA_Destination_Offset.Off_Low = 0x%x\n", DestinationAddress.IA_Destination_Offset.Off_Low));
    TRACE(TL_TRACE, ("nNumberOfArgBytes = 0x%x\n", nNumberOfArgBytes));
    TRACE(TL_TRACE, ("nNumberOfDataBytes = 0x%x\n", nNumberOfDataBytes));
    TRACE(TL_TRACE, ("fulTransactionType = 0x%x\n", fulTransactionType));
    TRACE(TL_TRACE, ("fulFlags = 0x%x\n", fulFlags));
    TRACE(TL_TRACE, ("Arguments[0] = 0x%x\n", Arguments[0]));
    TRACE(TL_TRACE, ("Arguments[1] = 0x%x\n", Arguments[1]));
    TRACE(TL_TRACE, ("DataValues[0] = 0x%x\n", DataValues[0]));
    TRACE(TL_TRACE, ("DataValues[1] = 0x%x\n", DataValues[1]));
    TRACE(TL_TRACE, ("ulGeneration = 0x%x\n", ulGeneration));
    TRACE(TL_TRACE, ("Buffer = 0x%x\n", Buffer));

    pIrb = ExAllocatePool(NonPagedPool, sizeof(IRB));

    if (!pIrb) {

        TRACE(TL_ERROR, ("Failed to allocate pIrb!\n"));
        TRAP;

        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit_AsyncLock;
    } // if

    pIrb->FunctionNumber = REQUEST_ASYNC_LOCK;
    pIrb->Flags = 0;
    pIrb->u.AsyncLock.DestinationAddress = DestinationAddress;
    pIrb->u.AsyncLock.nNumberOfArgBytes = nNumberOfArgBytes;
    pIrb->u.AsyncLock.nNumberOfDataBytes = nNumberOfDataBytes;
    pIrb->u.AsyncLock.fulTransactionType = fulTransactionType;
    pIrb->u.AsyncLock.fulFlags = fulFlags;
    pIrb->u.AsyncLock.Arguments[0] = Arguments[0];
    pIrb->u.AsyncLock.Arguments[1] = Arguments[1];
    pIrb->u.AsyncLock.DataValues[0] = DataValues[0];
    pIrb->u.AsyncLock.DataValues[1] = DataValues[1];
    pIrb->u.AsyncLock.pBuffer = Buffer;

    if (bGetGeneration)
        pIrb->u.AsyncLock.ulGeneration = deviceExtension->GenerationCount;
    else
        pIrb->u.AsyncLock.ulGeneration = ulGeneration;

    if (bRawMode)
        ntStatus = t1394Diag_SubmitIrpSynch(deviceExtension->PortDeviceObject, Irp, pIrb);
    else
        ntStatus = t1394Diag_SubmitIrpSynch(deviceExtension->StackDeviceObject, Irp, pIrb);

    if (!NT_SUCCESS(ntStatus)) {

        TRACE(TL_ERROR, ("SubmitIrpSync failed = 0x%x\n", ntStatus));

        if (ntStatus != STATUS_INVALID_GENERATION) {
            TRAP;
        }
    }

    if (pIrb)
        ExFreePool(pIrb);

Exit_AsyncLock:

    EXIT("t1394Diag_AsyncLock", ntStatus);
    return(ntStatus);
} // t1394Diag_AsyncLock

NTSTATUS
t1394Diag_AsyncStream(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN ULONG            nNumberOfBytesToStream,
    IN ULONG            fulFlags,
    IN ULONG            ulTag,
    IN ULONG            nChannel,
    IN ULONG            ulSynch,
    IN UCHAR            nSpeed,
    IN OUT PULONG       Data
    )
{
    NTSTATUS            ntStatus = STATUS_SUCCESS;
    PDEVICE_EXTENSION   deviceExtension = DeviceObject->DeviceExtension;
    PIRB                pIrb;
    PMDL                pMdl;

    ENTER("t1394Diag_AsyncStream");

    TRACE(TL_TRACE, ("nNumberOfBytesToStream = 0x%x\n", nNumberOfBytesToStream));
    TRACE(TL_TRACE, ("fulFlags = 0x%x\n", fulFlags));
    TRACE(TL_TRACE, ("ulTag = 0x%x\n", ulTag));
    TRACE(TL_TRACE, ("nChannel = 0x%x\n", nChannel));
    TRACE(TL_TRACE, ("ulSynch = 0x%x\n", ulSynch));
    TRACE(TL_TRACE, ("nSpeed = 0x%x\n", nSpeed));

    pIrb = ExAllocatePool(NonPagedPool, sizeof(IRB));

    if (!pIrb) {

        TRACE(TL_ERROR, ("Failed to allocate pIrb!\n"));
        TRAP;

        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit_AsyncStream;
    } // if

    pIrb->FunctionNumber = REQUEST_ASYNC_STREAM;
    pIrb->Flags = 0;
    pIrb->u.AsyncStream.nNumberOfBytesToStream = nNumberOfBytesToStream;
    pIrb->u.AsyncStream.fulFlags = fulFlags;
    pIrb->u.AsyncStream.ulTag = ulTag;
    pIrb->u.AsyncStream.nChannel = nChannel;
    pIrb->u.AsyncStream.ulSynch = ulSynch;
    pIrb->u.AsyncStream.nSpeed = nSpeed;
    
    pMdl = MmCreateMdl(NULL, Data, nNumberOfBytesToStream);

    if (!pMdl) {

        TRACE(TL_ERROR, ("Failed to allocate pMdl!\n"));
        TRAP;

        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit_AsyncStream;    
    }
    
    MmBuildMdlForNonPagedPool(pMdl);

    pIrb->u.AsyncStream.Mdl = pMdl;

    ntStatus = t1394Diag_SubmitIrpSynch(deviceExtension->StackDeviceObject, Irp, pIrb);

    if (!NT_SUCCESS(ntStatus)) {

        TRACE(TL_ERROR, ("SubmitIrpSync failed = 0x%x\n", ntStatus));
        TRAP;
    }

    if (pMdl)
        ExFreePool(pMdl);

    if (pIrb)
        ExFreePool(pIrb);

Exit_AsyncStream:

    EXIT("t1394Diag_AsyncStream", ntStatus);
    return(ntStatus);
} // t1394Diag_AsyncStream