}
            else
            {
                dx->pWaitCtrlIrp = Irp;
                
                status = STATUS_PENDING;
                IoAcquireCancelSpinLock(&Irp->CancelIrql);
                IoSetCancelRoutine(Irp, CancelWaitCtrlIrp);
                IoReleaseCancelSpinLock(Irp->CancelIrql);
                // is IRP to be canceled?
                if (Irp->Cancel)
                {
                    IoAcquireCancelSpinLock(&Irp->CancelIrql);
                    pOldCancelRoutine = IoSetCancelRoutine(Irp, NULL);
                    IoReleaseCancelSpinLock(Irp->CancelIrql);
                    // cancel routine already called?
                    if (pOldCancelRoutine != NULL)
                    {
                        // no, then cancel IRP here
                        status = STATUS_CANCELLED;
                        Irp->IoStatus.Information = 0;
                        dx->pWaitCtrlIrp = NULL;
                        DPrint(DBG_DRVCONTRAL, ("WAIT_ON_MASK: STATUS_CANCELLED\n"));
                        break;
                    }
                    else
                    {
                        // yes, cancel routine will complete IRP
                        IoMarkIrpPending(Irp);
                    }
                }
                else
                {
                    IoMarkIrpPending(Irp);
                }
                Irp->IoStatus.Status = STATUS_PENDING;
                Irp->IoStatus.Information = 0;
                DPrint(DBG_DRVCONTRAL, ("WAIT_ON_MASK STATUS_PENDING\n"));
                status = STATUS_PENDING;
                break;
            }
            break;
        }
    case IOCTL_SERIAL_PURGE:
        {
            if (IrpStack->Parameters.DeviceIoControl.InputBufferLength
                < sizeof(ULONG))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                DPrint(DBG_DRVCONTRAL, ("PURGE: rtn TOO_SMALL.\n"));
                break;
            }
            Irp->IoStatus.Information = sizeof(ULONG);
			dx->curLenRx = 0;
			dx->curLenTx = 0;
            //DPrint(DBG_DRVCONTRAL, ("PURGE: not handle and success.\n"));
            break;
        }
    case IOCTL_SERIAL_GET_BAUD_RATE:
        {
            if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength
                < sizeof(SERIAL_BAUD_RATE))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                DPrint(DBG_DRVCONTRAL, ("GET_BAUD_RATE: rtn TOO_SMALL.\n"));
                break;
            }
            Irp->IoStatus.Information = sizeof(SERIAL_BAUD_RATE);
            RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer,
                &dx->curBaudRate, sizeof(SERIAL_BAUD_RATE));
            DPrint(DBG_DRVCONTRAL, ("GET_BAUD_RATE: 0x%x.\n", dx->curBaudRate.BaudRate));
            break;
        }
    case IOCTL_SERIAL_GET_LINE_CONTROL:
        {
            if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength
                < sizeof(SERIAL_LINE_CONTROL))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                DPrint(DBG_DRVCONTRAL, ("GET_LINE_CONTROL: rtn TOO_SMALL.\n"));
                break;
            }
            Irp->IoStatus.Information = sizeof(SERIAL_LINE_CONTROL);
            RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer,
                &dx->curLineControl, sizeof(SERIAL_LINE_CONTROL));
            DPrint(DBG_DRVCONTRAL, ("GET_LINE_CONTROL: StopBits=%d, Parity=%d, WordLength=%d\n",
                dx->curLineControl.StopBits, dx->curLineControl.Parity, dx->curLineControl.WordLength));
            break;
        }
    case IOCTL_SERIAL_GET_CHARS:
        {
            if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength
                < sizeof(SERIAL_CHARS))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                DPrint(DBG_DRVCONTRAL, ("GET_CHARS: rtn TOO_SMALL.\n"));
                break;
            }
            Irp->IoStatus.Information = sizeof(SERIAL_CHARS);
            RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer,
                &dx->curChars, sizeof(SERIAL_CHARS));
            DPrint(DBG_DRVCONTRAL, ("GET_CHARS: EofChar=0x%x, ErrorChar=0x%x, BreakChar=0x%x, EventChar=0x%x, XonChar=0x%x, XoffChar=0x%x\n",
                dx->curChars.EofChar, dx->curChars.ErrorChar, dx->curChars.BreakChar, dx->curChars.EventChar, dx->curChars.XonChar, dx->curChars.XoffChar));
            break;
        }
    case IOCTL_SERIAL_SET_CHARS:
        {
            if (IrpStack->Parameters.DeviceIoControl.InputBufferLength
                < sizeof(SERIAL_CHARS))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                DPrint(DBG_DRVCONTRAL, ("SET_CHARS: rtn TOO_SMALL.\n"));
                break;
            }
            RtlMoveMemory(&dx->curChars,
                Irp->AssociatedIrp.SystemBuffer, sizeof(SERIAL_CHARS));
            DPrint(DBG_DRVCONTRAL, ("SET_CHARS: EofChar=0x%x, ErrorChar=0x%x, BreakChar=0x%x, EventChar=0x%x, XonChar=0x%x, XoffChar=0x%x\n",
                dx->curChars.EofChar, dx->curChars.ErrorChar, dx->curChars.BreakChar, dx->curChars.EventChar, dx->curChars.XonChar, dx->curChars.XoffChar));
            break;
        }
    case IOCTL_SERIAL_GET_HANDFLOW:
        {
            if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength
                < sizeof(SERIAL_HANDFLOW))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                DPrint(DBG_DRVCONTRAL, ("GET_HANDFLOW: rtn TOO_SMALL.\n"));
                break;
            }
            Irp->IoStatus.Information = sizeof(SERIAL_HANDFLOW);
            RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer,
                &dx->curHandflow, sizeof(SERIAL_HANDFLOW));
            DPrint(DBG_DRVCONTRAL, ("GET_HANDFLOW: ControlHandShake=0x%x, FlowReplace=0x%x, XonLimit=0x%x, XoffLimit=0x%x.\n",
                dx->curHandflow.ControlHandShake, dx->curHandflow.FlowReplace, dx->curHandflow.XonLimit, dx->curHandflow.XoffLimit));
            break;
        }
    case IOCTL_SERIAL_SET_HANDFLOW:
        {
            if (IrpStack->Parameters.DeviceIoControl.InputBufferLength
                < sizeof(SERIAL_HANDFLOW))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                DPrint(DBG_DRVCONTRAL, ("SET_HANDFLOW: rtn TOO_SMALL.\n"));
                break;
            }
            RtlMoveMemory(&dx->curHandflow,
                Irp->AssociatedIrp.SystemBuffer, sizeof(SERIAL_HANDFLOW));
            DPrint(DBG_DRVCONTRAL, ("SET_HANDFLOW: ControlHandShake=0x%x, FlowReplace=0x%x, XonLimit=0x%x, XoffLimit=0x%x.\n",
                dx->curHandflow.ControlHandShake, dx->curHandflow.FlowReplace, dx->curHandflow.XonLimit, dx->curHandflow.XoffLimit));
            break;
        }
    case IOCTL_SERIAL_GET_MODEMSTATUS: // 3. x4
        {
            if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength
                < sizeof(ULONG))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                DPrint(DBG_DRVCONTRAL, ("GET_MODEMSTATUS: rtn TOO_SMALL.\n"));
                break;
            }
            Irp->IoStatus.Information = sizeof(ULONG);
            //*(PULONG)Irp->AssociatedIrp.SystemBuffer = 0;
            DPrint(DBG_DRVCONTRAL, ("GET_MODEMSTATUS: not handle and success.\n"));//for comDebug
            break;
        }
    case IOCTL_SERIAL_GET_COMMSTATUS: // 2.
        {
            if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength
                < sizeof(SERIAL_STATUS))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                DPrint(DBG_DRVCONTRAL, ("GET_COMMSTATUS: rtn TOO_SMALL.\n"));
                break;
            }
            PSERIAL_STATUS pStatus = (PSERIAL_STATUS)Irp->AssociatedIrp.SystemBuffer;
            Irp->IoStatus.Information = sizeof(SERIAL_STATUS);
            //pStatus->Errors  = ;
            //pStatus->HoldReasons  = ;
            pStatus->AmountInInQueue  = dx->curLenRx;
            pStatus->AmountInOutQueue = dx->curLenTx;
            //pStatus->EofReceived = ;
            //pStatus->WaitForImmediate = ;
            DPrint(DBG_DRVCONTRAL, ("GET_COMMSTATUS: not complete and curLenTx=%d, curLenRx=%d.\n",
                dx->curLenTx, dx->curLenRx));
            break;
        }
    case IOCTL_SERIAL_XOFF_COUNTER:
        {
            DPrint(DBG_DRVCONTRAL, ("XOFF_COUNTER: do nothing and success.\n"));
            break;
        }
    case IOCTL_SERIAL_GET_PROPERTIES:
        {
            Irp->IoStatus.Information = sizeof(SERIAL_COMMPROP);
            DPrint(DBG_DRVCONTRAL, ("GET_PROPERTIES: do nothing and success.\n"));
            break;
        }
    case IOCTL_SERIAL_GET_DTRRTS:
        {
            Irp->IoStatus.Information = sizeof(ULONG);
            DPrint(DBG_DRVCONTRAL, ("GET_DTRRTS: do nothing and success.\n"));
            break;
        }
    case IOCTL_SERIAL_LSRMST_INSERT:
        {
            Irp->IoStatus.Information = sizeof(UCHAR);
            DPrint(DBG_DRVCONTRAL, ("LSRMST_INSERT: do nothing and success.\n"));
            break;
        }
    case IOCTL_SERIAL_CONFIG_SIZE:
        {
            Irp->IoStatus.Information = sizeof(ULONG);
            DPrint(DBG_DRVCONTRAL, ("CONFIG_SIZE: do nothing and success.\n"));
            break;
        }
    case IOCTL_SERIAL_GET_COMMCONFIG: //************************** not help
        {
            DPrint(DBG_DRVCONTRAL, ("GET_COMMCONFIG: do nothing and success.\n"));
            break;
        }
    case IOCTL_SERIAL_SET_COMMCONFIG: //************************** not help
        {
            DPrint(DBG_DRVCONTRAL, ("SET_COMMCONFIG: do nothing and success.\n"));
            break;
        }
    case IOCTL_SERIAL_GET_STATS:
        {
            Irp->IoStatus.Information = sizeof(SERIALPERF_STATS);
            DPrint(DBG_DRVCONTRAL, ("GET_STATS: do nothing and success.\n"));
            break;
        }
    case IOCTL_SERIAL_CLEAR_STATS:
        {
            DPrint(DBG_DRVCONTRAL, ("CLEAR_STATS: do nothing and success.\n"));
            break;
        }
    case IOCTL_SERIAL_GET_MODEM_CONTROL:
        {
            Irp->IoStatus.Information = sizeof(ULONG);
            DPrint(DBG_DRVCONTRAL, ("GET_MODEM_CONTROL: do nothing and success.\n"));
            break;
        }
    case IOCTL_SERIAL_SET_MODEM_CONTROL:
        {
            DPrint(DBG_DRVCONTRAL, ("SET_MODEM_CONTROL: do nothing and success.\n"));
            break;
        }
    case IOCTL_SERIAL_SET_FIFO_CONTROL:
        {
            DPrint(DBG_DRVCONTRAL, ("SET_FIFO_CONTROL: do nothing and success.\n"));
            break;
        }
    default: // Invalid request
        {
            ULONG controlCode, funcCode;
            controlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;
            funcCode = (controlCode & (~(FILE_DEVICE_SERIAL_PORT<<16))) >> 2;
            DPrint(DBG_DRVCONTRAL, ("DeviceControl 0x%x %d not handled.\n",
                controlCode, funcCode));
            Irp->IoStatus.Information = 0;
            status = STATUS_SUCCESS;
            break;
        }
    }
    
    if (status == STATUS_PENDING)
        return status;
    
    // Complete IRP
    return Vcp4usbCompleteIrp(Irp, status, Irp->IoStatus.Information);
}

//
NTSTATUS Vcp4usbSystemControl(IN PDEVICE_OBJECT fdo, IN PIRP Irp)
{
    DPrint(DBG_SYSCONTRAL, ("SystemControl\n"));
    PVCP4USB_DEVICE_EXTENSION dx = (PVCP4USB_DEVICE_EXTENSION)fdo->DeviceExtension;
    NTSTATUS status = STATUS_SUCCESS;
    
    // Just pass to lower driver
    IoSkipCurrentIrpStackLocation(Irp);
    
    return IoCallDriver(dx->NextStackDevice, Irp);
}

///////////////////////////////////////////////////////////////////////////////