pdd.c

i.mx27 soc for wince 6.0

        BOOL bBusSucceed = SetDevicePowerState(pPdd->hParentBus, cpsNew, NULL);
        if (bBusSucceed && 
            (pPdd->m_CurActualPowerState==D3 || pPdd->m_CurActualPowerState==D4))
        {            
            UfnPdd_PowerUp((PVOID)pPdd);
        }
    }

    if ( (cpsNew > pPdd->m_CurActualPowerState ) && pPdd->hParentBus  )
    {
        BOOL bBusSucceed = SetDevicePowerState(pPdd->hParentBus, cpsNew, NULL);
        if (bBusSucceed && (cpsNew == D4 ||cpsNew == D3 ))
        {
            RETAILMSG(1, (TEXT("UpdateDevicePower to powerdown\r\n")));
            UfnPdd_PowerDown((PVOID)pPdd);
        }
    }
    pPdd->m_CurActualPowerState = cpsNew ;
    return (cpsNew) ;
}


//------------------------------------------------------------------------------
//
//  Function:  SetupInterrupt
//
//  This function handles setup packet interrupts.
//
//  Parameter : 
//      pPdd - Pointer to USBFN_PDD
//
//  Return:
//      NULL
//
//--------------------------------------------------------------------------------
static VOID SetupEvent(USBFN_PDD *pPdd)
{
    CSP_USB_REGS*pUSBDRegs = pPdd->pUSBDRegs;
    DWORD data[2];
    USB_DEVICE_REQUEST *pSetup = (USB_DEVICE_REQUEST*)data;

    LOCK();
    if (pPdd->devState==0) // Why no bit set in PORTSC???
    {
        // Let MDD process change
        USB_PORTSC_T state;
        DWORD * t1;
        int i;

        DEBUGMSG(ZONE_PDD, (L"Device Attach\r\n"));

        //
        // Get device state & change
        t1=(DWORD *)&state; 
        *t1 = INREG32(&pUSBDRegs->OTG.PORTSC[USBD_PORT_NUM]);

        pPdd->devState=1;

        UNLOCK();               
        pPdd->pfnNotify(pPdd->pMddContext, UFN_MSG_BUS_EVENTS, UFN_ATTACH);
        LOCK();

        if (state.PSPD==0x2) 
        {
            UNLOCK();
            pPdd->pfnNotify(pPdd->pMddContext, UFN_MSG_BUS_SPEED, BS_HIGH_SPEED);
			DEBUGMSG(1,(_T(" BS_HIGH_SPEED   %x\r\n"),BS_HIGH_SPEED) );

            LOCK();
        }
        else
        {
            UNLOCK();
            pPdd->pfnNotify(pPdd->pMddContext, UFN_MSG_BUS_SPEED, BS_FULL_SPEED);
			DEBUGMSG(1,(_T(" BS_FULL_SPEED   %x\r\n"),BS_FULL_SPEED) );
            LOCK();
        }

        UNLOCK();               
        pPdd->pfnNotify(pPdd->pMddContext, UFN_MSG_BUS_EVENTS, UFN_RESET);
        LOCK();
        
		DEBUGMSG(1,(_T(" state.PSPD %x\r\n"),state.PSPD) );

        if (state.PSPD==2)
        {
            pPdd->highspeed=1;
            for (i=0;i<USBD_EP_COUNT;i++)
                pPdd->ep[i]=&pPdd->eph[i];
        }
        else
        {
            pPdd->highspeed=0;    
            for (i=0;i<USBD_EP_COUNT;i++)
                pPdd->ep[i]=&pPdd->epf[i];
        }
    }

    GetSetupPacket(pPdd, data);
    // DEBUGMSG(ZONE_PDD,(_T("Setup: %x %x\r\n"),data[0],data[1]) );
	DEBUGMSG(1,(_T("Setup: %x %x\r\n"),data[0],data[1]) );
 
    UNLOCK();

    pPdd->pfnNotify(pPdd->pMddContext, UFN_MSG_SETUP_PACKET, (DWORD)data);
}

//----------------------------------------------------------------
// 
//  Function:  DumpDeviceState
//
//  Dump the connection status based on the PORTSC register
//
//  Parameter:
//     state - Pointer to PORTSC register
//
//  Return
//     NULL
//
//----------------------------------------------------------------
void DumpDeviceState( USB_PORTSC_T * state)    
{
    if (state->CCS)
        RETAILMSG(1, (L"\t\tCurrent Connect Status: Attached\r\n"));
    if (state->CSC)
        RETAILMSG(1, (L"\t\tConnect Status Change: Changed\r\n"));
    if (state->PE)
        RETAILMSG(1, (L"\t\tPort Enabled\r\n"));
    if (state->PEC)
        RETAILMSG(1, (L"\t\tPort Enable/Disable Change\r\n"));
    if (state->OCA)
        RETAILMSG(1, (L"\t\tOver-current Active\r\n"));
    if (state->OCC)
        RETAILMSG(1, (L"\t\tOver-current Change\r\n"));
    if (state->FPR)
        RETAILMSG(1, (L"\t\tForce Port Resume\r\n"));
    if (state->SUSP)
        RETAILMSG(1, (L"\t\tSuspend\r\n"));
    if (state->PR)
        RETAILMSG(1, (L"\t\tPort Reset\r\n"));
    if (state->HSP)
        RETAILMSG(1, (L"\t\tHigh-Speed Port \r\n"));

    RETAILMSG(1, (L"\t\tLine Status: %x", state->LS));
    switch (state->LS)
    {
    case 0:
        RETAILMSG(1, (L"\t\t\tSE0\r\n"));
        break;

    case 1:
        RETAILMSG(1, (L"\t\t\tJ-state\r\n"));
        break;

    case 2:
        RETAILMSG(1, (L"\t\t\tK-state\r\n"));
        break;

    case 3:   
    default:
        RETAILMSG(1, (L"\t\t\tUndefined\r\n"));
        break;    
    }

    if (state->PP)
        RETAILMSG(1, (L"\t\t??? Should be 0 for device\r\n"));

    if (state->PO)
        RETAILMSG(1, (L"\t\tPort Owner\r\n"));

    if (state->PIC)
    {
        RETAILMSG(1, (L"\t\tPort Indicator Control"));
        switch (state->PIC)
        {
        case 1:
            RETAILMSG(1, (L"\t\t\tAmber\r\n"));
            break;

        case 2:
            RETAILMSG(1, (L"\t\t\tGreen\r\n"));
            break;

        case 3:
        default:
            RETAILMSG(1, (L"\t\t\tUndefined\r\n"));
            break;
        }
    }    
    if (state->PTC) 
        RETAILMSG(1, (L"\t\tPort Test Control: %x\r\n", state->PTC));

    if (state->WKCN) 
        RETAILMSG(1, (L"\t\tWake on Connect Enable (WKCNNT_E)\r\n"));

    if (state->WKDC) 
        RETAILMSG(1, (L"\t\tWake on Disconnect Enable (WKDSCNNT_E) \r\n"));

    if (state->WKOC) 
        RETAILMSG(1, (L"\t\tWake on Over-current Enable (WKOC_E) \r\n"));

    if (state->PHCD) 
        RETAILMSG(1, (L"\t\tPHY Low Power Suspend - Clock Disable (PLPSCD) \r\n"));

    if (state->PFSC) 
        RETAILMSG(1, (L"\t\tPort Force Full Speed Connect \r\n"));

    RETAILMSG(1, (L"\t\tPort Speed: %x->", state->PSPD));
    switch (state->PSPD)
    {
    case 0:
        RETAILMSG(1, (L"\t\t\tFull Speed\r\n"));
        break;

    case 1:
        RETAILMSG(1, (L"\t\t\tLow Speed\r\n"));
        break;

    case 2:
        RETAILMSG(1, (L"\t\t\tHigh Speed\r\n"));
        break;

    case 3:
    default:
        RETAILMSG(1, (L"\t\t\tUndefined\r\n"));
        break;
    }
    RETAILMSG(1, (L"\t\tParallel Transceiver Width:%x->", state->PTW));
    if (state->PTW) 
        RETAILMSG(1, (L"\t\t\t16 bits\r\n"));
    else
        RETAILMSG(1, (L"\t\t\t8 bits\r\n"));

    if (state->STS) 
        RETAILMSG(1, (L"\t\tSerial Transceiver Select \r\n"));

    RETAILMSG(1, (L"\t\tParallel Transceiver Select:%x->", state->PTS));
    switch (state->PTS)
    {
    case 0:
        RETAILMSG(1, (L"\t\t\tUTMI/UTMI+\r\n"));
        break;

    case 1:
        RETAILMSG(1, (L"\t\t\tPhilips Classic\r\n"));
        break;

    case 2:
        RETAILMSG(1, (L"\t\t\tULPI\r\n"));
        break;

    case 3:
        RETAILMSG(1, (L"\t\t\tSerial/1.1 PHY (FS Only)\r\n"));
        break;
    default:
        RETAILMSG(1, (L"\t\t\tUndefined\r\n"));
        break;

    }                    
}

//------------------------------------------------------------------------------
//
//  Function:  DevStatEvent
//
//  This function handles device state change interrupts.
//
//  Called with context LOCKed
//  
//  Parameters:
//
//      pPdd - Pointer to USBFN_PDD structure
//
//  Return:
//      
//      NULL
//
//-------------------------------------------------------------------------------
static VOID DevStatEvent (USBFN_PDD *pPdd)
{
    CSP_USB_REGS *pUSBDRegs = pPdd->pUSBDRegs;
    DWORD *t1;
    USB_PORTSC_T state;

    // Get device state & change
    t1=(DWORD *)&state; 
    *t1 = INREG32(&pUSBDRegs->OTG.PORTSC[USBD_PORT_NUM]);

    //DumpDeviceState( & state);    
    //Reset

    //Deattach
    if (pPdd->devState&&state.SUSP)
    {
        // TODO: Call bus driver (OTG?) to move HW to deep sleep
        // Let MDD process change        
        DEBUGMSG(ZONE_PDD, (_T("Device Detach\r\n")));

        // Don't process other changes (we are disconnected)
        pPdd->devState=0;

        UNLOCK();
        pPdd->pfnNotify(pPdd->pMddContext, UFN_MSG_BUS_EVENTS, UFN_DETACH);        
        LOCK();

        // SetSelfPowerState to D4
        pPdd->m_CurSelfPowerState = D4; // Do we need set to D3 as wake up source?
        UpdateDevicePower(pPdd);     

        OUTREG32(&pPdd->pUSBDRegs->OTG.T_154H.USBADR, 0);    
    }    
    
}

//------------------------------------------------------------------------------
//
//  Function:  DumpInterruptSource
//
//  This function dump the value on the interrupt register USBSTS
//
//  
//  Parameters:
//
//      source - pointer to USBSTS
//
//  Return:
//      
//      NULL
//
//-------------------------------------------------------------------------------
void DumpInterruptSource(USB_USBSTS_T * source)
{
    if (source->UI)
        RETAILMSG(1, (L"\tUSB Interrupt (USBINT)\r\n"));
    if (source->UEI)
        RETAILMSG(1, (L"\tUSB Error Interrupt (USBERRINT)\r\n"));
    if (source->PCI)
        RETAILMSG(1, (L"\tPort Change Detect\r\n"));
    if (source->FRI)
        RETAILMSG(1, (L"\tFrame List Rollover\r\n"));
    if (source->SEI)
        RETAILMSG(1, (L"\tSystem Error\r\n"));
    if (source->AAI)
        RETAILMSG(1, (L"\tInterrupt on Async Advance\r\n"));
    if (source->URI)
        RETAILMSG(1, (L"\tUSB Reset Received \r\n"));
    if (source->SRI)
        RETAILMSG(1, (L"\tSOF Received \r\n"));
    if (source->SLI)
        RETAILMSG(1, (L"\tDCSuspend \r\n"));
    if (source->ULPII)
        RETAILMSG(1, (L"\tULPI Interrupt\r\n"));
    if (source->HCH)
        RETAILMSG(1, (L"\tHCHaIted \r\n"));
    if (source->RCL)
        RETAILMSG(1, (L"\tReclamation,Only used by the host controller. \r\n"));
    if (source->PS)
        RETAILMSG(1, (L"\tPeriodic Schedule Status. \r\n"));
    if (source->AS)
        RETAILMSG(1, (L"\tAsynchronous Schedule Status. \r\n"));
}

//------------------------------------------------------------------------------
//
//  Function:  CheckEndpoint
//
//  This function handles the interrupt due to  endpoint complete 
//
//  
//  Parameters:
//
//      pPdd - Pointer to USBFN_PDD structure
//
//      i - endpoint to be examined
//
//  Return:
//      
//      NULL
//
//-------------------------------------------------------------------------------
static void CheckEndpoint(USBFN_PDD *pPdd, int i )
{
    CSP_USB_REGS* pUSBDRegs = pPdd->pUSBDRegs;
    STransfer * pTransfer;
    USB_ENDPTCOMPLETE_T edptcomp;
    DWORD *pEpc;

    pEpc = (DWORD*)&edptcomp;
    
    LOCK();
    // OUT endpoint
    *pEpc = INREG32(&pUSBDRegs->OTG.ENDPTCOMPLETE);

    if (edptcomp.ERCE&(1<<i))
    {