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 CPhcd
{
public:
    CPhcd::CPhcd(LPVOID lpvPhcdPddObject, CPhysMem * pobMem,
            LPCWSTR szDriverRegistryKey, REGISTER regBase, DWORD dwSysIntr);
    ~CPhcd();

    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 DumpRegisters(void);
	void   DecodeControlTransfer(SEndpoint * pEndpt, PUSB_DEVICE_REQUEST pDr);
    EError GuaranteeTdList(SEndpoint *pEndpt);
    EError DumpControlQueue(void);
    EError DumpIsochQueue(void);
    void   DumpDeviceInfo(LPPHCI_DEVICE pDevInfo);
//#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_pvPhcdPddObject;

    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;

	//Zouying, Added potion for ISP 1161
	static ULONG CALLBACK Isp1161AuxThreadStub(PVOID);
	DWORD Isp1161AuxThread();

	DWORD	ServiceList(PULONG);
	DWORD	ServiceATLList();
	DWORD	ServiceITLList();
	VOID	ServiceEndpoint(UINT);
	VOID	ServiceATLTransferDescriptor();
	VOID	ServiceITLTransferDescriptor(ULONG, ULONG m_TdsPutToITL[]);
	
	VOID	CheckITLList(PULONG, ULONG m_TdsPutToITL[], PULONG);
	VOID    IspTDTransferComplete(PULONG);
	VOID    ReDumpPtd();

	ULONG							m_ControlBulkRatio;
	ULONG							m_EdpointServicedOne1ms;
	ULONG							m_TdsPutToATL[10];
	ULONG							m_TdsPutToITLFirst[10];
	ULONG							m_TdsPutToITLSecond[10];
	

	SPhilipsTransferDescriptor		sPTDReDump[10];
	BOOL							m_bsPTDReDump[10];

	BOOL							m_bReDump;

	ULONG							m_TdsPutToATLIndex;
	ULONG							m_TdsPutToITLFirstIndex;
	ULONG							m_TdsPutToITLSecondIndex;
	

	BOOL							m_ATLBeingReadOut;
	UINT							uFrameNumber;
	UINT							uDumpingFrame;
	UINT							uTimes;
	UINT							uTesting;
	
	
	ULONG							m_DataToggleBit;
	USHORT							m_ATLTransferLen;
	USHORT							m_ITLATransferLen;
	USHORT							m_ITLBTransferLen;
	USHORT							m_ITLCTransferLen;
	USHORT							m_ITLDTransferLen;

	ULONG							m_HcBulkHeadED;
	ULONG							m_HcBulkCurrentED;
	ULONG							m_HcControlHeadED;
	ULONG							m_HcControlCurrentED;
	ULONG							m_HcHCCA;
	ULONG							m_HcPeriodCurrentED;
	ULONG							m_HcDoneHead;
	ULONG							m_HcPeriodicStart;

	ULONG							m_HcControlCBSR;
	ULONG							m_HcControlPLE;
	ULONG							m_HcControlIE;
	ULONG							m_HcControlCLE;