phy3250_otg_core.cpp

NXP LPC3000系列 wince BSP包

//        UP2OCR up2ocr;
//        up2ocr.ul = 0;
//        up2ocr.bit.HXS=0;
//        up2ocr.bit.SEOS= 4;
//        m_pUSBDReg->up2ocr = up2ocr.ul;
//        m_pUSBDReg->up3ocr = 0;
#endif        
#if 1
	// ISP1301 reg MODE_CONTROL_1 = 0x04
	// ISP1301 reg CTRL = 0x20
	m_pOTGRegs->otg_sts_ctrl = OTG_HOST_EN;
#endif
		ASSERT(m_pP1301Tranceiver!=NULL);
        CIST::CeSetPriority(m_iThreadPriority);
        CIST::IntializeInterrupt();
        fReturn = TRUE;
        
        // Let following run to handle the outstanding interrupt.
        m_pP1301Tranceiver->ISTThreadRun();
        ISTProcess();
        InterruptDone(GetSysIntr());

//		m_pOTGRegs->otg_int_enab = 0; //(OTG_INT_HNP_SUCC | OTG_INT_HNP_FAIL |
//			OTG_INT_REM_PLLUP);
//        DEBUGMSG(ZONE_OTG_FUNCTION, (L"CBulverdeOTG::PostInit: m_pUSBDReg->udc_otgicr = 0x%x\r\n",m_pUSBDReg->udc_otgicr));
//        m_pUSBDReg->udc_otgicr = MAXDWORD ;
    }

	m_SyncAccess.Unlock();

	return fReturn;
}

//
// device is turn off by Power Down, we need reintialize everything
BOOL PHY3250_OTG::PowerUp()
{
DEBUGMSG(1, (L"PHY3250_OTG::PowerUp\r\n"));
//    m_LPCI2C->Reinit();
    
//    UDCCR udccr;
//    udccr.ulValue = m_pUSBDReg->udc_cr;
//    udccr.bit.UDE=udccr.bit.OEN = 1;
//    m_pUSBDReg->udc_cr = udccr.ulValue ;
//    m_pUSBDReg->udc_otgicr = MAXDWORD ;
    
//    UP2OCR up2ocr;
//    up2ocr.ul = 0;
//    up2ocr.bit.HXS=0;
//    up2ocr.bit.SEOS= 4;
//    m_UsbOtgState = USBOTG_b_idle;
    
//    m_pUSBDReg->up2ocr = up2ocr.ul;
//    m_pUSBDReg->up3ocr = 0;
    
    ISTTimeout();
    return TRUE;
}
BOOL PHY3250_OTG::PowerDown()
{
DEBUGMSG(1, (L"PHY3250_OTG::PowerDown\r\n"));
    USBOTG_TRANSCEIVER_CTL usbOtgTransCtl;
    usbOtgTransCtl.ul = 0;
    usbOtgTransCtl.bit.DM_PullDown = 1;
    usbOtgTransCtl.bit.DP_PullDown =1;
    m_pP1301Tranceiver->SetTransceiver(usbOtgTransCtl);
    return TRUE;
}

BOOL PHY3250_OTG::IOControl(DWORD dwCode, PBYTE pBufIn, DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut, PDWORD pdwActualOut)
{
    BOOL bReturn = FALSE;
DEBUGMSG(1, (L"PHY3250_OTG::IOControl\r\n"));
#if 0
	switch (dwCode) {
      case IOCTL_BUS_USBOTG_BULVERDE_GET_EVENT:
        if (pBufOut && dwLenOut >= sizeof(HANDLE) ) {
            *(HANDLE *)pBufOut = m_hOTGFeatureEvent;
            bReturn = TRUE;
            if (pdwActualOut)
                *pdwActualOut = sizeof(HANDLE);
        }
        break;
      default:
        bReturn = USBOTG::IOControl(dwCode,pBufIn,dwLenIn,pBufOut,dwLenOut,pdwActualOut);
        break;
    }
    ASSERT(bReturn);
#else
    bReturn = USBOTG::IOControl(dwCode,pBufIn,dwLenIn,pBufOut,dwLenOut,pdwActualOut);
#if 0
if (pBufOut != NULL)
{
	DEBUGMSG(1, (L"PHY3250_OTG::IOControl (%d)%d 0x%x\r\n", ((dwCode - IOCTL_BUS_USBOTG_GETOTG_ENABLE_BIT) / 4), bReturn, *(PBYTE)pBufOut));
}
else
{
	DEBUGMSG(1, (L"PHY3250_OTG::IOControl (%d)%d %x\r\n", ((dwCode - IOCTL_BUS_USBOTG_GETOTG_ENABLE_BIT) / 4),
		bReturn, dwCode));
}

#endif
#endif

	return bReturn;
}

USBOTG_TRANSCEIVER_CTL PHY3250_OTG::SetupTransCtr(USBOTG_OUTPUT usbOtgOutput)
{
    USBOTG_TRANSCEIVER_CTL usbOtgTransCtl;
    usbOtgTransCtl.ul = 0;

#if 1
	usbOtgTransCtl.bit.DM_PullDown = 1;
    usbOtgTransCtl.bit.DM_PullUp= 0;
    if (usbOtgOutput.bit.loc_con) {
        usbOtgTransCtl.bit.DP_PullUp=1;
        usbOtgTransCtl.bit.DP_PullDown =0;
    }
    else {
        usbOtgTransCtl.bit.DP_PullUp=0;
        usbOtgTransCtl.bit.DP_PullDown =1;
        usbOtgTransCtl.bit.vbusDischange = 0;
    }
    usbOtgTransCtl.bit.ID_PullDown =0;
    usbOtgTransCtl.bit.vbusDrv = usbOtgOutput.bit.drv_vbus;
    usbOtgTransCtl.bit.vbusCharge = usbOtgOutput.bit.chrg_vbus ;
    //usbOtgTransCtl.bit.vbusDischange = 0;
    if (usbOtgTransCtl.bit.vbusDrv ==0 && usbOtgTransCtl.bit.vbusCharge == 0 )
        usbOtgTransCtl.bit.vbusDischange = 1;

#else
	usbOtgTransCtl.bit.DM_PullDown = 0;
    usbOtgTransCtl.bit.DM_PullUp= 0;
    if (usbOtgOutput.bit.loc_con) {
        usbOtgTransCtl.bit.DP_PullUp=0;
        usbOtgTransCtl.bit.DP_PullDown =0;
    }
    else {
        usbOtgTransCtl.bit.DP_PullUp=0;
        usbOtgTransCtl.bit.DP_PullDown =0;
        usbOtgTransCtl.bit.vbusDischange = 0;
    }
    usbOtgTransCtl.bit.ID_PullDown =0;
    usbOtgTransCtl.bit.vbusDrv = usbOtgOutput.bit.drv_vbus;
    usbOtgTransCtl.bit.vbusCharge = usbOtgOutput.bit.chrg_vbus ;
    //usbOtgTransCtl.bit.vbusDischange = 0;
    if (usbOtgTransCtl.bit.vbusDrv ==0 && usbOtgTransCtl.bit.vbusCharge == 0 )
        usbOtgTransCtl.bit.vbusDischange = 1;
#endif

DEBUGMSG(1, (L"PHY3250_OTG::SetupTransCtr 0x%x --> 0x%x\r\n", usbOtgOutput, usbOtgTransCtl));
    return usbOtgTransCtl ;
}   
    // OTG PDD Function.
BOOL PHY3250_OTG::SessionRequest(BOOL fPulseLocConn, BOOL fPulseChrgVBus)
{
DEBUGMSG(1, (L"PHY3250_OTG::SessionRequest\r\n"));
    m_SyncAccess.Lock();
    USBOTG_TRANSCEIVER_CTL usbOtgTransCtl = SetupTransCtr(m_UsbOtgOutputValues);
    Sleep(2);
    if (fPulseLocConn) {
        usbOtgTransCtl.bit.DP_PullUp=1;
        usbOtgTransCtl.bit.DP_PullDown =0;
        m_pP1301Tranceiver->SetTransceiver(usbOtgTransCtl);
        Sleep(10);        
        usbOtgTransCtl.bit.DP_PullUp=0;
        usbOtgTransCtl.bit.DP_PullDown =1;
        m_pP1301Tranceiver->SetTransceiver(usbOtgTransCtl);
        
    }
    usbOtgTransCtl = SetupTransCtr(m_UsbOtgOutputValues);
    if (fPulseChrgVBus) {
        usbOtgTransCtl.bit.vbusCharge =1;
        usbOtgTransCtl.bit.vbusDischange = 0;
        m_pP1301Tranceiver->SetTransceiver(usbOtgTransCtl);
        Sleep(80);
        usbOtgTransCtl.bit.vbusCharge =0;
        usbOtgTransCtl.bit.vbusDischange = 1;
        m_pP1301Tranceiver->SetTransceiver(usbOtgTransCtl);
    }

    m_SyncAccess.Unlock();
    return TRUE;
}
BOOL PHY3250_OTG::NewStateAction(USBOTG_STATES usbOtgState , USBOTG_OUTPUT usbOtgOutput) 
{
DEBUGMSG(1, (L"PHY3250_OTG::NewStateAction 0x%x 0x%x\r\n", usbOtgState, usbOtgOutput));
    m_SyncAccess.Lock();
    USBOTG_OUTPUT lusbOtgOutput = usbOtgOutput;

    if (lusbOtgOutput.bit.loc_sof) {// Switch to Host.
        m_pP1301Tranceiver->SetTransceiver(SetupTransCtr(lusbOtgOutput));
//        UP2OCR up2ocr;
//        up2ocr.ul = 0;
//        up2ocr.bit.SEOS = 5;
//        up2ocr.bit.DMPDE = up2ocr.bit.DPPDE = 1;
//        m_pUSBDReg->up2ocr = up2ocr.ul;
        //m_pUSBDReg->up3ocr = 0;
		UINT32 tmp = m_pCLKPWRRegs->clkpwr_usb_ctrl;
		tmp &= ~CLKPWR_USBCTRL_PD_ADD;
		tmp |= CLKPWR_USBCTRL_PD_ADD;
		m_pCLKPWRRegs->clkpwr_usb_ctrl = tmp;

		m_pOTGRegs->otg_sts_ctrl |= OTG_HOST_EN;
        SetEvent(GetOtgAConnectEvent());
        DEBUGMSG(1, (L"PHY3250_OTG::NewStateAction:USB Host m_pOTGRegs->otg_sts_ctrl =0x%x\r\n", m_pOTGRegs->otg_sts_ctrl));
        // We should reset bus if possible 
    } else {// Otherwise stay in Function.
        if (!m_UsbOtgInput.bit.b_usbfn_active && lusbOtgOutput.bit.loc_con) // Device Have not ready yet. 
            lusbOtgOutput.bit.loc_con = 0 ;
        m_pP1301Tranceiver->SetTransceiver(SetupTransCtr(lusbOtgOutput));
//        UP2OCR up2ocr;
//        up2ocr.ul = 0;
//        up2ocr.bit.HXS=0;
//        up2ocr.bit.SEOS = 4;
//        m_pUSBDReg->up2ocr = up2ocr.ul;
//        m_pUSBDReg->up3ocr = 0;
		UINT32 tmp = m_pCLKPWRRegs->clkpwr_usb_ctrl;
		tmp &= ~CLKPWR_USBCTRL_PD_ADD;
		tmp |= CLKPWR_USBCTRL_PD_ADD;
		m_pCLKPWRRegs->clkpwr_usb_ctrl = tmp;

		m_pOTGRegs->otg_sts_ctrl &= ~OTG_HOST_EN;
        DEBUGMSG(1, (L"PHY3250_OTG::NewStateAction:USB Function m_pOTGRegs->otg_sts_ctrl =0x%x\r\n",m_pOTGRegs->otg_sts_ctrl));
    }

    if (lusbOtgOutput.bit.loc_sof || lusbOtgOutput.bit.loc_con) 
        m_pP1301Tranceiver->EnableDataLineInterrupt(FALSE);
    else
        m_pP1301Tranceiver->EnableDataLineInterrupt(TRUE);

#if 0
		{
		int idx;
		UNS_8 data;
		UNS_8 regs [] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
			0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x12, 0x13, 0x14, 0x15,
			0xFF};

		idx = 0;
		while (regs[idx] != 0xFF)
		{
			if (ReadXCVR(regs[idx], &data) == FALSE)
			{
				DEBUGMSG(1, (L"PHY3250_OTG::REG 0x%x read error\r\n", regs[idx]));
			}
			else
			{
				DEBUGMSG(1, (L"PHY3250_OTG::REG 0x%x = 0x%x\r\n", regs[idx], data));
			}

			idx++;
		}

	}
#endif
		m_SyncAccess.Unlock();

	return TRUE;
}
BOOL PHY3250_OTG::IsSE0()
{
    USBOTG_TRANSCEIVER_STATUS usbTransceiverStatus;
DEBUGMSG(1, (L"PHY3250_OTG::IsSE0\r\n"));
    if (m_pP1301Tranceiver && m_pP1301Tranceiver->GetTransceiver(&usbTransceiverStatus)) {
        return ((usbTransceiverStatus.bit.DP_HI==0 && usbTransceiverStatus.bit.DM_HI==0)?TRUE:FALSE);
    }
    else
        return FALSE;
}
BOOL PHY3250_OTG::UpdateInput() 
{
    USBOTG_TRANSCEIVER_STATUS usbTransceiverStatus;
DEBUGMSG(1, (L"PHY3250_OTG::UpdateInput\r\n"));
    if (m_pP1301Tranceiver && m_pP1301Tranceiver->GetTransceiver(&usbTransceiverStatus)) {
DEBUGMSG(1, (L"PHY3250_OTG::UpdateInput usbTransceiverStatus = 0x%x 0x%x\r\n", usbTransceiverStatus, m_UsbOtgOutputValues));
        if (m_UsbOtgOutputValues.bit.loc_con || m_UsbOtgOutputValues.bit.loc_sof)
            m_UsbOtgInput.bit.a_conn = m_UsbOtgInput.bit.b_conn =  1;
        else
            m_UsbOtgInput.bit.a_conn = m_UsbOtgInput.bit.b_conn = 
                ((usbTransceiverStatus.bit.DP_HI==0 && usbTransceiverStatus.bit.DM_HI==0)?0:1) ;
        m_UsbOtgInput.bit.a_sess_vld = usbTransceiverStatus.bit.aSessValid;
        
        if (m_UsbOtgOutputValues.bit.drv_vbus)
            //we can't set this because it make hw and sw un-sync
            m_UsbOtgInput.bit.a_vbus_vld = 1;
        else
            m_UsbOtgInput.bit.a_vbus_vld = usbTransceiverStatus.bit.aBusValid; 
        //
        m_UsbOtgInput.bit.b_sess_end = usbTransceiverStatus.bit.bSessEnd ;
        m_UsbOtgInput.bit.b_sess_vld = usbTransceiverStatus.bit.bSessValid;
        m_UsbOtgInput.bit.id = (usbTransceiverStatus.bit.ID!=0?1:0);
        m_UsbOtgInput.bit.a_srp_det = m_UsbOtgInput.bit.a_sess_vld ;
        DEBUGMSG(1, (L"PHY3250_OTG::UpdateInput:m_UsbOtgInput.ul=%x\r\n",m_UsbOtgInput.ul));
        // Update Output if there is any.
/*
        USBOTG_OUTPUT usbOtgOutput = m_UsbOtgOutputValues;
        if (!m_UsbOtgInput.bit.b_usbfn_active && usbOtgOutput.bit.loc_con) // Device Have not ready yet. 
            usbOtgOutput.bit.loc_con = 0 ;
        m_pP1301Tranceiver->SetTransceiver(SetupTransCtr(usbOtgOutput));
*/
    }
    DEBUGMSG(ZONE_OTG_FUNCTION, (L"-CBulverdeOTG::UpdateInput:\r\n"));
    return TRUE;
}
BOOL PHY3250_OTG::StateChangeNotification (USBOTG_TRANSCEIVER_STATUS_CHANGE usbStatusChange, USBOTG_TRANSCEIVER_STATUS usbTransceiverStatus)
{
DEBUGMSG(1, (L"PHY3250_OTG::StateChangeNotification\r\n"));
    m_SyncAccess.Lock();
    UpdateInput();
    m_SyncAccess.Unlock();
    EventNotification();
    return TRUE;
}

BOOL PHY3250_OTG::ISTProcess()
{
//	UINT32 otgisr;

	DEBUGMSG(1, (L"PHY3250_OTG::ISTProcess\r\n"));

//	PREFAST_ASSERT(m_pUSBDReg != NULL);
    m_SyncAccess.Lock();

#if 0
	UDCOTG udcOtgIsr;
    udcOtgIsr.ul = m_pUSBDReg->udc_otgisr; // 
    DEBUGMSG(1, (L"CBulverdeOTG::ISTProcess() udcOtgIsr=0x%x\r\n",udcOtgIsr.ul));
    if (udcOtgIsr.bit.XR || udcOtgIsr.bit.XF)
	{
        m_pP1301Tranceiver->ISTThreadRun();
    }
    if (udcOtgIsr.bit.SF)
	{
        SetEvent(m_hOTGFeatureEvent);
    }

#else
//	otgisr = m_pOTGRegs->otg_int_sts;
//    DEBUGMSG(1, (L"PHY3250_OTG::ISTProcess() otgisr=0x%x\r\n", otgisr));
//    if (otgisr & (OTG_INT_HNP_SUCC | OTG_INT_HNP_FAIL))
//	{
        m_pP1301Tranceiver->ISTThreadRun();
//		m_pOTGRegs->otg_int_clr = (OTG_INT_HNP_SUCC | OTG_INT_HNP_FAIL);
//    }
//    if (otgisr & OTG_INT_REM_PLLUP)
//	{
//        SetEvent(m_hOTGFeatureEvent); // TBD
//		m_pOTGRegs->otg_int_clr = OTG_INT_REM_PLLUP;
//    }

#endif
//    m_pUSBDReg->udc_otgisr = udcOtgIsr.ul; // Clear the bit.
//	m_pOTGRegs->otg_int_clr = (OTG_INT_HNP_SUCC | OTG_INT_HNP_FAIL |
//		OTG_INT_REM_PLLUP);

	m_SyncAccess.Unlock();

	return TRUE;
    
}

BOOL PHY3250_OTG::ISTTimeout()
{
    USBOTG_TRANSCEIVER_STATUS usbOtgTransStatus;
    USBOTG_TRANSCEIVER_STATUS_CHANGE usbOtgStatusChange;

	DEBUGMSG(1, (L"PHY3250_OTG::ISTTimeout\r\n"));

	usbOtgStatusChange.ul = usbOtgTransStatus.ul = 0;
    m_pP1301Tranceiver->GetISP1301Change(&usbOtgStatusChange);    
    m_pP1301Tranceiver->GetTransceiver(&usbOtgTransStatus);
    
//    DEBUGMSG(ZONE_OTG_THREAD, (L"CBulverdeOTG::ISTTimeout() udcOtgIsr=0x%x,udcOtgicr=0x%x,m_pUSBDReg+0x1c = 0x%x\r\n",
//        m_pUSBDReg->udc_otgisr,m_pUSBDReg->udc_otgicr, *(PDWORD)((PBYTE)m_pUSBDReg+0x1c)));
    DEBUGMSG(1, (L"PHY3250_OTG::ISTTimeout() usbOtgStatusChange =0x%x, usbOtgTransStatus= 0x%x\r\n",
        usbOtgStatusChange.ul, usbOtgTransStatus.ul));
    return TRUE;
}

// Class Factory.
USBOTG *CreateUSBOTGObject(LPTSTR lpActivePath)
{
DEBUGMSG(1, (L"CreateUSBOTGObject\r\n"));
    return new PHY3250_OTG(lpActivePath);
}
void DeleteUSBOTGObject(USBOTG *pUsbOtg)
{
DEBUGMSG(1, (L"DeleteUSBOTGObject\r\n"));
    if (pUsbOtg)
	{
        delete pUsbOtg;
	}
}