else
        ASSERT(FALSE);
    if (pBuffLen)
        *pBuffLen -= dwLeft;
    Unlock();
    DEBUGMSG (ZONE_WRITE,(TEXT("-CUsbFuncPipe::WriteData (0x%x,0x%x)\r\n"), pTxBuffer,pBuffLen?*pBuffLen:0));

}
BOOL  CUsbFuncPipe::CancelTransfer()
{
    Lock();
    if (m_fRead) {
        while (m_pTransferArray[m_dwCompleteIndex] && !m_pTransferArray[m_dwCompleteIndex]->IsTransferClosed() &&
                m_pTransferArray[m_dwCompleteIndex]->IsTransferComplete()) {
            m_pTransferArray[m_dwCompleteIndex]->CloseTransfer();
            m_pTransferArray[m_dwCompleteIndex]->IssueTransfer();
            // Advance to next one.
            m_dwCompleteIndex = IncIndex(m_dwCompleteIndex);
            m_dwCurPosition = 0;
        }
    }
    else {
        while (m_pTransferArray[m_dwCompleteIndex] && !m_pTransferArray[m_dwCompleteIndex]->IsTransferClosed()) {
            if (!m_pTransferArray[m_dwCompleteIndex]->IsTransferComplete())
                m_pTransferArray[m_dwCompleteIndex]->AbortTransfer();
            m_pTransferArray[m_dwCompleteIndex]->CloseTransfer();
            m_dwCompleteIndex = IncIndex(m_dwCompleteIndex);
        }
    }
    SetEvent(m_TerminateEvent);
    Unlock();
    return TRUE;
}

BOOL CUsbFuncPipe::IsAnySpaceAvailable()
{
    BOOL fReturn = FALSE;
    if (!m_fRead) {
        Lock();
        fReturn =(m_pTransferArray[m_dwWriteIndex]!=NULL 
                    && m_pTransferArray[m_dwWriteIndex]->IsTransferComplete());
        Unlock();
    }
    return fReturn;
}

DWORD CUsbFuncPipe::ThreadRun()
{
    while (m_TerminateEvent && ! IsTerminated()) {
        Lock();
        if (m_pTransferArray[m_dwCompleteIndex] && !m_pTransferArray[m_dwCompleteIndex]->IsTransferClosed()) {
            HANDLE rgh[2];
            rgh[0] = m_pTransferArray[m_dwCompleteIndex]->GetCompleteEventHandle();
            rgh[1] = m_TerminateEvent;
            Unlock();
            WaitForMultipleObjects(dim(rgh),rgh,FALSE,INFINITE);
            Lock();
        }
        else {
            Unlock();
            WaitForSingleObject(m_TerminateEvent,INFINITE);
            Lock();
        }
        if (m_pTransferArray[m_dwCompleteIndex] && !IsTerminated()) {
            DWORD dwCurIndex = m_dwCompleteIndex;
            if (!m_pTransferArray[dwCurIndex]->IsTransferClosed() && 
                    m_pTransferArray[dwCurIndex]->IsTransferComplete()) {
                Unlock();
                if (m_pSerialFn)
                    m_pSerialFn->EndpointNotification(this);                    
                Lock();
            }            
        }
        Unlock();
    }
    return (1);
}
//--------------------------USB FN Serial Driver -------------------------------------------
USBSerialFn::USBSerialFn(LPTSTR lpActivePath, PVOID pMdd, PHWOBJ pHwObj )
:   CSerialPDD(lpActivePath, pMdd,  pHwObj  )
,   CUsbFn (lpActivePath)
{
    PREFAST_ASSERT(lpActivePath!=NULL);
    m_pBulkIn = NULL;
    m_pBulkOut = NULL;
    m_pInterruptIn = NULL;
    m_bOldHostModemStatus = m_curHostModemStatus = 0;
    m_bModemSetState[0]=m_bModemSetState[1]=0;
}
USBSerialFn::~USBSerialFn()
{
    if ( m_pBulkIn) {
//        ASSERT(FALSE);
        delete m_pBulkIn;
    }
    if ( m_pBulkOut ) {
//        ASSERT(FALSE);
        delete m_pBulkOut;
    }
    if (m_pInterruptIn ) {
//        ASSERT(FALSE);
        delete m_pInterruptIn;
            
    }
}
BOOL USBSerialFn::Init()
{
    BOOL fReturn = TRUE;
    fReturn = (CUsbFn::Init() && CSerialPDD::Init());
    ASSERT(fReturn);
    return fReturn;
};
BOOL USBSerialFn::EndpointNotification(CUsbFuncPipe * pPipe)
{
    if (pPipe!=NULL) {
        DWORD interruptType =  INTR_NONE;
        m_HardwareLock.Lock();
        if ( pPipe == m_pBulkIn) { // Device to Host.
            interruptType |= INTR_TX;
        }
        else 
        if ( pPipe == m_pBulkOut){ // Host to Device.
            interruptType |= INTR_RX;
        }
        if (pPipe == m_pInterruptIn) {
            if ( m_pInterruptIn->IsAnySpaceAvailable()) {
                if (m_bOldModemState !=m_bModemSetState[0]) {
                    DWORD dwLength = sizeof(m_bModemSetState);
                    m_bModemSetState [0] |= USBFN_SERIAL_DATA_AVAILABLE; // Always set data available.
                    m_pInterruptIn->WriteData(m_bModemSetState,&dwLength);
                    m_bOldModemState =  m_bModemSetState[0];
                }
                else
                    m_pInterruptIn->WriteData(NULL,NULL);
            }
            else
                ASSERT(FALSE);
            
        }
        m_HardwareLock.Unlock(); 
        return NotifyPDDInterrupt((INTERRUPT_TYPE)interruptType);
    }
    return FALSE;
}
/*BOOL USBSerialFn::InitXmit(BOOL bInit) 
{
    m_HardwareLock.Lock();
    BOOL bReturn = FALSE;
    if (m_pBulkIn) {
        if (bInit)
            bReturn = m_pBulkIn->OpenPipe();
        else {
            m_pBulkIn->ClosePipe();
            bReturn = TRUE;
        }
        ASSERT(bReturn);
    }
    m_HardwareLock.Unlock();
    return bReturn;
};
*/
void    USBSerialFn::XmitInterruptHandler(PUCHAR pTxBuffer, ULONG *pBuffLen)
{
    m_HardwareLock.Lock();
    if (m_pBulkIn) {
        if ((m_DCB.fOutxCtsFlow && IsCTSOff()) ||(m_DCB.fOutxDsrFlow && IsDSROff())) { // We are in flow off
            DEBUGMSG(ZONE_THREAD|ZONE_WRITE,(TEXT("USBSerialFn::XmitInterruptHandler! Flow Off, Data Discard.\r\n")));
            if (pBuffLen)
                *pBuffLen= 0;
        }
        else
            m_pBulkIn->WriteData(pTxBuffer,pBuffLen);
    }
    m_HardwareLock.Unlock();
};
void    USBSerialFn::XmitComChar(UCHAR ComChar) 
{
    DWORD dwLength = 1; // We can not do special.
    BOOL fReturn = FALSE;
    while (fReturn) {
        m_HardwareLock.Lock();
        if (m_pBulkIn) {
            if (m_pBulkIn->IsAnySpaceAvailable()) {
                m_pBulkIn->WriteData(&ComChar,&dwLength);
                fReturn = FALSE;
            }
        }
        else 
            fReturn = FALSE;
        m_HardwareLock.Unlock();
        if (!fReturn)
            Sleep(10);
    }    
}
BOOL USBSerialFn::CancelXmit()
{
    m_HardwareLock.Lock();
     if (m_pBulkIn) {
        m_pBulkIn->CancelTransfer();
    }
    m_HardwareLock.Unlock();
    return TRUE;
}

/*BOOL    USBSerialFn::InitReceive(BOOL bInit)
{
    m_HardwareLock.Lock();
    BOOL bReturn = FALSE;
    if (m_pBulkOut) {
        if (bInit)
            bReturn = m_pBulkOut->OpenPipe();
        else {
            m_pBulkOut->ClosePipe();
            bReturn = TRUE;
        }
        ASSERT(bReturn);
    }
    m_HardwareLock.Unlock();
    return bReturn;
}
*/
ULONG   USBSerialFn::ReceiveInterruptHandler(PUCHAR pRxBuffer,ULONG *pBufflen)
{
    DWORD dwReturn = 0;
    m_HardwareLock.Lock();
    if (m_pBulkOut) {
        dwReturn = m_pBulkOut->ReadData(pRxBuffer,pBufflen);
    }
    m_HardwareLock.Unlock();
    return dwReturn;
}
ULONG   USBSerialFn::CancelReceive()
{
    m_HardwareLock.Lock();
     if (m_pBulkIn) {
        m_pBulkIn->CancelTransfer();
    }
    m_HardwareLock.Unlock();
    return TRUE;
}

/*BOOL    USBSerialFn::InitModem(BOOL bInit)
{
    m_HardwareLock.Lock();
    BOOL bReturn = FALSE;
    if (m_pInterruptIn) {
        if (bInit)
            bReturn = m_pInterruptIn->OpenPipe();
        else{
            m_pInterruptIn->ClosePipe();
            bReturn = TRUE;
        }
    }
    m_bOldModemState = m_bModemSetState[0]= m_bModemSetState[1] = USBFN_SERIAL_DATA_AVAILABLE;
    m_HardwareLock.Unlock();
    return bReturn;
}
*/
void USBSerialFn::SetModemSignal(BOOL bSet, BYTE bBitSet)
{
    m_HardwareLock.Lock();
    if (bSet)
        m_bModemSetState[0] |= bBitSet;
    else
        m_bModemSetState[0] &= ~bBitSet;
    
    if (m_pInterruptIn && m_bOldModemState !=m_bModemSetState[0] && m_pInterruptIn->IsAnySpaceAvailable()) {
        DWORD dwLength = sizeof(m_bModemSetState);
        m_bModemSetState [0] |= USBFN_SERIAL_DATA_AVAILABLE;
        m_pInterruptIn->WriteData(m_bModemSetState,&dwLength);
        m_bOldModemState =  m_bModemSetState[0];
    }
    m_HardwareLock.Unlock();

}
ULONG   USBSerialFn::GetModemStatus() 
{ 
    m_HardwareLock.Lock();
    ULONG Events = 0;
    m_bOldHostModemStatus ^= m_curHostModemStatus; 
    if ( m_bOldHostModemStatus & MS_DSR_ON)
        Events |= EV_DSR;
    if ( m_bOldHostModemStatus & MS_RLSD_ON)
        Events |= EV_RLSD;
    if ( m_bOldHostModemStatus & MS_CTS_ON)
        Events |= EV_CTS;
    m_bOldHostModemStatus = m_curHostModemStatus;
    m_HardwareLock.Unlock();
    if (Events)
        EventCallback(Events,m_curHostModemStatus);        
    return m_curHostModemStatus;
};

//
// D A T A / M A C R O S
//
#define MAX_INTERRUPT_ENDPOINT_PACKET_SIZE 8
#define CB_CONFIG_DESCRIPTOR  (sizeof(USB_CONFIGURATION_DESCRIPTOR)+sizeof(USB_INTERFACE_DESCRIPTOR)+3*sizeof(USB_ENDPOINT_DESCRIPTOR))
//  definitions
#define COMMAND_PASSED                      0x00
#define COMMAND_FAILED                      0x01
#define PHASE_ERROR                         0x02

#define EP0_PACKET_SIZE                     USB_FULL_HIGH_SPEED_CONTROL_MAX_PACKET_SIZE
#define HIGH_SPEED_BULK_PACKET_SIZES        USB_HIGH_SPEED_BULK_MAX_PACKET_SIZE
#define FULL_SPEED_BULK_PACKET_SIZES        USB_FULL_SPEED_BULK_MAX_PACKET_SIZE 
#define USB_VERSION                         0x200


static USB_DEVICE_DESCRIPTOR                g_HighSpeedDeviceDesc = {
    sizeof(USB_DEVICE_DESCRIPTOR),          // bLength
    USB_DEVICE_DESCRIPTOR_TYPE,             // bDescriptorType
    USB_VERSION,                            // bcdUSB
    0x00,                                   // bDeviceClass
    0x00,                                   // bDeviceSubClass
    0x00,                                   // bDeviceProtocol
    EP0_PACKET_SIZE,                        // bMaxPacketSize0
    0,                                      // idVendor
    0,                                      // idProduct
    0x0000,                                 // bcdDevice
    0x01,                                   // iManufacturer
    0x02,                                   // iProduct
    0x00,                                   // iSerialNumber
    0x01                                    // bNumConfigurations
};


static USB_DEVICE_DESCRIPTOR                g_FullSpeedDeviceDesc = {
    sizeof(USB_DEVICE_DESCRIPTOR),          // bLength
    USB_DEVICE_DESCRIPTOR_TYPE,             // bDescriptorType
    USB_VERSION,                            // bcdUSB
    0x00,                                   // bDeviceClass
    0x00,                                   // bDeviceSubClass
    0x00,                                   // bDeviceProtocol
    EP0_PACKET_SIZE,                        // bMaxPacketSize0
    0,                                      // idVendor
    0,                                      // idProduct
    0x0000,                                 // bcdDevice
    0x01,                                   // iManufacturer
    0x02,                                   // iProduct
    0x00,                                   // iSerialNumber
    0x01                                    // bNumConfigurations
};

#define BULK_IN_ENDPOINT_ADDRESS  0x81
#define BULK_OUT_ENDPOINT_ADDRESS 0x02

#define INTERRUPT_IN_ENDPOINT_ADDRESS 0x83  // Optional

#define BULK_IN_DESCRIPTOR_INDEX    0
#define BULK_OUT_DESCRIPTOR_INDEX   1
#define INTERRUPT_IN_DESCRIPTOR_INDEX 2

static UFN_ENDPOINT                         g_HighSpeedEndpoints[] = {
    {
        sizeof(UFN_ENDPOINT),
        {
            sizeof(USB_ENDPOINT_DESCRIPTOR),// bLength
            USB_ENDPOINT_DESCRIPTOR_TYPE,   // bDescriptorType
            BULK_IN_ENDPOINT_ADDRESS,       // bEndpointAddress (endpoint 1, in)
            USB_ENDPOINT_TYPE_BULK,         // bmAttributes
            HIGH_SPEED_BULK_PACKET_SIZES,	// wMaxPacketSize
            0x00                            // bInterval (interrupt only)
        },
        NULL
    },
    {
        sizeof(UFN_ENDPOINT),
        {
            sizeof(USB_ENDPOINT_DESCRIPTOR),// bLength
            USB_ENDPOINT_DESCRIPTOR_TYPE,   // bDescriptorType
            BULK_OUT_ENDPOINT_ADDRESS,      // bEndpointAddress (endpoint 2, out)
            USB_ENDPOINT_TYPE_BULK,         // bmAttributes
            HIGH_SPEED_BULK_PACKET_SIZES,	// wMaxPacketSize
            0x00                            // bInterval (interrupt only)
        },
        NULL
    },
    {
        sizeof(UFN_ENDPOINT),
        {
            sizeof(USB_ENDPOINT_DESCRIPTOR),// bLength
            USB_ENDPOINT_DESCRIPTOR_TYPE,   // bDescriptorType
            INTERRUPT_IN_ENDPOINT_ADDRESS,  // bEndpointAddress (endpoint 2, out)
            USB_ENDPOINT_TYPE_INTERRUPT,    // bmAttributes
            MAX_INTERRUPT_ENDPOINT_PACKET_SIZE,   // wMaxPacketSize
            0xc                            // bInterval (interrupt only)
        },
        NULL
    }
};

static UFN_ENDPOINT                         g_FullSpeedEndpoints[] = {
    {
        sizeof(UFN_ENDPOINT),
        {
            sizeof(USB_ENDPOINT_DESCRIPTOR),// bLength
            USB_ENDPOINT_DESCRIPTOR_TYPE,   // bDescriptorType
            BULK_IN_ENDPOINT_ADDRESS,       // bEndpointAddress (endpoint 1, in)
            USB_ENDPOINT_TYPE_BULK,         // bmAttributes
            FULL_SPEED_BULK_PACKET_SIZES,	// wMaxPacketSize
            0x00                            // bInterval (interrupt only)
        },
        NULL
    },
    {
        sizeof(UFN_ENDPOINT),
        {
            sizeof(USB_ENDPOINT_DESCRIPTOR),// bLength
            USB_ENDPOINT_DESCRIPTOR_TYPE,   // bDescriptorType
            BULK_OUT_ENDPOINT_ADDRESS,      // bEndpointAddress (endpoint 2, out)
            USB_ENDPOINT_TYPE_BULK,         // bmAttributes
            FULL_SPEED_BULK_PACKET_SIZES,	// wMaxPacketSize
            0x00                            // bInterval (interrupt only)
        },
        NULL
    },
    {
        sizeof(UFN_ENDPOINT),