hwinit.c

LP1071 无线局域网卡WinCE驱动程序

     *temp = INREG32(&pRegs->USB_CTRL);
     Ctrl.OWIE = OWIE_INT_ENABLE;
     OUTREG32(&pRegs->USB_CTRL, *temp);

    // usb_otg_power_mask_enable
    temp = (DWORD *)&Ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    Ctrl.OPM = OPM_NO_USBPWR;
    OUTREG32(&pRegs->USB_CTRL, *temp);

    // usb_bypass_inactive
    temp = (DWORD *)&Ctrl;  
    *temp=0;
    Ctrl.BPE = BPE_BYPASS_INACTIVE;     //  Bypass Enable bit, clear it
    CLRREG32(&pRegs->USB_CTRL, *temp);

    // otg_setmode
	Reset(pRegs);
	SetMode(pRegs,CM_HOST_CONTROLLER);

    // otg_power_on_port1
    if (INREG32(&pRegs->OTG.HCSPARAMS) &(0x1 << PPC_LSH))
    {
        DWORD Mask = (0x1<<1) + (0x1<<3)+(0x1<<5);
        CLRREG32(&pRegs->OTG.PORTSC, Mask);
        temp = (DWORD *)&Portsc;
        *temp = INREG32(&pRegs->OTG.PORTSC);
        Portsc.PP = PP_READ_WRITE;      
        OUTREG32(&pRegs->OTG.PORTSC, *temp);
    }
    else
        RETAILMSG(1, (TEXT("Host does not control power\r\n")));

    //otg_controller_reset
	Reset(pRegs);
	SetMode(pRegs,CM_HOST_CONTROLLER);    
}

//-----------------------------------------------------------------------------
//
//  Function: ConfigOTGClient
//
//  This function is to configure client functionality on the USB OTG Core.
//
//  Parameters:
//     pRegs - Pointer to 3 USB Core Registers
//     
//  Returns:
//     NULL
//
//-----------------------------------------------------------------------------

static void ConfigOTGClient(CSP_USB_REGS *pRegs)
{
    USB_PORTSC_T Port;
    USB_USBCMD_T Cmd;
    USB_HCSPARAMS_T Hcs;
    DWORD *temp;

    DEBUGMSG(1, (TEXT("ConfigOTGClient: Stop controller\r\n")));
    // Stop the controller first
	Stop(pRegs);

    DEBUGMSG(1, (TEXT("ConfigOTGClient: Reset\r\n")));
    // Do a reset first no matter what
	Reset(pRegs);

    // Enable power for OTG on port 1
    temp=(DWORD *)&Hcs;
    *temp=INREG32(&pRegs->OTG.HCSPARAMS);
    if (Hcs.PPC) {
        WORD USB_OTG_PORTSC1_Write_MASK = (0x1<<1)+(0x1<<3)+(0x1<<5);   
        *temp=INREG32(&pRegs->OTG.PORTSC[0]);
        *temp&=~USB_OTG_PORTSC1_Write_MASK;
        *temp|=1<<12;
        SETREG32(&pRegs->OTG.PORTSC[0], *temp);
    }
        
    // reset the usb otg
	Reset(pRegs);
        
    // Set USB Mode 
	SetMode(pRegs,CM_DEVICE_CONTROLLER);

    // otg_itc_setup(0);
    temp=(DWORD *)&Cmd;
    *temp=INREG32(&pRegs->OTG.USBCMD);
    Cmd.ITC=0;
    OUTREG32(&pRegs->OTG.USBCMD, *temp);

    // otg_frindex_setup(1);
    OUTREG32(&pRegs->OTG.FRINDEX, 1);

    // otg_set_configflag_on();
    OUTREG32(&pRegs->OTG.CONFIGFLAG, 1);

    // for debug, just check the Port Reset bit
    temp=(DWORD *)&Port;
    *temp=INREG32(&pRegs->OTG.PORTSC[0]);
    DEBUGMSG(1,(TEXT("ConfigOTGClient: PORTSC 0x%x PR=%d\r\n"), *temp, Port.PR));

    //RETAILMSG(1, (TEXT("Initialize1504 OTG HighSpeed Client\r\n")));
     #if (USB_HOST_MODE ==1)	
        Initialize1504Client(pRegs); 
    #endif

}

//-----------------------------------------------------------------------------
//
//  Function: InitializeOTGTransceiver
//
//  This function is to configure the OTG USB Core.
//
//  Parameters:
//     pRegs - Pointer to 3 USB Core Registers
//     IsHost - TRUE: it is configured as host
//              FALSE: it is configured as client
//     
//  Returns:
//     TRUE: Success
//     FALSE: Failure
//
//-----------------------------------------------------------------------------
BOOL InitializeOTGTransceiver(PCSP_USB_REGS* pRegs, BOOL IsHost)
{
        // Clear USB Interrupt enable registers
    OUTREG32(&(*pRegs)->OTG.USBINTR, 0);

    InitializeCPLD(IsHost);
    
    InitializeMux();  
    USBClockInit();
    
    if (IsHost) 
    {
        // Stop the controller first
        {
            USB_USBCMD_T Cmd;           
            USB_USBSTS_T Sts;
            USB_USBMODE_T Mode;
            DWORD * temp = (DWORD *)&Cmd;
            DWORD * temp2 = (DWORD*)&Sts;
            DWORD *pTmpMode = (DWORD*)&Mode;
            int nAttempts = 0;

            *temp = INREG32(&(*pRegs)->OTG.USBCMD);
            Cmd.RS = 0;
            OUTREG32(&(*pRegs)->OTG.USBCMD, *temp);

            *pTmpMode = INREG32(&(*pRegs)->OTG.USBMODE);
            if ( Mode.CM == 0x3 )
            {
                *temp2 = INREG32(&(*pRegs)->OTG.USBSTS);
                while ( (Sts.HCH == 0) && (nAttempts++ < 50) )
                {
                    Sleep(10);
                    *temp2 = INREG32(&(*pRegs)->OTG.USBSTS);
                }
            }
        }

        // Do a reset first no matter what
		Reset(*pRegs);
        // actually set the mode to HOST now
		SetMode(*pRegs,CM_HOST_CONTROLLER);

        ConfigOTGHost(*pRegs);
        {   //usb_bypass_inactive()
            USB_CTRL_T Ctrl;
            DWORD * temp=(DWORD *)&Ctrl;
        
            *temp=0;
            Ctrl.BPE = BPE_BYPASS_ACTIVE;     //  Bypass Enable bit, clear it
            CLRREG32(&(*pRegs)->USB_CTRL, *temp);
        }


		SetMode(*pRegs,CM_HOST_CONTROLLER);
		
		//RETAILMSG(1, (TEXT("PowerOnPort\r\n")));
        // power on port
        {
            DWORD *temp;
            USB_HCSPARAMS_T Hcs;
            temp=(DWORD *)&Hcs;
            *temp=INREG32(&(*pRegs)->OTG.HCSPARAMS);

            if (Hcs.PPC) 
            {
                USB_PORTSC_T Portsc;
                DWORD * temp2= (DWORD *)&Portsc;

                *temp2 = INREG32(&(*pRegs)->OTG.PORTSC);
                Portsc.PP = PP_READ_WRITE;
                SETREG32(&(*pRegs)->OTG.PORTSC, *temp2);
            }   
        }

        //RETAILMSG(1, (TEXT("Initialize1504 Host\r\n")));
    #if (USB_HOST_MODE == 1)	
        Initialize1504Host(*pRegs);
   #endif
        
    }
    else
    {
        ConfigOTGClient(*pRegs);

        // Reset all interrupts
        {
            USB_USBSTS_T temp;
            DWORD       *t=(DWORD*)&temp;
            *t=0;
            temp.UI=1;   temp.UEI=1; temp.PCI=1; temp.FRI=1; 
            temp.SEI=1; temp.AAI=1; temp.URI=1; temp.SRI=1;
            temp.SLI=1; temp.ULPII=1;
            OUTREG32(&(*pRegs)->OTG.USBSTS, *t);
        }
    }

    // Last to do: Enable the ID Pin Interrupt in OTGSC
    {
        USB_OTGSC_T temp;
        DWORD       *t = (DWORD *)&temp;

        *t = INREG32(&(*pRegs)->OTG.OTGSC);
        temp.IDIE = 1;
        OUTREG32(&(*pRegs)->OTG.OTGSC, *t);
    }

    return TRUE;
}

//-----------------------------------------------------------------------------
//
//  Function: GetSysIntr
//
//  This function is to return the SYSINTR value of the USB OTG Core.
//
//  Parameters:
//     NULL
//     
//  Returns:
//     SYSINTR_USBOTG
//
//-----------------------------------------------------------------------------
DWORD GetSysIntr(void)
{
    return SYSINTR_USBOTG;
}

//-------------------------------------------------------------------------------------------------------
// Function: BSPUsbXvrSetPhyPowerMode 
//     function for platform to call when they want to suspend/resume the PHY
//
// Parameters: 
//      1) pUSBRegs - USB registers
//      2) bResume - TRUE - request to resume, FALSE - request suspend
//
// Return: 
//      NULL
//-----------------------------------------------------------------------------------------------------------
static void BSPUsbXvrSetPhyPowerMode(CSP_USB_REGS *pUSBRegs, BOOL bResume)
{
    // For Toshiba: Please move their xvc_SetPhyPowerMode to here
    DEBUGMSG(1, (TEXT("BSPUsbXvrSetPhyPowerMode bResume = %d\r\n"),bResume));
    if (bResume)
    {
        if (INREG32(&pUSBRegs->OTG.PORTSC[0]) & 0x800000)
        {
            // Clear the PHCD
            CLRREG32(&pUSBRegs->OTG.PORTSC[0], INREG32(&pUSBRegs->OTG.PORTSC[0]) & 0x800000);
            // Force Resume bit
            OUTREG32(&pUSBRegs->OTG.PORTSC[0], INREG32(&pUSBRegs->OTG.PORTSC[0])|0x40); 
            //RETAILMSG(1, (TEXT("Force resume\r\n")));
        }
    }
    else
    {
        USB_PORTSC_T portsc;
        DWORD *temp = (DWORD *)&portsc;

        *temp = INREG32(&(pUSBRegs)->OTG.PORTSC);
        portsc.PHCD = 1;
        OUTREG32(&(pUSBRegs)->OTG.PORTSC, *temp);
    }
}

//---------------------------------------------------------------------------------------------
// Function: RegisterCallback 
//     - function call by XVC to register the callback function during the XVC_Init.
// 
// Parameters: 
//      pfn - Pointer to USB Callback function pointers
//
// Return: 
//      NULL
//------------------------------------------------------------------------------------------------
void RegisterCallback(BSP_USB_CALLBACK_FNS *pfn)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+RegisterCallback\r\n")));
    if (pfn)
    {
        pfn->pfnUSBPowerDown = NULL;
        pfn->pfnUSBPowerUp = NULL;
        pfn->pfnUSBSetPhyPowerMode = BSPUsbXvrSetPhyPowerMode;
        DEBUGMSG(ZONE_FUNCTION, (TEXT("RegisterCallback for XVC\r\n")));
    }
    DEBUGMSG(ZONE_FUNCTION, (TEXT("-RegisterCallback\r\n")));
}