ohcd.hpp

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

    SThreadParams * pNext;
};

typedef BOOL (* LPUSBD_HCD_ATTACH_PROC)(LPVOID lpvHcd, LPCHCD_FUNCS lpHcdFuncs,
                                        LPLPVOID lppvContext);
typedef BOOL (* LPUSBD_HCD_DETACH_PROC)(LPVOID lpvContext);
typedef BOOL (* LPUSBD_ATTACH_PROC)(LPVOID lpvContext, UINT iDevice,
                                    UINT iEndpointZero,
                                    LPCUSB_DEVICE lpDeviceInfo,
                                    LPLPVOID lppvDeviceDetach);
typedef BOOL (* LPUSBD_DETACH_PROC)(LPVOID lpvDeviceDetach);


class COhcd
{
public:
    COhcd(LPVOID lpvOhcdPddObject, CPhysMem * pobMem,
            LPCWSTR szDriverRegistryKey, REGISTER regBase, DWORD dwSysIntr);
    ~COhcd();

    BOOL Initialize(void);

    static ULONG CALLBACK UsbDriverThreadStub(PVOID context);
    static ULONG CALLBACK UsbDriverCriticalThreadStub(PVOID context);
    static DWORD WINAPI DeviceStatusChangeStub(LPVOID lpvNotifyParameter);
//    static VOID CALLBACK PowerMgmtCallbackStub(DWORD dwContext, BOOL bOff);

    // Called indirectly through client threads

    BOOL GetFrameNumber(LPDWORD lpdwFrameNumber);
    BOOL GetFrameLength(LPUSHORT lpuFrameLength);
    BOOL SetFrameLength(HANDLE hEvent, USHORT uFrameLength);
    BOOL StopAdjustingFrame();

    BOOL OpenPipe(UINT iDevice, LPCUSB_ENDPOINT_DESCRIPTOR lpEndpointDescriptor,
            LPUINT lpiEndpointIndex);

    BOOL ClosePipe(UINT iDevice, UINT iEndpointIndex);
    BOOL ResetPipe(UINT iDevice, UINT iEndpointIndex);
    BOOL IsPipeHalted(UINT iDevice, UINT iEndpointIndex, LPBOOL lpbHalted);

    BOOL IssueTransfer(UINT iDevice, UINT iEndpointIndex,
            LPTRANSFER_NOTIFY_ROUTINE lpStartAddress, LPVOID lpvNotifyParameter,
            DWORD dwFlags, LPCVOID lpvControlHeader, DWORD dwStartingFrame,
            DWORD dwFrames, LPCDWORD aLengths, DWORD dwBufferSize,
            LPVOID lpvBuffer, ULONG paBuffer, LPCVOID lpvCancelId,
            LPDWORD adwIsochErrors, LPDWORD adwIsochLengths, LPBOOL lpfComplete,
            LPDWORD lpdwBytesTransfered, LPDWORD lpdwError);

    BOOL AbortTransfer(UINT iDevice, UINT iEndpointIndex,
                       LPTRANSFER_NOTIFY_ROUTINE lpStartAddress,
                       LPVOID lpvNotifyParameter, LPCVOID lpvCancelId);

    VOID PowerMgmtCallback(BOOL bOff);

private:
   int find_dev_with_endpt(SEndpoint *pEndpt);  // locate the SDevice index on which the endpoint is located
   BOOL m_fTimeWarp;    // TRUE iff we're processing a writebackdone queue from before a recent power-on
   BOOL m_fStabilizing; // TRUE while cleaning up after a power-suspend/resume cycle

#ifdef DEBUG

    EError GuaranteeTdList(SEndpoint *pEndpt);
    EError DumpRegisters(void);
    EError DumpControlQueue(void);
    EError DumpIsochQueue(void);
    void   DumpDeviceInfo(LPOHCI_DEVICE pDevInfo);
    void   DecodeControlTransfer(SEndpoint * pEndpt, PUSB_DEVICE_REQUEST pDr);
#endif
    DWORD UsbDriverCriticalThread(void);
    DWORD UsbDriverThread(void);
    DWORD DeviceStatusChange(SThreadParams * pThreadInfo);
    EError InitializeSchedule(void);
    EError InitializeInterruptEds(void);
    EError InitializeHardware(void);
    VOID   EnterOperationalState(void);
#ifdef USE_CRITICAL_THREAD
    EError DeQueueCriticalITd(ULONG paITd);
    EError DeQueueCriticalTd(ULONG paTd);
    EError HandleCriticalWritebackDone(ULONG paDoneHead);
#endif
    EError DeQueueTdList(ULONG paTdHead);
    EError CopyIsochFrameData(
            SIsochTransferDescriptor * pITd, STransfer * pTransfer);
    EError DeQueueITdList(ULONG paITdHead);
    EError HandleWritebackDone(ULONG paDoneHead);
    EError HandleConnectChange(void);
    EError CleanupSchedule(void);
    BOOL CleanupFrame(void);
    EError FreeTds(SEndpoint * pEndpt, LPCVOID lpvCancelId);
    EError CleanupEds(void);

    ULONG   GrowTdList(ULONG cNumITds);
    SEndpointDescriptor * GetEd(void);
    SGeneralTransferDescriptor * GetTd(UINT numToGet = 1);
    EError FreeTd(SGeneralTransferDescriptor * pTd);
    ULONG  GrowITdList(ULONG cNumITds);
    SIsochTransferDescriptor * GetITd(void);
    EError FreeITd(SIsochTransferDescriptor * pITd);
    SDevice * FindDevice(UCHAR hub, UCHAR port, UCHAR configStatus);
    EError GetDeviceDescriptor(SDevice * pDev, DWORD dwBufferSize);
    EError GetInitialDeviceDescriptor(SDevice * pDev0);
    EError SetAddress(SDevice * pDev0);
    EError GetRealDeviceDescriptor(SDevice * pDev);
    EError ParseDeviceDescriptor(SDevice * pDev);
    EError GetConfigDesc(SDevice *pDev, UINT iConfiguration,
            DWORD dwBufferSize);
    EError SendRealGetConfig(SDevice * pDev);
    EError ParseConfigDescriptor(SDevice * pDev);
    EError CheckConfiguration(SDevice * pDev, UINT iConfiguration);
    EError CheckHubPowerConfiguration(SDevice * pDev);
    EError SetConfiguration(SDevice * pDev, UINT iConfiguration);
    EError DoneInitialDeviceSetup(SDevice * pDev);
    EError FreeAddr0(void);
    UINT CalculateOverhead(UCHAR bEndptType, UINT cMaxPacket);
    BOOL CalculateBandwidth(UINT nRequiredBandwidth, PUINT pCurBandwidth);
    EError HandlePowerUp(void);

    EError InitializeHub(SDevice * pDev, PUSB_ENDPOINT_DESCRIPTOR pEd);

    EError ConfigureHub(SDevice * pDev);

    EError SendHubPortTransfer(SDevice * pDev, UCHAR bRequest, USHORT wValue,
                               USHORT wIndex);

    EError PowerHubPorts(SDevice * pDev);

    EError SendHubInterrupt(SDevice * pDev);

    UINT FindSignaledPort(PBYTE pBuffer, UINT bufferSize);

    EError HandleHubInterrupt(SDevice * pDev);

    EError InterpretPortStatus(SDevice * pDev);

    EError IssuePortReset(SDevice *pDev, BOOL fRootHub, DWORD dwDelay);
    static ULONG  CALLBACK ResetPortStub(LPVOID context);
    DWORD  ResetPortThread(SDevice *pDev, BOOL fRootHub, DWORD dwDelay);

    EError ResetHubPort(SDevice * pDev);

    EError GetStatus(SDevice * pDev, BOOL fDeviceStatus);

    EError FinishResettingPort(SDevice * pDev);


    EError ClearPortChangeNotifications(SDevice * pDev);

    EError FreeHubPort0(SDevice * pDev);

    EError FreeEndptDesc(SEndpointDescriptor * pEd, BOOL bIsIsoch);

    UINT ConvertInterval(UCHAR interval, PUCHAR pNewInterval);

    EError AddEndptDescToSchedule(SEndpointDescriptor * pEd, UCHAR endptType,
            UCHAR intrInterval, UINT nReservedBandwidth);

    ULONG FindIntrAddLocation(UCHAR intrInterval);

    EError RemoveEndptDescFromSchedule(SEndpointDescriptor * pEd,
                                       UCHAR endptType);

    BOOL FindEdInIntrBranch(ULONG paEd, PULONG ppaCur, PULONG ppaPrev,
            UINT depth);

    SDevice * AddDevice(UCHAR hubNum, UCHAR port, UCHAR bIsLowSpeed);


   EError EnqueueDeviceStatusChange(SDevice *pDev, BOOL fAttach);

    EError RemoveDevice(SDevice * pDev);

    EError MarkDeviceForRemoval(SDevice * pDev);

    SEndpoint * AddEndpoint(SDevice * pDev, PCUSB_ENDPOINT_DESCRIPTOR pUEd,
            UINT nReservedBandwidth);

    EError RemoveEndpoint(SEndpoint * pEndpt);

    EError RemoveMultipleEndpoints(SDevice * pDev, UINT first, UINT last);

    EError InitiateGeneralTransfer(SEndpoint * pEndpt, STransfer * pTransfer,
            BOOL fToDevice, BOOL fShortPacketOk, ULONG paSetupBuf,
            SPhysAddr *pDataHead, BOOL fAddTransfer);

    EError InitiateIsochTransfer(SEndpoint * pEndpt, STransfer * pTransfer,
            SPhysAddr * pDataHead, BOOL fUseStartingFrame,
            DWORD dwStartingFrame, const DWORD * aOffsets);

//  USHORT
//  CalculateIsochStartFrame(
//      SEndpointDescriptor *pEd);

    EError CompleteTransfer(SDevice * pDev, SEndpoint * pEndpt,
                            DWORD conditionCode);


    EError CompleteClassTransfer(SEndpoint * pEndpt, DWORD conditionCode,
                                 STransfer * pTransfer);

    PCHCD_FUNCS m_pHcdFuncs;
    LPVOID m_pvOhcdPddObject;

    ULONG m_paWriteBackDone;
    ULONG m_paWriteBackDone2;
    ULONG m_paLastWriteBackDone;

    ULONG m_paHcControlHeadEdSave;
    ULONG m_paHcBulkHeadEdSave;

    BOOL m_fWDH;
    BOOL m_fSF;
    BOOL m_fRHSC;
    BOOL m_fSO;
    BOOL m_fUE;
    BOOL m_fFNO;

    HANDLE m_hClientDriverComplete;
    HANDLE m_hUsbPsudoInterrupt;

    BOOL m_fCriticalRunning;

#ifdef USE_CRITICAL_THREAD
    INT m_cCriticalTds;
    HANDLE m_hReleaseCriticalThread;
    HANDLE m_hCriticalThreadDone;
    HANDLE m_hCriticalThread;
#endif

    HANDLE m_hUsbInterrupt;
    HANDLE m_hIsrThread;
    BOOL m_bClosing;
    BOOL m_bPoweredUpAfterPowerDown;

    REGISTER    m_regBase;
    DWORD   m_sysIntr;

#ifdef USE_CRITICAL_THREAD
    CRITICAL_SECTION m_csClientInstallCriticalThread;
    CRITICAL_SECTION m_csCriticalTds;
#endif

    CRITICAL_SECTION m_csTdListsLock;

    SGeneralTransferDescriptor * m_pFreeTdList;
    SIsochTransferDescriptor * m_pFreeITdList;

    CRITICAL_SECTION m_csSTdInfoListLock;
    STdInfo * m_pFreeSTdInfoHead;
    STdInfo * m_pTdProcessList;


    CRITICAL_SECTION m_csScheduleLock; // locks anything to do with ED's

    HINSTANCE   m_hUSBDInstance;
    LPUSBD_ATTACH_PROC      m_pAttachProc;
    LPUSBD_DETACH_PROC      m_pDetachProc;
    LPVOID                  m_pvHcdContext;

    CRITICAL_SECTION m_csFrameAdjustment;
    HANDLE  m_hAdjustmentEvent;
    INT     m_nAdjustFrame;
    SHORT   m_nLastAdjustmentFrame;
    BOOL    m_fAdjust;

    UINT    m_nReserveFakeBandwidth;
    DWORD   m_dwFrameNumber;

    UINT    m_numRootHubPorts;
    CRITICAL_SECTION m_csAddr0Lock;
    CRITICAL_SECTION m_csPortPower;
    DWORD   *m_PortPowerAllocated;     // Array of numRootHubPorts for tracking power
    UINT    m_PowerOnToPowerGoodTime;  // In 2ms increments
    BOOL    m_bAddr0Busy;
    UINT    m_addrThatOwnsAddr0;
    UINT    m_numPortsWaitingForAddr0;
    UINT    m_addr0CurRetryValue;

    UINT    m_schedOverrunCount;

    PBYTE   m_pHcca;

    ULONG   m_paLastIntrEd;

    CPhysMem *m_pobMem;
//  PDRIVER_OBJECT m_pDriverObject;
    UINT m_curMaxNumDevices;

    CRITICAL_SECTION m_csDeviceListLock;
    SDevice **m_ppDevices;

    CRITICAL_SECTION m_csEdInfoListsLock;
    SEdInfo * m_pFreeSEdInfoHead;
    SEdInfo *m_pEdRemovalList;

    CRITICAL_SECTION m_csOtherListsLock;
    SPhysAddr *m_pFreePhysAddrHead;
    STransfer *m_pFreeTransferHead;

    CRITICAL_SECTION m_csThreadParamListLock;
    SThreadParams * m_pFreeThreadParamsHead;
    SThreadParams * m_pActiveThreadParamsHead;

};



inline UINT
CalcHubIntrDataSize(UINT numPorts)
{
    // Calculate the number of bytes needed to hold interrupt data for
    // this number of ports.  Need 1 bit per port and bit zero is reserved.
    return(((numPorts + 1) / 8) + 1);
}

extern "C"
{

BOOL HcdGetFrameNumber(LPVOID lpvHcd, LPDWORD lpdwFrameNumber);
BOOL HcdGetFrameLength(LPVOID lpvHcd, LPUSHORT lpuFrameLength);
BOOL HcdSetFrameLength(LPVOID lpvHcd, HANDLE hEvent, USHORT uFrameLength);
BOOL HcdStopAdjustingFrame(LPVOID lpvHcd);


BOOL HcdOpenPipe(LPVOID lpvHcd, UINT iDevice,
                 LPCUSB_ENDPOINT_DESCRIPTOR lpEndpointDescriptor,
                 LPUINT lpiEndpointIndex);
BOOL HcdClosePipe(LPVOID lpvHcd, UINT iDevice, UINT iEndpointIndex);
BOOL HcdResetPipe(LPVOID lpvHcd, UINT iDevice, UINT iEndpointIndex);
BOOL HcdIsPipeHalted(LPVOID lpvHcd, UINT iDevice, UINT iEndpointIndex,
        LPBOOL lpbHalted);


BOOL HcdIssueTransfer(LPVOID lpvHcd, UINT iDevice, UINT iEndpointIndex,
                      LPTRANSFER_NOTIFY_ROUTINE lpStartAddress,
                      LPVOID lpvNotifyParameter, DWORD dwFlags,
                      LPCVOID lpvControlHeader, DWORD dwStartingFrame,
                      DWORD dwFrames, LPCDWORD aLengths, DWORD dwBufferSize,
                      LPVOID lpvBuffer, ULONG paBuffer, LPCVOID lpvCancelId,
                      LPDWORD adwIsochErrors, LPDWORD adwIsochLengths,
                      LPBOOL lpfComplete, LPDWORD lpdwBytesTransfered,
                      LPDWORD lpdwError);

BOOL HcdAbortTransfer(LPVOID lpvHcd, UINT iDevice, UINT iEndpointIndex,
                      LPTRANSFER_NOTIFY_ROUTINE lpStartAddress,
                      LPVOID lpvNotifyParameter, LPCVOID lpvCancelId);

}

#endif // _OHCD_HPP_