bul_usbfn.h

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

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this sample source code is subject to the terms of the Microsoft
// license agreement under which you licensed this sample source code. If
// you did not accept the terms of the license agreement, you are not
// authorized to use this sample source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the LICENSE.RTF on your install media or the root of your tools installation.
// THE SAMPLE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES OR INDEMNITIES.
//
/*++

THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name: 

        bul_usbfn.h

Abstract:

        Bulverde USB Function Driver Header.

--*/
#ifndef __BUL_USBFN_H_
#define __BUL_USBFN_H_
#include <bulverde_usbd.h>
#include <bulverde_usbotg.h>
#include <bulverde_clkmgr.h>
#include <csync.h>
#include <cmthread.h>
#include <CRegEdit.h>
#include <CRefCon.h>
#include <usbfn.h>

#define ERRORCOUNTERINREGISTRY

#ifndef SHIP_BUILD
#define STR_MODULE _T("bulverde_usbfn!")
#define SETFNAME() LPCTSTR pszFname = STR_MODULE _T(__FUNCTION__) _T(":")
#else
#define SETFNAME()
#endif

#define MAX_ENDPOINT_NUMBER 0x18

class BulUsbDevice ;
class BulEndpoint ;

#define ENDPOINT_CONTROL_STATUS_REGISTER_OFFSET (0x100/sizeof(DWORD))
#define ENDPOINT_BYTECOUNT_REGISTER_OFFSET      (0x200/sizeof(DWORD))
#define ENDPOINT_DATA_REGISTER_OFFSET           (0x300/sizeof(DWORD))
#define ENDPOINT_CONFIGURATION_REGISTER_OFFSET  (0x400/sizeof(DWORD))

#define DEVICE_CONTROL_REGISTER (0/sizeof(DWORD))
#define DEVICE_INT_CR0_REGISTER (4/sizeof(DWORD))
#define DEVICE_INT_CR1_REGISTER (8/sizeof(DWORD))
#define DEVICE_INT_SR0_REGISTER (0xc/sizeof(DWORD))
#define DEVICE_INT_SR1_REGISTER (0x10/sizeof(DWORD))
#define DEVICE_Frame_NUMBER_REGISTER (0x14/sizeof(DWORD))
#define DEVICE_OTGICR_REGISTER (0x18/sizeof(DWORD))
#define DEVICE_OTGISR_REGISTER (0x1c/sizeof(DWORD))
// Registry Value.
#define BUL_USBFUNCTION_DOUBLEBUFFER_VALNAME TEXT("DoubleBuffer")
#define BUL_USBFUNCTION_DOUBLEBUFFER_VALTYPE REG_DWORD
#define BUL_USBFUNCTION_PRIORITY_VALNAME    TEXT("Priority256")
#define BUL_USBFUNCTION_PRIORITY_VALTYPE    REG_DWORD
// Debugging only registry.
#define BUL_USBFUNCTION_EP0_STALL_COUNTER_VALNAME TEXT("EP0StallCounter")
#define BUL_USBFUNCTION_EP0_STALL_COUNTER_VALTYPE REG_DWORD
#define BUL_USBFUNCTION_BAD_SETUP_COUNTER_VALNAME TEXT("BadSetupCounter")
#define BUL_USBFUNCTION_BAD_SETUP_COUNTER_VALTYPE REG_DWORD

#define BUL_USBFUNCTION_DEFAULT_PRIORITY    100
class CEndpointContainer : public CStaticContainer <BulEndpoint, MAX_ENDPOINT_NUMBER>
{
};
class BulOTGEventThread;
class BulUsbDevice :public CEndpointContainer, public CRegistryEdit, public CMiniThread {
public:
    BulUsbDevice(LPCTSTR lpActivePath);
    virtual ~BulUsbDevice();
    virtual DWORD Init(PVOID pvMddContext,
        PUFN_MDD_INTERFACE_INFO pMddInterfaceInfo, PUFN_PDD_INTERFACE_INFO pPddInterfaceInfo);
//  PDD interface.
    virtual BOOL DeleteAllEndpoint();
// Endpoint Function.
    virtual DWORD IsEndpointSupportable (DWORD dwEndpoint,UFN_BUS_SPEED Speed,PUSB_ENDPOINT_DESCRIPTOR pEndpointDesc,
            BYTE bConfigurationValue=1, BYTE bInterfaceNumber=0, BYTE bAlternateSetting=0 );
    virtual DWORD InitEndpoint(DWORD dwEndpoint,UFN_BUS_SPEED Speed,PUSB_ENDPOINT_DESCRIPTOR pEndpointDesc,
            BYTE bConfigurationValue=1, BYTE bInterfaceNumber=0, BYTE bAlternateSetting=0 );
    virtual DWORD DeinitEndpoint(DWORD dwEndpoint );
    virtual DWORD StallEndpoint(DWORD dwEndpoint );
    virtual DWORD ClearEndpointStall( DWORD dwEndpoint );
    virtual DWORD ResetEndpoint(DWORD dwEndpoint );
    virtual DWORD IsEndpointHalted( DWORD dwEndpoint, PBOOL pfHalted );
    virtual DWORD IssueTransfer(DWORD  dwEndpoint,PSTransfer pTransfer );
    virtual DWORD AbortTransfer(DWORD dwEndpoint, PSTransfer pTransfer);
    
//  Endpoint Zero Special
    virtual DWORD SendControlStatusHandshake(DWORD dwEndpoint);
//  Device Function.
    virtual DWORD Start();
    virtual DWORD Stop();
    virtual BOOL IsCableAttached() { return TRUE; };
    virtual DWORD  SetAddress( BYTE  bAddress );
    virtual void PowerDown();
    virtual void PowerUp() ;
    virtual void  SetPowerState( CEDEVICE_POWER_STATE cpsNew ) ;
    virtual DWORD IOControl( IOCTL_SOURCE source, DWORD dwCode, PBYTE  pbInBuf, DWORD cbInBuf, PBYTE pbOutBuf, DWORD cbOutBuf,PDWORD  pcbActualOutBuf );
    void    OTGSetupFeature() {
        m_fOTGSetupFeature = TRUE;
        ISTProcess();
    }
    
//  Register Access.
    void WriteUDCRegister(DWORD dwOffset, DWORD dwData) { 
        PREFAST_ASSERT(m_pUsbDevReg!=NULL);
        WRITE_REGISTER_ULONG(m_pUsbDevReg + dwOffset, dwData);
    }
    DWORD ReadUDCRegister(DWORD dwOffset) {
        PREFAST_ASSERT(m_pUsbDevReg!=NULL);
        return READ_REGISTER_ULONG(m_pUsbDevReg + dwOffset);
    }
    void WriteUDCRegisterByte(DWORD dwOffset, BYTE bData) {
        PREFAST_ASSERT(m_pUsbDevReg!=NULL);
        WRITE_REGISTER_UCHAR((PUCHAR)(m_pUsbDevReg + dwOffset),bData);
    }
    BYTE ReadUDCRegisterByte(DWORD dwOffset) {
        PREFAST_ASSERT(m_pUsbDevReg!=NULL);
        return READ_REGISTER_UCHAR ((PUCHAR)(m_pUsbDevReg + dwOffset));
    }

// Device Register Access.
    DWORD   ReadControlRegister() {  return ReadUDCRegister(DEVICE_CONTROL_REGISTER); }
    void    WriteControlRegister(DWORD dwData) { WriteUDCRegister(DEVICE_CONTROL_REGISTER, dwData);}
    DWORD   ReadIntrCtr0Register() { return ReadUDCRegister(DEVICE_INT_CR0_REGISTER); }
    DWORD   ReadIntrCtr1Register() { return ReadUDCRegister(DEVICE_INT_CR1_REGISTER); }
    DWORD   ReadIntrStatus0Register() { return ReadUDCRegister(DEVICE_INT_SR0_REGISTER); }
    DWORD   ReadIntrStatus1Register() { return ReadUDCRegister(DEVICE_INT_SR1_REGISTER); }
    void    WriteIntrCtr0Register(DWORD dwData) { WriteUDCRegister(DEVICE_INT_CR0_REGISTER, dwData); }
    void    WriteIntrCtr1Register(DWORD dwData) { WriteUDCRegister(DEVICE_INT_CR1_REGISTER, dwData); }
    void    WriteIntrStatus0Register(DWORD dwData) { WriteUDCRegister(DEVICE_INT_SR0_REGISTER,dwData); }
    void    WriteIntrStatus1Register(DWORD dwData) { WriteUDCRegister(DEVICE_INT_SR1_REGISTER,dwData); }

    DWORD   ReadOTGICR() { return ReadUDCRegister(DEVICE_OTGICR_REGISTER); };
    void    WriteOTGICR(DWORD dwData) { WriteUDCRegister(DEVICE_OTGICR_REGISTER,dwData); }
    DWORD   ReadOTGISR() { return ReadUDCRegister(DEVICE_OTGISR_REGISTER); };
    void    WriteOTGISR(DWORD dwData) { WriteUDCRegister(DEVICE_OTGISR_REGISTER,dwData); };
    // Interrupt
    BOOL    EnableEndpointInterrupt(DWORD dwEndpointIndex,BOOL bEnable);
    DWORD   GetEndpointIntrStatus(DWORD dwEndpointIndex);


    // 
    void MddTransferComplete(PSTransfer pTransfer) {
        SETFNAME();
        if (m_pvMddContext && pTransfer) {
            DEBUGMSG(ZONE_FUNCTION, (_T("%s MddTransferComplete pTransfer:0x%x"),pszFname,pTransfer));
            m_pfnNotify(m_pvMddContext, UFN_MSG_TRANSFER_COMPLETE, (DWORD) pTransfer);
        }
    }
    BOOL DeviceNotification( DWORD dwMsg, DWORD dwParam ) {
        SETFNAME();
        if (m_pvMddContext) {
            DEBUGMSG(ZONE_FUNCTION, (_T("%s DeviceNotification dwMsg:0x%x,dwParam:0x%x"),pszFname,dwMsg,dwParam));
            return m_pfnNotify(m_pvMddContext, dwMsg, dwParam);
        }
        else {
            DebugBreak();
            return FALSE;
        }
    }
public:
    // Debugging function.
    void IncEp0StallCounter() {
#ifdef ERRORCOUNTERINREGISTRY
        DWORD dwEp0StallCounter = 0;
        if (!GetRegValue(BUL_USBFUNCTION_EP0_STALL_COUNTER_VALNAME,(LPBYTE) &dwEp0StallCounter,sizeof(dwEp0StallCounter))) {
            dwEp0StallCounter = 0;
        }
        dwEp0StallCounter++;
        RegSetValueEx( BUL_USBFUNCTION_EP0_STALL_COUNTER_VALNAME,BUL_USBFUNCTION_EP0_STALL_COUNTER_VALTYPE,
            (PBYTE)&dwEp0StallCounter,sizeof(dwEp0StallCounter));
#endif
    }
    void IncBadSetupCounter() {
#ifdef ERRORCOUNTERINREGISTRY
        DWORD dwBadSetupCounter = 0;
        if (!GetRegValue(BUL_USBFUNCTION_BAD_SETUP_COUNTER_VALNAME,(LPBYTE) &dwBadSetupCounter,sizeof(dwBadSetupCounter))) {
            dwBadSetupCounter = 0;
        }
        dwBadSetupCounter++;
        RegSetValueEx( BUL_USBFUNCTION_BAD_SETUP_COUNTER_VALNAME, BUL_USBFUNCTION_BAD_SETUP_COUNTER_VALTYPE,
            (PBYTE)&dwBadSetupCounter,sizeof(dwBadSetupCounter));
#endif
    }
protected: 

    //virtual BulEndpoint * GetEndpointBy(DWORD dwEndpointIndex) {        
    //    return  (dwEndpointIndex<MAX_ENDPOINT_NUMBER ? m_EndpointArray[dwEndpointIndex]:NULL);
    //}
    virtual void PowerMgr(BOOL bOff);
    
    volatile PULONG  m_pUsbDevReg;
    volatile PBULVERDE_CLKMGR_REG m_pDCCLKReg;
    BOOL    m_fIsCableAttached;
    //BulEndpoint *   m_EndpointArray[MAX_ENDPOINT_NUMBER];