//        return(STATUS_UNSUCCESSFUL);
        return FALSE;
    }

    m_hClientDriverComplete = CreateEvent(NULL, FALSE, FALSE, NULL);
    if(m_hClientDriverComplete == NULL)
    {
        DEBUGMSG(ZONE_ERROR,
        (TEXT("PHCD: Error on CreateEvent\r\n")));
//        return(STATUS_UNSUCCESSFUL);
        return FALSE;
    }

    // Just to make sure this is really ours.
    InterruptDisable(m_sysIntr);

    bOk = InterruptInitialize(m_sysIntr, m_hUsbInterrupt, 0, 0);
    if (!bOk)
    {
        DEBUGMSG(ZONE_ERROR,
        (TEXT("PHCD: Error on InterruptInitialize\r\n")));
//        return(STATUS_UNSUCCESSFUL);
        return FALSE;
    }

	// Set up HCCA memory area 
    errorCode = InitializeSchedule();
    if (errorCode != successful)
    {
        DEBUGMSG(ZONE_ERROR,
            (TEXT("PHCD: Unable to initialize schedule\r\n")));
//        return(STATUS_UNSUCCESSFUL);
        return FALSE;
    }
	

	// Initialize PHCI controller
    errorCode = InitializeHardware();
    if (errorCode != successful)
    {
        DEBUGMSG(ZONE_ERROR,
            (TEXT("PHCD: Unable to initialize hardware\r\n")));
//        return(STATUS_UNSUCCESSFUL);
        return FALSE;
    }

    // Start processing frames
    EnterOperationalState();

    // Start up our IST  
    m_hIsrThread = CreateThread(0, 0, UsbDriverThreadStub, this, 0, NULL);
    if (m_hIsrThread == NULL)
    {
        DEBUGMSG(ZONE_ERROR,
        (TEXT("PHCD: Error on CreateThread\r\n")));
//        return(STATUS_UNSUCCESSFUL);
        return FALSE;
    }

   /* 
	m_hIsrThread = CreateThread(0, 0, Isp1161AuxThreadStub, this, 0, NULL);
    if (m_hIsrThread == NULL)
    {
        DEBUGMSG(ZONE_ERROR,
        (TEXT("PHCD: Error on CreateThread\r\n")));
//        return(STATUS_UNSUCCESSFUL);
        return FALSE;
    }
	*/




#ifdef USE_CRITICAL_THREAD
    m_hCriticalThread = CreateThread(0, 0, UsbDriverCriticalThreadStub, this, 0,
            NULL);
    if (m_hCriticalThread == NULL)
    {
        DEBUGMSG(ZONE_ERROR,
        (TEXT("PHCD: Error on CreateThread\r\n")));
//        return(STATUS_UNSUCCESSFUL);
        return FALSE;
    }
#endif

    RETAILMSG(ISPDBG,(TEXT("-PHCD::Initialize\r\n")));

    return TRUE;
//    return(STATUS_SUCCESS);
}


//#ifdef DEBUG
EError CPhcd::GuaranteeTdList(SEndpoint *pEndpt)
{
    SEndpointDescriptor * pEd = pEndpt->pEd;

    ULONG   paHead = pEd->paTdQueueHead & gcEdTdQueueHeadMask;
    ULONG   paTail = pEd->paTdQueueTail;

    if(pEndpt->endptType == gcEndptTypeIsochronous)
    {
        while(paHead != paTail)
        {
            SIsochTransferDescriptor * pITd =
                    (SIsochTransferDescriptor *)m_pobMem->PaToVa(paHead);
            paHead = pITd->paNextTd;
            ASSERT(paHead);
        }
    }
    else
    {
        while(paHead != paTail)
        {
            SGeneralTransferDescriptor * pTd =
                    (SGeneralTransferDescriptor *)m_pobMem->PaToVa(paHead);
            paHead = pTd->paNextTd;
            ASSERT(paHead);
        }
    }
    return successful;
}

EError CPhcd::DumpRegisters(void)
{
    REGISTER    regBase = m_regBase;
    UINT port;
    ULONG   ulTemp;
    UINT    lastRootPortNum = gcFirstRootPortNum + m_numRootHubPorts;

	RETAILMSG(1, (TEXT("PHCD: Command And Status Partition\r\n")));
    ulTemp = READ_REGISTER_ULONG(HcRevision(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcRevision = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcControl(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcControl = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcCommandStatus(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcCommandStatus = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcInterruptStatus(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcInterruptStatus = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcInterruptEnable(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcInterruptEnable = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcInterruptDisable(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcInterruptDisable = 0x%08X\r\n"),
        ulTemp));

    RETAILMSG(1, (TEXT("PHCD: Memory Pointer Partition\r\n")));
    ulTemp = READ_REGISTER_ULONG(HcHCCA(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcHCCA = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcPeriodCurrentEd(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcPeriodCurrentEd = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcControlHeadEd(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcControlHeadEd= 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcControlCurrentEd(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcControlCurrentEd= 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcBulkHeadEd(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcBulkHeadEd = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcBulkCurrentEd(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcBulkCurrentEd = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcDoneHead(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcDoneHead = 0x%08X\r\n"),
        ulTemp));

    RETAILMSG(1, (TEXT("PHCD: Frame Counter Partition\r\n")));
    ulTemp = READ_REGISTER_ULONG(HcFmInterval(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcFmInterval = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcFmRemaining(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcFmRemaining = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcFmNumber(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcFmNumber = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcPeriodicStart(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcPeriodicStart = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcLSThreshold(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcLSThreshold = 0x%08X\r\n"),
        ulTemp));

    RETAILMSG(1, (TEXT("PHCD: Root Hub Partition\r\n")));

    ulTemp = READ_REGISTER_ULONG(HcRhDescriptorA(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcRhDescriptorA = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcRhDescriptorB(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcRhDescriptorB = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcRhStatus(regBase));
    RETAILMSG(1, (TEXT("PHCD: HcRhStatus = 0x%08X\r\n"),
        ulTemp));

    for (port = gcFirstRootPortNum; port < lastRootPortNum; port++)
    {
        ulTemp = READ_REGISTER_ULONG(HcRhPortStatus(regBase, port));
        RETAILMSG(1, (TEXT("PHCD: HcPortStatus%d = 0x%08X\r\n"),
            port, ulTemp));

    }

    return(successful);
}

static void DumpEd(ULONG paEd, SEndpointDescriptor * pEd)
{
    RETAILMSG(ISPDBG, (TEXT("PHCD: paEd %08X, pEd %08X\r\n")
                 TEXT("  addr %02X endpt %01X dir %01X lowSpeed %d skip %d isoch %d\r\n")
                 TEXT("  maxpacket %03X queueTail %08X queueHead %08X nextEd %08X\r\n"),
                 paEd, pEd,pEd->bfFunctionAddress, pEd->bfEndpointNumber, pEd->bfDirection,
                 pEd->bfIsLowSpeed, pEd->bfSkip, pEd->bfIsIsochronous,
                 pEd->bfMaxPacketSize, pEd->paTdQueueTail, pEd->paTdQueueHead,
                 pEd->paNextEd));
}
static void DumpTd(ULONG paTd, SGeneralTransferDescriptor *pTd)
{
    RETAILMSG(ISPDBG, (TEXT("PHCD: paTd %08X, pTd %08X\r\n")
                 TEXT("  addr %02X endpt %02X isoch %d shortPkOk %d PID %01X\r\n")
                 TEXT("  delayIntr %01X dataTog %01X errorCount %02X cc %01X\r\n")
                 TEXT("  buffer %08X nextTd %08X bufferEnd %08X\r\n"),
                 paTd, pTd,pTd->bfAddr, pTd->bfEndptArrayNum, pTd->bfIsIsoch,
                 pTd->bfShortPacketOk, pTd->bfPID, pTd->bfDelayInterrupt,
                 pTd->bfDataToggle, pTd->bfErrorCount, pTd->bfConditionCode,
                 pTd->paCurBuffer, pTd->paNextTd, pTd->paBufferEnd));
}
static void DumpITd(ULONG paITd, SIsochTransferDescriptor *pITd)
{
   RETAILMSG(ISPDBG, (TEXT("PHCD: paITd %08X, pITd %08X\r\n")
                TEXT("  startframe %X fastcopy %u isoch %d delayintr %d framecount %u\r\n")
                TEXT("  LastTd %01X ConditionCode %01X paBufferPage0 %X NextTd %X\r\n")
                TEXT("  BufferEnd %08X nextTd %08X bufferEnd %08X\r\n")
                TEXT("  PSW[0]: %04X, PSW[1]: %04X, PSW[2]: %04X, PSW[3]: %04X\r\n")
                TEXT("  PSW[4]: %04X, PSW[5]: %04X, PSW[6]: %04X, PSW[7]: %04X\r\n"),
                paITd, pITd,
                pITd->bfStartFrame, pITd->bfFastDataCopyRequired, pITd->bfIsIsoch,
                pITd->bfDelayInterrupt, pITd->bfFrameCount, pITd->bfLastTd,
                pITd->bfConditionCode, pITd->paBufferPage0, pITd->paNextTd,
                pITd->paBufferEnd, 
                pITd->offsetPsw[0],pITd->offsetPsw[1],pITd->offsetPsw[2],pITd->offsetPsw[3],
                pITd->offsetPsw[4],pITd->offsetPsw[5],pITd->offsetPsw[6],pITd->offsetPsw[7]));
}
EError CPhcd::DumpControlQueue(void)
{

    REGISTER    regBase = m_regBase;
    UINT port;
    ULONG   ulTemp;
    UINT    lastRootPortNum = gcFirstRootPortNum + m_numRootHubPorts;
    SEndpointDescriptor * pEd;
    ULONG paEd;
    SGeneralTransferDescriptor *pTd;
    ULONG paTd;

    RETAILMSG(ISPDBG, (TEXT("PHCD: Control Queue Dump\r\n")));

    ulTemp = READ_REGISTER_ULONG(HcControl(regBase));
    RETAILMSG(ISPDBG, (TEXT("PHCD: HcControl = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcCommandStatus(regBase));
    RETAILMSG(ISPDBG, (TEXT("PHCD: HcCommandStatus = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcControlHeadEd(regBase));
    RETAILMSG(ISPDBG, (TEXT("PHCD: HcControlHeadEd= 0x%08X\r\n"),
        ulTemp));

    paEd = ulTemp;
    while (paEd != NULL)
    {
        pEd = (SEndpointDescriptor*)m_pobMem->PaToVa(paEd);
        RETAILMSG(ISPDBG, (TEXT("\r\n")));
		DumpEd(paEd,pEd);
		RETAILMSG(ISPDBG, (TEXT("\r\n")));

        paTd = (pEd->paTdQueueHead & gcEdTdQueueHeadMask);
        while (paTd != gcStaticEdIdentifier && paTd != pEd->paTdQueueTail)
        {
            pTd = (SGeneralTransferDescriptor*)m_pobMem->PaToVa(paTd);
            RETAILMSG(ISPDBG, (TEXT("\r\n")));
			DumpTd(paTd,pTd);
			RETAILMSG(ISPDBG, (TEXT("\r\n")));
            paTd = pTd->paNextTd;
        }
        paEd = pEd->paNextEd;
    }

    ulTemp = READ_REGISTER_ULONG(HcControlCurrentEd(regBase));
    RETAILMSG(ISPDBG, (TEXT("PHCD: HcControlCurrentEd= 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcDoneHead(regBase));
    RETAILMSG(ISPDBG, (TEXT("PHCD: HcDoneHead = 0x%08X\r\n"),
        ulTemp));


    ulTemp = READ_REGISTER_ULONG(HcFmInterval(regBase));
    RETAILMSG(ISPDBG, (TEXT("PHCD: HcFmInterval = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcFmRemaining(regBase));
    RETAILMSG(ISPDBG, (TEXT("PHCD: HcFmRemaining = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcFmNumber(regBase));
    RETAILMSG(ISPDBG, (TEXT("PHCD: HcFmNumber = 0x%08X\r\n"),
        ulTemp));

    RETAILMSG(ISPDBG, (TEXT("PHCD: HccaFmNumber = 0x%04X\r\n"),
        *HccaFrameNumber(m_pHcca)));

    ulTemp = READ_REGISTER_ULONG(HcPeriodicStart(regBase));
    RETAILMSG(ISPDBG, (TEXT("PHCD: HcPeriodicStart = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcLSThreshold(regBase));
    RETAILMSG(ISPDBG, (TEXT("PHCD: HcLSThreshold = 0x%08X\r\n"),
        ulTemp));


	RETAILMSG(ISPDBG, (TEXT("PHCD: Root Hub Partition\r\n")));
    for (port = gcFirstRootPortNum; port < lastRootPortNum; port++)
    {
        ulTemp = READ_REGISTER_ULONG(HcRhPortStatus(regBase, port));
        RETAILMSG(ISPDBG, (TEXT("PHCD: HcPortStatus%d = 0x%08X\r\n"),
            port, ulTemp));

    }

    return(successful);
}

EError CPhcd::DumpIsochQueue(void)
{
    REGISTER regBase = m_regBase;
    SEndpointDescriptor * pEd;
    ULONG paEd;
    SIsochTransferDescriptor *pITd;
    ULONG paITd;

    RETAILMSG(ISPDBG, (TEXT("PHCD: Isoch Queue Dump\r\n")));

    RETAILMSG(ISPDBG,(TEXT("PHCD: LastIntrEd: 0x%X\r\n"),m_paLastIntrEd));
    paEd = m_paLastIntrEd;
    pEd  = (SEndpointDescriptor*)m_pobMem->PaToVa(m_paLastIntrEd);

    paEd = pEd->paNextEd;
    while (paEd != NULL) {
        pEd  = (SEndpointDescriptor*)m_pobMem->PaToVa(paEd);
        DumpEd(paEd,pEd);

        paITd = (pEd->paTdQueueHead & gcEdTdQueueHeadMask);
        while (paITd != gcStaticEdIdentifier && paITd != pEd->paTdQueueTail) {
            pITd = (SIsochTransferDescriptor*)m_pobMem->PaToVa(paITd);
            DumpITd(paITd,pITd);
            paITd = pITd->paNextTd;
        }

        paEd = pEd->paNextEd;
    }
    return successful;
}


static const TCHAR *aszRequestStrings[] =
{
    TEXT("GET_STATUS"),
    TEXT("CLEAR_FEATURE"),
    TEXT("RSVD (2)"),
    TEXT("SET_FEATURE"),
    TEXT("RSVD (4)"),
    TEXT("SET_ADDRESS"),