ohcd.cpp

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

        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("OHCD: 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("OHCD: Error on CreateThread\r\n")));
//        return(STATUS_UNSUCCESSFUL);
        return FALSE;
    }
#endif

    DEBUGMSG(ZONE_FUNCTION,(TEXT("-OHCD::Initialize\r\n")));

    return TRUE;
//    return(STATUS_SUCCESS);
}

#ifdef DEBUG
EError COhcd::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;
}
#endif

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

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

    ulTemp = READ_REGISTER_ULONG(HcControl(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcControl = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcCommandStatus(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcCommandStatus = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcInterruptStatus(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcInterruptStatus = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcInterruptEnable(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcInterruptEnable = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcInterruptDisable(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcInterruptDisable = 0x%08X\r\n"),
        ulTemp));

    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: Memory Pointer Partition\r\n")));
    ulTemp = READ_REGISTER_ULONG(HcHCCA(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcHCCA = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcPeriodCurrentEd(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: Hc = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcControlHeadEd(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcControlHeadEd= 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcControlCurrentEd(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcControlCurrentEd= 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcBulkHeadEd(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcBulkHeadEd = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcBulkCurrentEd(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcBulkCurrentEd = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcDoneHead(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcDoneHead = 0x%08X\r\n"),
        ulTemp));

    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: Frame Counter Partition\r\n")));
    ulTemp = READ_REGISTER_ULONG(HcFmInterval(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcFmInterval = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcFmRemaining(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcFmRemaining = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcFmNumber(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcFmNumber = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcPeriodicStart(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcPeriodicStart = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcLSThreshold(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcLSThreshold = 0x%08X\r\n"),
        ulTemp));

    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: Root Hub Partition\r\n")));

    ulTemp = READ_REGISTER_ULONG(HcRhDescriptorA(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcRhDescriptorA = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcRhDescriptorB(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcRhDescriptorB = 0x%08X\r\n"),
        ulTemp));

    ulTemp = READ_REGISTER_ULONG(HcRhStatus(regBase));
    DEBUGMSG(ZONE_INIT, (TEXT("OHCD: HcRhStatus = 0x%08X\r\n"),
        ulTemp));

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

    }

    return(successful);
}
#endif

#ifdef DEBUG
static void DumpEd(ULONG paEd, SEndpointDescriptor * pEd)
{
    DEBUGMSG(1, (TEXT("OHCD: 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)
{
    DEBUGMSG(1, (TEXT("OHCD: 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)
{
   DEBUGMSG(1, (TEXT("OHCD: 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 COhcd::DumpControlQueue(void)
{

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

    DEBUGMSG(1, (TEXT("OHCD: Control Queue Dump\r\n")));

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

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

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

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

        paTd = (pEd->paTdQueueHead & gcEdTdQueueHeadMask);
        while (paTd != gcStaticEdIdentifier && paTd != pEd->paTdQueueTail)
        {
            pTd = (SGeneralTransferDescriptor*)m_pobMem->PaToVa(paTd);
            DumpTd(paTd,pTd);
            paTd = pTd->paNextTd;
        }
        paEd = pEd->paNextEd;
    }

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

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

    ulTemp = READ_REGISTER_ULONG(HcFmInterval(regBase));
    DEBUGMSG(1, (TEXT("OHCD: HcFmInterval = 0x%08X\r\n"),
        ulTemp));

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

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

    DEBUGMSG(1, (TEXT("OHCD: HccaFmNumber = 0x%04X\r\n"),
        *HccaFrameNumber(m_pHcca)));

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

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

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

    }

    return(successful);
}

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

    DEBUGMSG(1, (TEXT("OHCD: Isoch Queue Dump\r\n")));

    DEBUGMSG(1,(TEXT("OHCD: 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"),
    TEXT("GET_DESCRIPTOR"),
    TEXT("SET_DESCRIPTOR"),
    TEXT("GET_CONFIGURATION"),
    TEXT("SET_CONFIGURATION"),
    TEXT("GET_INTERFACE"),
    TEXT("SET_INTERFACE"),
    TEXT("SYNC_FRAME")
};

static const TCHAR *aszPortFeatureStrings[] =
{
    TEXT("PORT_CONNECTION"),
    TEXT("PORT_ENABLE"),
    TEXT("PORT_SUSPEND"),
    TEXT("PORT_OVER_CURRENT"),
    TEXT("PORT_RESET"),
    TEXT("RSVD (5)"),
    TEXT("RSVD (6)"),
    TEXT("RSVD (7)"),
    TEXT("PORT_POWER"),
    TEXT("PORT_LOW_SPEED"),
    TEXT("RSVD (10)"),
    TEXT("RSVD (11)"),
    TEXT("RSVD (12)"),
    TEXT("RSVD (13)"),
    TEXT("RSVD (14)"),
    TEXT("RSVD (15)"),
    TEXT("C_PORT_CONNECTION"),
    TEXT("C_PORT_ENABLE"),
    TEXT("C_PORT_SUSPEND"),
    TEXT("C_PORT_OVER_CURRENT"),
    TEXT("C_PORT_RESET"),
};

static const TCHAR *aszHubFeatureStrings[] =
{
    TEXT("LOCAL_POWER"),
    TEXT("OVER_CURRENT")
};

inline const TCHAR *DecodeRequestString(UCHAR bRequest)
{
    return ((bRequest < NUM_ELEMENTS(aszRequestStrings)) ?