usbfndrv.cpp

OMAP730 USB 驱动源码

    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);
        }
    }
    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;
}
BOOL  CUsbFuncPipe::TransferComplete( CUsbFuncTransfer * pTransfer)
{  
    do {
        if (m_pSerialFn)
            m_pSerialFn->EndpointNotification(this);
    } while (m_fContinueInterrupt) ;
    
#if DEBUG
    if (pTransfer) {
        for (DWORD dwIndex =0 ; dwIndex < m_dwNumOfTransfer; dwIndex++)
            if (m_pTransferArray[dwIndex] == pTransfer)
                return TRUE;
    }
    ASSERT(FALSE);
#endif
    return TRUE;
}
//--------------------------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() && m_hDefaultPipe!=NULL);
    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->WriteDataOnce(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

#define PID_MICROSOFT_SERIAL_PROTOTYPE      0x00ce

    
#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

CUsbFn::CUsbFn (LPCTSTR lpActivePath)
:   m_pUfnFuncs(&m_UfnFuncs)
{
    DWORD dwLen = _tcslen(lpActivePath);
    m_lpActivePath = new TCHAR[dwLen+1];
    if (m_lpActivePath) {
        _tcscpy(m_lpActivePath,lpActivePath);
        m_lpActivePath[dwLen]= 0;
    }
    m_hDevice = NULL;
    m_hDefaultPipe = NULL;
    m_pvInterface = NULL;
    m_CurrentSpeed = BS_HIGH_SPEED;


    const USB_DEVICE_DESCRIPTOR 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
        0x03,                                   // iSerialNumber
        0x01                                    // bNumConfigurations
    };
    m_HighSpeedDeviceDesc = HighSpeedDeviceDesc;

    const USB_DEVICE_DESCRIPTOR FullSpeedDeviceDesc = {
        sizeof(USB_DEVICE_DESCRIPTOR),          // bLength