bul_usbfn.cpp

Windows CE 6.0 针对PXA270的开发板的BSP参考代码

        if (udccsr.ep0bit.SA !=0 && udccsr.ep0bit.OPC==0) {
            m_pUsbDevice->IncBadSetupCounter();
            OALMSG(1, (_T("Endpoint Zero FAILED SETUP  udccsr=0x%x. Sent STALL \r\n"),udccsr.ulValue));
            udccsr.ep0bit.FST = 1;
        }
        if (udccsr.ep0bit.OPC) {
            if ( udccsr.ep0bit.SA ) { // This is setup Packet.
                if (m_pCurTransfer) { // Outstanding transfer.
                    //DebugBreak();
                    OALMSG(OAL_ETHER&&OAL_VERBOSE, (_T("Endpoint Zero Current Transfer Canceled\r\n")));
                    WriteControlStatusRegister( udccsr.ulValue);
                    PSTransfer pTransfer = CompleteTransfer( UFN_CANCELED_ERROR );
                    Unlock();
                    m_pUsbDevice->MddTransferComplete(pTransfer);
                    Lock();

                    // maybe we should disable NeedAck while the transfer is already canceled.
                    m_bNeedAck = FALSE;
                }
                ASSERT(ReadByteCountRegister() == sizeof (USB_DEVICE_REQUEST));
                union {
                    USB_DEVICE_REQUEST udr;
                    DWORD dw8Byte[2];
                };
                dw8Byte[0] = ReadDataRegister();
                dw8Byte[1] = ReadDataRegister();
                OALMSG(OAL_ETHER&&OAL_VERBOSE, (_T("Endpoint Zero Setup bmRequestType = 0xx%x, bRequest=0x%x, wValue=0x%x,wIndex=0x%x,wLength=0x%x\r\n"),
                    udr.bmRequestType,udr.bRequest,udr.wValue,udr.wIndex,udr.wLength));
                
                if (m_bNeedAck) { // Previous setup haven't ack yet. Disable Interrupt and wait for the Ack.
                    m_pUsbDevice->EnableEndpointInterrupt(m_dwEndpointIndex,FALSE);
                    OALMSG(OAL_ETHER&&OAL_VERBOSE, (_T("Endpoint Zero Disable Interrupt\r\n")));
                    m_fBackedudr = TRUE;
                    m_backup_udr = udr;
                    WriteControlStatusRegister( udccsr.ulValue);
                   continue;
                }
                else {
                    m_bNeedAck = TRUE;
                    m_bSetupDirIn = ((udr.bmRequestType & USB_REQUEST_DEVICE_TO_HOST)!=0?TRUE:FALSE);
                    bContinue = TRUE ;
                    m_fZeroPacket = FALSE;
                    m_cur_udr = udr ;
                    WriteControlStatusRegister( udccsr.ulValue);
                    m_pUsbDevice->DeviceNotification(UFN_MSG_SETUP_PACKET, (DWORD) &udr);
                }
                continue;
            }
            else if ( ReadByteCountRegister() == 0 ) { // ACK from Host.
                bContinue = TRUE; 
            }
            else if (m_pCurTransfer ) {
                if((m_pCurTransfer->dwFlags & USB_IN_TRANSFER)==0) { // Out Data.
                    BOOL bComplete =  (ReadByteCountRegister()<m_epDesc.wMaxPacketSize);
                    DWORD dwSize = (m_pCurTransfer->cbTransferred< m_pCurTransfer->cbBuffer? m_pCurTransfer->cbBuffer-m_pCurTransfer->cbTransferred: 0);
                    if (dwSize!=0) {
                        dwSize= ReceiveData((PBYTE)m_pCurTransfer->pvBuffer + m_pCurTransfer->cbTransferred , dwSize);
                        m_pCurTransfer->cbTransferred += dwSize;
                    }

                    bComplete = (bComplete || (m_pCurTransfer->cbTransferred>= m_pCurTransfer->cbBuffer));
                    // Check for the completeion.
                    if ( bComplete ) {
                        WriteControlStatusRegister( udccsr.ulValue);
                        PSTransfer pTransfer =CompleteTransfer(UFN_NO_ERROR);
                        bContinue = TRUE;
                        Unlock();
                        m_pUsbDevice->MddTransferComplete(pTransfer);
                        Lock();
                        continue;
                    }
                }
                else { // Error
                    udccsr.ep0bit.FST = 1;
                }
            }
            else { // Transfer Not queue yet. 
                //m_pUsbDevice->EnableEndpointInterrupt(m_dwEndpointIndex,FALSE);
                // Do not clean OPC
                udccsr.ep0bit.OPC = 0;
            }

        }
        
        if (udccsr.ep0bit.IPR==0 ) {
        // Because the Ep0 is half duplex. We assume the direction is correct.
            if (m_pCurTransfer && (m_pCurTransfer->dwFlags & USB_IN_TRANSFER)!=0 &&
                    m_pCurTransfer->cbTransferred <= m_pCurTransfer->cbBuffer) {
                DWORD dwTotalData = m_pCurTransfer->cbBuffer - m_pCurTransfer->cbTransferred ;
                dwTotalData = min (dwTotalData,m_epDesc.wMaxPacketSize) ;
                // Spec 12.5.5
                DWORD dwReturn = XmitData(((PBYTE)m_pCurTransfer->pvBuffer)+ m_pCurTransfer->cbTransferred, dwTotalData );
                ASSERT(dwReturn == dwTotalData);
                m_pCurTransfer->cbTransferred += dwReturn;
                if (dwTotalData< m_epDesc.wMaxPacketSize) {
                    udccsr.ep0bit.IPR = 1;
                    m_fZeroPacket = FALSE;
                }
                else 
                    m_fZeroPacket = (m_cur_udr.wLength > m_pCurTransfer->cbTransferred);
            }
        }
        else 
            udccsr.ep0bit.IPR = 0 ; // Do not set when there is packet.
            
        if (udccsr.ep0bit.SST) { // Stall happens.
            m_pUsbDevice->IncEp0StallCounter() ;
            OALMSG(OAL_ETHER&&OAL_VERBOSE, (_T("Stall Sent on Zero endpoint =0x%x\r\n"),m_dwEndpointIndex));
        }
        // Clean the status.
        WriteControlStatusRegister( udccsr.ulValue);
        if (m_pCurTransfer &&m_pCurTransfer->cbTransferred >= m_pCurTransfer->cbBuffer && !m_fZeroPacket ) {// Complete anyway
            PSTransfer pTransfer = CompleteTransfer(UFN_NO_ERROR);
            Unlock();
            m_pUsbDevice->MddTransferComplete(pTransfer);
            Lock();            
        }
        
    }
    m_fInIST = FALSE;
    Unlock();
    FUNCTION_LEAVE_MSG();
    return ERROR_SUCCESS;
}
DWORD   BulEndpointIn::IST(DWORD dwIRBit)
{
    Lock();
    BOOL bContinue = TRUE;
    SETFNAME();
    FUNCTION_ENTER_MSG();
    if ((dwIRBit & EPINT_FIFO_ERROR)!=0) { // FIFO Error. End
        DWORD dwUdccsr;
        dwUdccsr = ReadControlStatusRegister();
        OALMSG(OAL_ETHER&&OAL_WARN, (_T("FIFO Error on Endpoint IN(%d) UDCCSR=0x%x\r\n"),m_dwEndpointIndex,dwUdccsr));
    }

    while (bContinue) 
    { // Loop until all the event clear.
        bContinue = FALSE;
        UDCCSR udccsr;
        udccsr.ulValue = ReadControlStatusRegister();
        OALMSG(OAL_ETHER&&OAL_VERBOSE, (_T(" IN::IST(%d) UDCCSR=0x%x\r\n"),m_dwEndpointIndex,udccsr.ulValue));
        if (m_fStalled && (udccsr.epbit.PC!=0 || udccsr.epbit.TRN!=0) ) {
            // Stall has been clear silently. So we generate Faking Clear Feature for Endpoint Zero
            m_fStalled = FALSE;
            udccsr.epbit.PC = udccsr.epbit.TRN = udccsr.epbit.FEF = 0;
            WriteControlStatusRegister(udccsr.ulValue);
            bContinue = TRUE;
            SendFakeFeature(USB_REQUEST_CLEAR_FEATURE,USB_FEATURE_ENDPOINT_STALL);
            continue;
        }
        if ( udccsr.epbit.PC!=0 ) { // Packet Complete.
            if (udccsr.epbit.DPE!=0 ) { // Data Packet Error
                WriteControlStatusRegister(udccsr.ulValue);
                PSTransfer pTransfer = CompleteTransfer( UFN_NOT_COMPLETE_ERROR );
                Unlock();
                m_pUsbDevice->MddTransferComplete(pTransfer);
                Lock();                
                continue;
            }
            if ( m_pCurTransfer && !m_fZeroPacket &&  m_pCurTransfer->cbTransferred >= m_pCurTransfer->cbBuffer) {
                WriteControlStatusRegister(udccsr.ulValue);        
                PSTransfer pTransfer = CompleteTransfer(UFN_NO_ERROR);
                Unlock();
                m_pUsbDevice->MddTransferComplete(pTransfer);
                Lock();                
                continue;
            }
            bContinue = TRUE;
        }
        udccsr.epbit.SP = 0;
        if ( udccsr.epbit.FS!=0 && m_pCurTransfer!=NULL  && 
                (m_pCurTransfer->cbTransferred < m_pCurTransfer->cbBuffer || m_fZeroPacket) )  { // Include Eaqual for 0 packet.
            ASSERT((m_pCurTransfer->dwFlags & USB_IN_TRANSFER)!=NULL);
            DWORD dwXmitLength = (m_fZeroPacket?0:m_pCurTransfer->cbBuffer-m_pCurTransfer->cbTransferred);
            dwXmitLength = XmitData((PBYTE)m_pCurTransfer->pvBuffer + m_pCurTransfer->cbTransferred, dwXmitLength );
            m_pCurTransfer->cbTransferred += dwXmitLength;
            m_fZeroPacket = FALSE;
            if (dwXmitLength < m_epDesc.wMaxPacketSize) {
                udccsr.epbit.SP = 1;
                m_fZeroPacket = FALSE;
            }
            else
                m_fZeroPacket = FALSE;
            bContinue = TRUE;
        }
        if (udccsr.epbit.SST) {
            OALMSG(OAL_ETHER&&OAL_WARN, (_T("Stall send on In Endpoint = 0x%x\r\n"),m_dwEndpointIndex));
            // We have to assume we clean stall here because this no more interrupt.
            udccsr.epbit.FST = 0 ;
            m_fStalled = FALSE;
            bContinue = TRUE;
            WriteControlStatusRegister(udccsr.ulValue);        
            SendFakeFeature(USB_REQUEST_CLEAR_FEATURE,USB_FEATURE_ENDPOINT_STALL);
            continue;
        }
        WriteControlStatusRegister(udccsr.ulValue);        
    }
    Unlock();
    FUNCTION_LEAVE_MSG();
    return ERROR_SUCCESS;
}
DWORD   BulEndpointOut::IST(DWORD dwIRBit)
{
    Lock();
    BOOL bContinue = TRUE;
    SETFNAME();
    FUNCTION_ENTER_MSG();
    if ((dwIRBit & EPINT_FIFO_ERROR)!=0) { // FIFO Error. End
        DWORD dwUdccsr;
        dwUdccsr = ReadControlStatusRegister();
        OALMSG(OAL_ETHER&&OAL_WARN, (_T("FIFO Error on Endpoint Out(%d) UDCCSR=0x%x\r\n"),m_dwEndpointIndex,dwUdccsr));
    }

    while (bContinue) {
        bContinue = FALSE;
        UDCCSR udccsr;
        udccsr.ulValue = ReadControlStatusRegister();
        OALMSG(OAL_ETHER&&OAL_VERBOSE, (_T(" Out::IST(%d) UDCCSR=0x%x\r\n"),m_dwEndpointIndex,udccsr.ulValue));
        if (m_fStalled && (udccsr.epbit.PC!=0 || udccsr.epbit.TRN!=0) ) {
            // Stall has been clear silently. So we generate Faking Clear Feature for Endpoint Zero
            m_fStalled = FALSE;
            udccsr.epbit.PC = udccsr.epbit.TRN = udccsr.epbit.FEF = 0;
            WriteControlStatusRegister(udccsr.ulValue);
            bContinue = TRUE;
            SendFakeFeature(USB_REQUEST_CLEAR_FEATURE,USB_FEATURE_ENDPOINT_STALL);
            continue;
        }
        // Unload in data if there is any
        if  ( udccsr.epbit.FS!=0 && m_pCurTransfer!=NULL  && 
                m_pCurTransfer->cbTransferred < m_pCurTransfer->cbBuffer)  { // Include Eaqual for 0 packet.
            DWORD dwReceiveLength = min (ReadByteCountRegister(),m_pCurTransfer->cbBuffer - m_pCurTransfer->cbTransferred);
            dwReceiveLength = ReceiveData((PBYTE)m_pCurTransfer->pvBuffer + m_pCurTransfer->cbTransferred,dwReceiveLength);
            m_pCurTransfer->cbTransferred += dwReceiveLength;
            if (m_pCurTransfer->cbTransferred >= m_pCurTransfer->cbBuffer) {
                WriteControlStatusRegister(udccsr.ulValue);
                PSTransfer pTransfer = CompleteTransfer(UFN_NO_ERROR);
                Unlock();
                m_pUsbDevice->MddTransferComplete(pTransfer);
                Lock();
                continue;
            }
            else
                bContinue = TRUE;
                
        }
        if ( udccsr.epbit.PC!=0 ) { // Packet Complete.
            if (udccsr.epbit.DPE!=0 ) { // Data Packet Error
                WriteControlStatusRegister(udccsr.ulValue);
                PSTransfer pTransfer = CompleteTransfer( UFN_NOT_COMPLETE_ERROR );
                Unlock();
                m_pUsbDevice->MddTransferComplete(pTransfer);
                Lock();                
                continue;
            }
            if ( m_pCurTransfer) {
                BOOL fShortPacket = FALSE;
                if (udccsr.epbit.BNE_BNF!=0 &&
                        m_pCurTransfer->cbTransferred < m_pCurTransfer->cbBuffer)  { // Last Try.
                    DWORD dwReceiveLength = min (ReadByteCountRegister(),m_pCurTransfer->cbBuffer - m_pCurTransfer->cbTransferred);
                    dwReceiveLength = ReceiveData((PBYTE)m_pCurTransfer->pvBuffer + m_pCurTransfer->cbTransferred,dwReceiveLength);
                    m_pCurTransfer->cbTransferred += dwReceiveLength;
                    fShortPacket = (dwReceiveLength!=0 && dwReceiveLength<m_epDesc.wMaxPacketSize) ;
                    
                }
                if (m_pCurTransfer->cbTransferred >= m_pCurTransfer->cbBuffer) {
                    WriteControlStatusRegister(udccsr.ulValue);
                    PSTransfer pTransfer = CompleteTransfer(UFN_NO_ERROR);
                    Unlock();
                    m_pUsbDevice->MddTransferComplete(pTransfer);
                    Lock();                
                    continue;
                }
                else if (udccsr.epbit.SP || fShortPacket ){
                    WriteControlStatusRegister(udccsr.ulValue);
                    PSTransfer pTransfer = CompleteTransfer(UFN_NO_ERROR);
                    Unlock();
                    m_pUsbDevice->MddTransferComplete(pTransfer);
                    Lock();                
                    continue;
                }
                bContinue = TRUE;
            }
            else { // Not ready yet.
                //m_pUsbDevice->EnableEndpointInterrupt(m_dwEndpointIndex,FALSE);
                // Do not clean anything
                udccsr.epbit.PC = 0;
                bContinue = FALSE;
            }
        }
        if (udccsr.epbit.SST) {
            OALMSG(OAL_ETHER&&OAL_WARN, (_T("Stall Sent on Out endpoint =0x%x\r\n"),m_dwEndpointIndex));
            m_fStalled = TRUE;
            bContinue = TRUE;
        }
        if (udccsr.ulValue)
            WriteControlStatusRegister(udccsr.ulValue);
    }
    Unlock();
    FUNCTION_LEAVE_MSG();
    return ERROR_SUCCESS;
}
BulUsbDevice::BulUsbDevice(LPCTSTR lpActivePath )
{
    m_pUsbDevReg = NULL;
    m_pDCCLKReg = NULL;
    m_fDoubleBuffer = TRUE;
    m_pvMddContext = NULL;
    m_dwCurConfigure = MAXDWORD;
    m_dwCurInterface = MAXDWORD;
    m_pfnNotify = NULL;
}

BulUsbDevice::~BulUsbDevice()
{
    for (DWORD dwIndex =0 ; dwIndex <MAX_ENDPOINT_NUMBER; dwIndex ++) {
        RemoveObjectBy( dwIndex );
    }
    
    if (m_pUsbDevReg!=NULL) {
        WriteIntrCtr0Register(0);
        WriteIntrCtr1Register(0);
        WriteControlRegister(0) ;
    }

    if (m_pDCCLKReg) {
        m_pDCCLKReg->cken &= ~XLLP_CLKEN_USBCLIENT ;
    }

}
DWORD BulUsbDevice::Init(
    PVOID                       pvMddContext,
    PUFN_MDD_INTERFACE_INFO     pMddInterfaceInfo,
    PUFN_PDD_INTERFACE_INFO     pPddInterfaceInfo
    )
{
    m_pvMddContext = pvMddContext;
    m_pfnNotify = pMddInterfaceInfo->pfnNotify;
    pPddInterfaceInfo->pvPddContext = this;
    
    m_fIsCableAttached = FALSE;
    if (m_pDCCLKReg == NULL ) {
        m_pDCCLKReg = (PBULVERDE_CLKMGR_REG)OALPAtoVA(BULVERDE_BASE_REG_PA_CLKMGR, FALSE);
        if (m_pDCCLKReg != NULL)
            m_pDCCLKReg->cken |= XLLP_CLKEN_USBCLIENT ;
        else
            return ERROR_INVALID_DATA;            
    }

    // Map Windows.
    // Translate to System Address.
    if (m_pUsbDevReg==NULL ) {
        m_pUsbDevReg = (PULONG) OALPAtoVA(BULVERDE_BASE_REG_PA_UDC, FALSE);
        if (m_pUsbDevReg==NULL )
            return ERROR_INVALID_DATA;
    }
        
    if (HardwareInit()) {
#if 0
        ThreadStart();
#endif
        return ERROR_SUCCESS;
    }
    else
        return ERROR_INVALID_DATA;
}
BOOL BulUsbDevice::HardwareInit()
{
    BOOL bReturn = TRUE;
    SETFNAME();
    FUNCTION_ENTER_MSG();
    Lock();
    // Disable Hardware
    UDCCR udccr;
    udccr.ulValue = ReadControlRegister();
    udccr.bit.UDE= udccr.bit.EMCE = 0;
    WriteControlRegister(udccr.ulValue);
    WriteIntrCtr0Register(0);
    WriteIntrCtr1Register(0); 
    // Ack all outstanding interrupt.
    WriteIntrStatus0Register(0xffffffff);
    WriteIntrStatus1Register(0xffffffff);
    Unlock();
    FUNCTION_LEAVE_MSG();
    return bReturn;
}
BOOL   BulUsbDevice::ReInit() // For Cable Detach & Attach , We have to re-init the Device Controller.
{
    Lock();
    HardwareInit();
    for (DWORD dwIndex=0; dwIndex<MAX_ENDPOINT_NUMBER; dwIndex++) {
        BulEndpoint *pEndpoint = ObjectIndex(dwIndex);
        if (pEndpoint!=NULL)  {
            pEndpoint->ReInit();
            pEndpoint->DeRef();
        }
    }
        
    //PVOID pvMddContext = m_pvMddContext;
    //m_pvMddContext = NULL;
    Start();
    
    for (dwIndex=0; dwIndex<MAX_ENDPOINT_NUMBER; dwIndex++) {
        if ( RawObjectIndex(dwIndex)!=NULL) {
            EnableEndpointInterrupt(dwIndex, TRUE);
        }
    }
    
    Unlock();
    return FALSE;
}
BOOL BulUsbDevice::DeleteAllEndpoint()
{
    for (DWORD dwIndex=0; dwIndex<MAX_ENDPOINT_NUMBER; dwIndex++)
        RemoveObjectBy( dwIndex );
    return TRUE;
}

//
#define UDCIR0_MAX 0x10
BOOL   BulUsbDevice::EnableEndpointInterrupt(DWORD dwEndpointIndex,BOOL bEnable)
{
    SETFNAME();
    OALMSG(OAL_ETHER&&OAL_INTR, (_T("%s Enter. dwEndpoint:0x%x,Enable:0x%x --\r\n"), pszFname,dwEndpointIndex,bEnable));
    
    if (dwEndpointIndex < MAX_ENDPOINT_NUMBER ) {
        Lock();
        if (dwEndpointIndex <UDCIR0_MAX) {
            DWORD dwIntrCtrBit = ((EPINT_PACKET_COMPLETE | EPINT_FIFO_ERROR) <<(dwEndpointIndex*2));
            DWORD dwIntrCtl = ReadIntrCtr0Register() ;
            if (bEnable)