bul_usbfn.h

Windows CE 6.0 BSP for VOIP sample phone. Intel PXA270 platform.

    // IST
    DWORD       m_dwSysIntr;
    HANDLE      m_hISTEvent;
    DWORD       m_dwPriority;

    BOOL        m_fDoubleBuffer;
    PVOID       m_pvMddContext;

    // Protected Fucntion
    BOOL        HardwareInit();
    BOOL        ReInit(); // For Cable Detach & Attach , We have to re-init the Device Controller.
    // Device Info.
    DWORD       m_dwCurConfigure;
    DWORD       m_dwCurInterface;

    PFN_UFN_MDD_NOTIFY      m_pfnNotify;
    CEDEVICE_POWER_STATE    m_CurPowerState;
    HANDLE                  m_hParent;

    CLockObject m_ISTLock;
    void    ISTProcess();
    BOOL    m_fOTGSetupFeature;
private:
    DWORD   ThreadRun();
    UDCCR   m_prevUDCR;
    HANDLE  m_hOTGEvent;
    BulOTGEventThread * m_pOTGEventThread;
};

class BulOTGEventThread: public CMiniThread {
public :
    BulOTGEventThread(  BulUsbDevice& BulverUSBDevice, HANDLE& hOTGEvent,DWORD dwPrority);
    ~BulOTGEventThread();
    BOOL Init() {
        CeSetPriority(m_dwPriority);
        ThreadStart();
        return TRUE;
    }
private:
    DWORD   ThreadRun();
    BulUsbDevice&   m_BulverUSBDevice;
    HANDLE&         m_hOTGEvent;
    DWORD           m_dwPriority;
};
class BulEndpoint:public CRefObject , public CLockObject {
public :
    BulEndpoint(BulUsbDevice * const pUsbDevice, const DWORD dwPipeIndex,BOOL bDoubleBuffer = TRUE ) 
    :   m_pUsbDevice(pUsbDevice)
    ,   m_dwEndpointIndex(dwPipeIndex)
    ,   m_fDoubleBuffer(bDoubleBuffer)
    {
        m_pCurTransfer = NULL;
    }
    virtual ~BulEndpoint() {
        if (m_pUsbDevice)
            m_pUsbDevice->EnableEndpointInterrupt(m_dwEndpointIndex,FALSE);
    }
    virtual BOOL Init(PUSB_ENDPOINT_DESCRIPTOR pEndpointDesc,
            BYTE bConfigurationValue, BYTE bInterfaceNumber, BYTE bAlternateSetting);
    virtual BOOL ReInit();
    // Read & Write UDCCSR
    DWORD   ReadControlStatusRegister() {
        PREFAST_ASSERT(m_pUsbDevice!=NULL);
        PREFAST_ASSERT(m_dwEndpointIndex<MAX_ENDPOINT_NUMBER);
        return m_pUsbDevice->ReadUDCRegister( ENDPOINT_CONTROL_STATUS_REGISTER_OFFSET + m_dwEndpointIndex);
    }; 
    void    WriteControlStatusRegister(DWORD dwData) {
        PREFAST_ASSERT(m_pUsbDevice!=NULL);
        PREFAST_ASSERT(m_dwEndpointIndex<MAX_ENDPOINT_NUMBER);
        m_pUsbDevice->WriteUDCRegister( ENDPOINT_CONTROL_STATUS_REGISTER_OFFSET + m_dwEndpointIndex,dwData);
    };
    // Read UDCBCR
    DWORD   ReadByteCountRegister(){
        PREFAST_ASSERT(m_pUsbDevice!=NULL);
        PREFAST_ASSERT(m_dwEndpointIndex<MAX_ENDPOINT_NUMBER);
        return ((m_pUsbDevice->ReadUDCRegister( ENDPOINT_BYTECOUNT_REGISTER_OFFSET + m_dwEndpointIndex)) & 0x3ff);
    }
    // Read or Write UDCDR.
    BYTE    ReadDataRegisterByte() {
        PREFAST_ASSERT(m_pUsbDevice!=NULL);
        PREFAST_ASSERT(m_dwEndpointIndex<MAX_ENDPOINT_NUMBER);
        return (m_pUsbDevice->ReadUDCRegisterByte( ENDPOINT_DATA_REGISTER_OFFSET + m_dwEndpointIndex));
    }
    // Read or Write UDCDR.
    DWORD    ReadDataRegister() {
        PREFAST_ASSERT(m_pUsbDevice!=NULL);
        PREFAST_ASSERT(m_dwEndpointIndex<MAX_ENDPOINT_NUMBER);
        return ( m_pUsbDevice->ReadUDCRegister( ENDPOINT_DATA_REGISTER_OFFSET + m_dwEndpointIndex));
    }
    void    WriteDataRegisterByte(BYTE bData) {
        PREFAST_ASSERT(m_pUsbDevice!=NULL);
        PREFAST_ASSERT(m_dwEndpointIndex<MAX_ENDPOINT_NUMBER);
        m_pUsbDevice->WriteUDCRegisterByte( ENDPOINT_DATA_REGISTER_OFFSET + m_dwEndpointIndex, bData);
    }
    void    WriteDataRegister(DWORD dwData) {
        PREFAST_ASSERT(m_pUsbDevice!=NULL);
        PREFAST_ASSERT(m_dwEndpointIndex<MAX_ENDPOINT_NUMBER);
        m_pUsbDevice->WriteUDCRegister( ENDPOINT_DATA_REGISTER_OFFSET + m_dwEndpointIndex, dwData);
    }
    // Read Or Write UDCCR.
    DWORD   ReadConfigurationRegister() {
        PREFAST_ASSERT(m_pUsbDevice!=NULL);
        PREFAST_ASSERT(m_dwEndpointIndex<MAX_ENDPOINT_NUMBER);
        if (m_pUsbDevice!=0) { // Endpoint ZERO is not supported
            return m_pUsbDevice->ReadUDCRegister( ENDPOINT_CONFIGURATION_REGISTER_OFFSET + m_dwEndpointIndex );
        }
        else {
            ASSERT(FALSE);
            return 0;
        }
    }
    void    WriteConfigurationRegister(DWORD dwData) {
        PREFAST_ASSERT(m_pUsbDevice!=NULL);
        PREFAST_ASSERT(m_dwEndpointIndex<MAX_ENDPOINT_NUMBER);
        if (m_pUsbDevice!=0) { // Endpoint ZERO is not supported
            m_pUsbDevice->WriteUDCRegister( ENDPOINT_CONFIGURATION_REGISTER_OFFSET + m_dwEndpointIndex, dwData );
        }
        else {
            ASSERT(FALSE);
        }
    }

    
    // Supported Function.
    virtual DWORD InitEndpoint(UFN_BUS_SPEED Speed,PUSB_ENDPOINT_DESCRIPTOR pEndpointDesc) {
        // We should Reset the EndPoint and clear FIFO
        ResetEndpoint();
        return (m_pUsbDevice->EnableEndpointInterrupt(m_dwEndpointIndex,TRUE)?ERROR_SUCCESS:ERROR_GEN_FAILURE);
    }
    virtual DWORD DeinitEndpoint() {
        return (m_pUsbDevice->EnableEndpointInterrupt(m_dwEndpointIndex,FALSE)?ERROR_SUCCESS:ERROR_GEN_FAILURE);
    }
    virtual DWORD StallEndpoint();
    virtual DWORD ClearEndpointStall();
    virtual DWORD ResetEndpoint();
    virtual DWORD IsEndpointHalted(PBOOL pfHalted );
    virtual DWORD IssueTransfer(PSTransfer pTransfer ) ;
    virtual DWORD AbortTransfer(PSTransfer pTransfer );
    virtual DWORD SendControlStatusHandshake() { return ERROR_INVALID_PARAMETER; };
    // Attribute.
    USB_ENDPOINT_DESCRIPTOR GetEndpointDescriptor() { return m_epDesc; };
    // IST
    virtual DWORD   IST(DWORD dwIRBit) = 0 ;
protected:
    BulUsbDevice * const    m_pUsbDevice;
    const DWORD             m_dwEndpointIndex;
    USB_ENDPOINT_DESCRIPTOR m_epDesc;
    BYTE            m_bConfigurationValue,m_bInterfaceNumber,m_bAlternateSetting;
    BOOL            m_fDoubleBuffer;
    PSTransfer      m_pCurTransfer;
    BOOL            m_fZeroPacket;
    BOOL            m_fStalled;
//  Help Function.
    PSTransfer CompleteTransfer(DWORD dwError);
    void SendFakeFeature(BYTE bReuqest,WORD wFeatureSelector);
    DWORD XmitData(PBYTE pBuffer, DWORD dwLength);
    DWORD ReceiveData(PBYTE pBuffer, DWORD dwLength);    
};
#define EP0_MAX_PACKET_SIZE 0x10 
class BulEndpointZero : public BulEndpoint {
public:
    BulEndpointZero(BulUsbDevice * const pUsbDevice, BOOL bDoubleBuffer = TRUE ) 
        : BulEndpoint(pUsbDevice, 0 ,bDoubleBuffer) 
    {
        m_bNeedAck = FALSE;
        m_bSetupDirIn = FALSE;
        m_fInIST = FALSE;
    }
    BOOL Init(PUSB_ENDPOINT_DESCRIPTOR pEndpointDesc,
            BYTE bConfigurationValue, BYTE bInterfaceNumber, BYTE bAlternateSetting);   
    virtual BOOL ReInit();
    DWORD ResetEndpoint();
    DWORD IssueTransfer(PSTransfer pTransfer );
    DWORD SendControlStatusHandshake() ;
    DWORD   IST(DWORD dwIRBit);
protected:
    BOOL  ContinueTransfer();
    BOOL  m_bNeedAck;
    BOOL  m_bSetupDirIn;
    BOOL  m_fInIST ;
private:
    USB_DEVICE_REQUEST m_backup_udr;
    USB_DEVICE_REQUEST m_cur_udr;
    BOOL               m_fBackedudr;
};

class BulEndpointIn : public BulEndpoint  {
public:
    BulEndpointIn(BulUsbDevice * const pUsbDevice,DWORD dwEndpointIndex, BOOL bDoubleBuffer = TRUE )
        : BulEndpoint(pUsbDevice, dwEndpointIndex ,bDoubleBuffer) 
    {;
    }
    DWORD   IST(DWORD dwIRBit) ;
};

class BulEndpointOut : public BulEndpoint  {
public:
    BulEndpointOut(BulUsbDevice * const pUsbDevice,DWORD dwEndpointIndex, BOOL bDoubleBuffer = TRUE )
        : BulEndpoint(pUsbDevice, dwEndpointIndex ,bDoubleBuffer) 
    {;
    }
    DWORD   IST(DWORD dwIRBit) ;
};


BulUsbDevice * CreateBulUsbDevice(LPCTSTR lpActivePath);

#endif