hwinit.c

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

            DEBUGMSG(1, (L"\t\t\tLow Speed\r\n"));
            break;
        case 2:
            DEBUGMSG(1, (L"\t\t\tHigh Speed\r\n"));
            break;
        case 3:
        default:
            DEBUGMSG(1, (L"\t\t\tUndefined\r\n"));
            break;
    }
    DEBUGMSG(1, (L"\t\tParallel Transceiver Width:%x->", state->PTW));
    if (state->PTW) 
        DEBUGMSG(1, (L"\t\t\t16 bits\r\n"));
    else
        DEBUGMSG(1, (L"\t\t\t8 bits\r\n"));
    if (state->STS) 
        DEBUGMSG(1, (L"\t\tSerial Transceiver Select \r\n"));
    
    DEBUGMSG(1, (L"\t\tParallel Transceiver Select:%x->", state->PTS));
    switch (state->PTS) {
        case 0:
            DEBUGMSG(1, (L"\t\t\tUTMI/UTMI+\r\n"));
            break;
        case 1:
            DEBUGMSG(1, (L"\t\t\tPhilips Classic\r\n"));
            break;
        case 2:
            DEBUGMSG(1, (L"\t\t\tULPI\r\n"));
            break;
        case 3:
            DEBUGMSG(1, (L"\t\t\tSerial/1.1 PHY (FS Only)\r\n"));
            break;
        default:
            DEBUGMSG(1, (L"\t\t\tUndefined\r\n"));
            break;
    }                   
}
#endif

//-----------------------------------------------------------------------------
//
//  Function: DumpUSBRegs
//
//  This function is to dump the USB Register detail
//
//  Parameters:
//     regs - Pointer to 3 USB Core Register
//     sel - 0: H2, 1: H1, 2: OTG
//     
//  Returns:
//     NULL
//
//-----------------------------------------------------------------------------
#ifdef DEBUG

static void DumpUSBRegs(PCSP_USB_REGS regs, WORD sel)
{    
    CSP_USB_REG *pReg;
    
    if (sel == USB_SEL_OTG)
        DEBUGMSG(1, (L"Dump OTG Regs\r\n"));
    else
        DEBUGMSG(1,(L"Dump H%s USB Regs\r\n", ((sel == 0)? "2": "1")));
    
    if (sel == USB_SEL_H2)
        pReg = (PCSP_USB_REG)(&(regs->H2));
    else if (sel==USB_SEL_H1)
        pReg = (PCSP_USB_REG)(&(regs->H1));
    else
        pReg=(PCSP_USB_REG)(&(regs->OTG));

    DEBUGMSG(1,(L"\tID(%xh)=%x\r\n",offset(CSP_USB_REG,ID), INREG32(&pReg->ID)));
    DEBUGMSG(1,(L"\tHWGENERAL(%xh)=%x\r\n",offset(CSP_USB_REG,HWGENERAL),INREG32(&pReg->HWGENERAL)));
    DEBUGMSG(1,(L"\tHWHOST(%xh)=%x\r\n",offset(CSP_USB_REG,HWHOST),INREG32(&pReg->HWHOST)));
    DEBUGMSG(1,(L"\tHWDEVICE(%xh)=%x\r\n",offset(CSP_USB_REG,HWDEVICE),INREG32(&pReg->HWDEVICE)));
    DEBUGMSG(1,(L"\tHWTXBUF(%xh)=%x\r\n",offset(CSP_USB_REG,HWTXBUF),INREG32(&pReg->HWTXBUF)));
    DEBUGMSG(1,(L"\tHWRXBUF(%xh)=%x\r\n",offset(CSP_USB_REG,HWRXBUF),INREG32(&pReg->HWRXBUF)));
    DEBUGMSG(1,(L"\tCAPLENGTH(%xh)=%x\r\n",offset(CSP_USB_REG,CAPLENGTH),INREG8(&pReg->CAPLENGTH)));
    DEBUGMSG(1,(L"\tHCIVERSION(%xh)=%x\r\n",offset(CSP_USB_REG,HCIVERSION),INREG16(&pReg->HCIVERSION)));
    DEBUGMSG(1,(L"\tHCSPARAMS(%xh)=%x\r\n",offset(CSP_USB_REG,HCSPARAMS),INREG32(&pReg->HCSPARAMS)));
    DEBUGMSG(1,(L"\tHCCPARAMS(%xh)=%x\r\n",offset(CSP_USB_REG,HCCPARAMS),INREG32(&pReg->HCCPARAMS)));
    DEBUGMSG(1,(L"\tDCIVERSION(%xh)=%x\r\n",offset(CSP_USB_REG,DCIVERSION),INREG16(&pReg->DCIVERSION)));
    DEBUGMSG(1,(L"\tDCCPARAMS(%xh)=%x\r\n",offset(CSP_USB_REG,DCCPARAMS),INREG32(&pReg->DCCPARAMS)));
    DEBUGMSG(1,(L"\tUSBCMD(%xh)=%x\r\n",offset(CSP_USB_REG,USBCMD),INREG32(&pReg->USBCMD)));
    DEBUGMSG(1,(L"\tUSBSTS(%xh)=%x\r\n",offset(CSP_USB_REG,USBSTS),INREG32(&pReg->USBSTS)));
    DEBUGMSG(1,(L"\tUSBINTR(%xh)=%x\r\n",offset(CSP_USB_REG,USBINTR),INREG32(&pReg->USBINTR)));
    DEBUGMSG(1,(L"\tPORTSC(%xh)[0]=%x\r\n",offset(CSP_USB_REG,PORTSC[0]),INREG32(&pReg->PORTSC[0])));
    {
        USB_PORTSC_T state;
        DWORD * temp=(DWORD*)&state;
        *temp=INREG32(&pReg->PORTSC[0]);

        DumpDeviceState( & state);
    }
    DEBUGMSG(1,(L"\tOTGSC(%xh)=%x\r\n",offset(CSP_USB_REG,OTGSC),INREG32(&pReg->OTGSC)));
    DEBUGMSG(1,(L"\tUSBMODE(%xh)=%x\r\n",offset(CSP_USB_REG,USBMODE),INREG32(&pReg->USBMODE)));
    DEBUGMSG(1,(L"\tULPI_VIEWPORT(%xh)=%x\r\n",offset(CSP_USB_REG,ULPI_VIEWPORT),INREG32(&pReg->ULPI_VIEWPORT)));

    DEBUGMSG(1,(L"\t*********************\r\n"));
    DEBUGMSG(1,(L"\tAddress of ASYNCLISTADDR at 0x%x\r\n", &pReg->T_158H.ASYNCLISTADDR));
    DEBUGMSG(1,(L"\tASYNCLISTADDR(%xh)=%x\r\n",offset(CSP_USB_REG,T_158H),INREG32(&pReg->T_158H.ASYNCLISTADDR)));
    DEBUGMSG(1,(L"\tENDPTSETUPSTAT(%xh)=%x\r\n",offset(CSP_USB_REG,ENDPTSETUPSTAT),INREG32(&pReg->ENDPTSETUPSTAT)));
    DEBUGMSG(1,(L"\tENDPTPRIME(%xh)=%x\r\n",offset(CSP_USB_REG,ENDPTPRIME),INREG32(&pReg->ENDPTPRIME)));
    DEBUGMSG(1,(L"\tENDPTFLUSH(%xh)=%x\r\n",offset(CSP_USB_REG,ENDPTFLUSH),INREG32(&pReg->ENDPTFLUSH)));
    DEBUGMSG(1,(L"\tENDPTSTATUS(%xh)=%x\r\n",offset(CSP_USB_REG,ENDPTSTATUS),INREG32(&pReg->ENDPTSTATUS)));
    DEBUGMSG(1,(L"\tENDPTCOMPLETE(%xh)=%x\r\n",offset(CSP_USB_REG,ENDPTCOMPLETE),INREG32(&pReg->ENDPTCOMPLETE)));
    DEBUGMSG(1,(L"\tENDPTCTRL0(%xh)=%x\r\n",offset(CSP_USB_REG,ENDPTCTRL0),INREG32(&pReg->ENDPTCTRL0)));
    DEBUGMSG(1,(L"\t*********************\r\n"));
    
    DEBUGMSG(1,(L"\tUSB_CTRL(%xh)=%x\r\n",offset(CSP_USB_REGS,USB_CTRL),INREG32(&regs->USB_CTRL)));
    DEBUGMSG(1,(L"\tUSB_OTG_MIRROR(%xh)=%x\r\n",offset(CSP_USB_REGS,USB_OTG_MIRROR),INREG32(&regs->USB_OTG_MIRROR)));
}

#endif

//-----------------------------------------------------------------------------
//
//  Function: ConfigH1
//
//  This function is to configure the USB H1 Core.
//
//  Parameters:
//     pRegs - Pointer to 3 USB Core Registers
//     
//  Returns:
//     NULL
//
//-----------------------------------------------------------------------------
static void ConfigH1(CSP_USB_REGS *pRegs)
{
    USB_PORTSC_T portsc;
    USB_CTRL_T ctrl;
    USB_USBCMD_T  cmd;
    USB_USBMODE_T mode;
    DWORD *temp;

    //DEBUGMSG(1, (TEXT("H1 Configuration\r\n")));
    //void usb_hs1_serial_interface_config()
    temp =  (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    ctrl.H1SIC = 0x2;
    OUTREG32(&pRegs->USB_CTRL, *temp);

    //void usb_hs1_interrupt_enable()
    temp = (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    ctrl.H1WIE = 0x1;
    OUTREG32(&pRegs->USB_CTRL, *temp);

    //void usb_hs1_power_mask_enable()
    temp = (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    ctrl.H1PM = 0x1;
    OUTREG32(&pRegs->USB_CTRL, *temp);

    //void usb_hs1_tll_disable()
    temp = (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    ctrl.H1DT = 0x1;
    OUTREG32(&pRegs->USB_CTRL, *temp);

    //void usb_bypass_inactive()
    temp = (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    ctrl.BPE = 0x1;
    OUTREG32(&pRegs->USB_CTRL, *temp);
    
    //uh1_setmode();
    temp = (DWORD *)&cmd;
    *temp = INREG32(&pRegs->H1.USBCMD);
    cmd.RST = 1;
    OUTREG32(&pRegs->H1.USBCMD, *temp);

    while (INREG32(&pRegs->H1.USBCMD)& (0x1 << 1));

    temp = (DWORD *)&mode;
    *temp = INREG32(&pRegs->H1.USBMODE);
    mode.CM = 0x3;
    OUTREG32(&pRegs->H1.USBMODE, *temp);

    Sleep(10);
    if ((INREG32(&pRegs->H1.USBMODE)& 0x3) != 0x3)
    {
        DEBUGMSG(1, (TEXT("USBMode setting failure\r\n")));
        return;
    }

    //uh1_power_on_port1();
    if (INREG32(&pRegs->H1.HCSPARAMS) &(0x1 << 4))
    {
        temp = (DWORD *)&portsc;
        *temp = INREG32(&pRegs->H1.PORTSC);
        portsc.PP = 1;
        OUTREG32(&pRegs->H1.PORTSC, *temp);
    }
    else
        DEBUGMSG(1, (TEXT("Host does not control power\r\n")));

    //uh1_controller_reset
    temp=(DWORD *)&cmd; 
    *temp=0;
    cmd.RST=1;  
    CLRREG32(&pRegs->H1.USBCMD, *temp);
    *temp = INREG32(&pRegs->H1.USBCMD);
    cmd.RST=1;
    OUTREG32(&pRegs->H1.USBCMD, *temp);
    while (INREG32(&pRegs->H1.USBCMD) & (0x1 << 1));

    temp = (DWORD *)&mode;
    *temp = INREG32(&pRegs->H1.USBMODE);
    mode.CM = 0x3;
    OUTREG32(&pRegs->H1.USBMODE, *temp);

    Sleep(10);
    while ((INREG32(&pRegs->H1.USBMODE)& 0x3) != 0x3);
    
    return;
}
//-----------------------------------------------------------------------------
//
//  Function: ConfigH2
//
//  This function is to configure the USB H2 Core.
//
//  Parameters:
//     pRegs - Pointer to 3 USB Core Registers
//     
//  Returns:
//     NULL
//
//-----------------------------------------------------------------------------
static void ConfigH2(CSP_USB_REGS *pRegs)
{
    USB_PORTSC_T portsc;
    USB_CTRL_T   ctrl;
    USB_USBMODE_T mode;
    USB_USBCMD_T cmd;
    DWORD *temp;
           
	DEBUGMSG(1, (TEXT("USBH2 ConfigH2 pRegs 0x%X\r\n"), pRegs));

    //usb_hs2_ulpi_interface_configure
    temp  = (DWORD *)&portsc;
    *temp = INREG32(&pRegs->H2.PORTSC);
    portsc.LS  = 0x2;
    portsc.PTS = 0x2;

    DEBUGMSG(1, (TEXT("USBH2 *temp 0x%X\r\n"), *temp ));

	// Keep this comment as to configure for the Full Speed Testing
    // Configure this to Full Speed for testing purpose
	//portsc.PFSC = 0x1;
    //portsc.PTC =  0x6;
    OUTREG32(&pRegs->H2.PORTSC, *temp);

    //usb_h2_interrupt_enable
    temp =  (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    ctrl.H2WIE = 1;
    OUTREG32(&pRegs->USB_CTRL, *temp);

    //usb_h2_power_mask_enable
    temp =  (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    ctrl.H2PM = 1;
    OUTREG32(&pRegs->USB_CTRL, *temp);

    // usb_h2_tll_disable
    temp =  (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    ctrl.H2DT = 1;
    OUTREG32(&pRegs->USB_CTRL, *temp);

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

    //uh2_setmode
    temp = (DWORD *)&cmd;
    *temp = INREG32(&pRegs->H2.USBCMD);
    cmd.RST = 1;
    OUTREG32(&pRegs->H2.USBCMD, *temp);

    while (INREG32(&pRegs->H2.USBCMD)& (0x1 << 1));

    temp = (DWORD *)&mode;
    *temp = INREG32(&pRegs->H2.USBMODE);
    mode.CM = 0x3;
    OUTREG32(&pRegs->H2.USBMODE, *temp);

    Sleep(10);
    if ((INREG32(&pRegs->H2.USBMODE)& 0x3) != 0x3)
    {
        DEBUGMSG(1, (TEXT("USBMode setting failure\r\n")));
        return;
    }
 
    //uh2_power_on_port1
    if (INREG32(&pRegs->H2.HCSPARAMS) &(0x1 << 4))
    {
        temp = (DWORD *)&portsc;
        *temp = INREG32(&pRegs->H2.PORTSC);
		DEBUGMSG(1, (TEXT("USBH2 PORTSC  0x%X\r\n"), *temp ));
        portsc.PP = 1;
        OUTREG32(&pRegs->H2.PORTSC, *temp);
    }
    else
        DEBUGMSG(1, (TEXT("Host does not control power\r\n")));

    //uh2_controller_reset
    temp=(DWORD *)&cmd; 
    *temp=0;
    cmd.RST=1;  
    CLRREG32(&pRegs->H2.USBCMD, *temp);
    *temp = INREG32(&pRegs->H2.USBCMD);
    cmd.RST=1;
    OUTREG32(&pRegs->H2.USBCMD, *temp);
    while (INREG32(&pRegs->H2.USBCMD) & (0x1 << 1));

    temp = (DWORD *)&mode;
    *temp = INREG32(&pRegs->H2.USBMODE);
    mode.CM = 0x3;
    OUTREG32(&pRegs->H2.USBMODE, *temp);

    Sleep(10);
    while ((INREG32(&pRegs->H2.USBMODE)& 0x3) != 0x3);

//#define H2_TEST_MODE
#ifdef H2_TEST_MODE
    DEBUGMSG(1, (TEXT("+H2_TestMode\r\n")));
    // Disable async and periodic schedule
    // Disable async and periodic schedule
    temp = (DWORD *)&cmd;
    *temp = 0;
    *temp = INREG32(&pRegs->H2.USBCMD);
    *temp = *temp & ~0x30;
    OUTREG32(&pRegs->H2.USBCMD, *temp);

    DEBUGMSG(1, (TEXT("USBCMD after setting = 0x%x\r\n"), INREG32(&pRegs->H2.USBCMD)));

    // Go to suspend mode, please
    temp  = (DWORD *)&portsc;
    *temp = 0;
    *temp = INREG32(&pRegs->H2.PORTSC);
    *temp  |= 0x00000080;
    OUTREG32(&pRegs->H2.PORTSC, *temp);

    // Set to TEST_MODE, please
    temp  = (DWORD *)&portsc;
    *temp = 0;
    *temp = INREG32(&pRegs->H2.PORTSC);
    portsc.PTC = 0x4; // PTC = 4 -> test pattern
    OUTREG32(&pRegs->H2.PORTSC, *temp);

    DEBUGMSG(1, (TEXT("PORTSC after setting = 0x%x\r\n"), INREG32(&pRegs->H2.PORTSC)));

    // Set run/stop bit now
    temp = (DWORD *)&cmd;
    *temp = 0;
    *temp = INREG32(&pRegs->H2.USBCMD);
    cmd.RS = 1;
    OUTREG32(&pRegs->H2.USBCMD, *temp);

    DEBUGMSG(1, (TEXT("-H2_TestMode\r\n")));
    // Richard asks me to do, loop forever!!
    while(1);
#endif

    return;
}

//-----------------------------------------------------------------------------
//
//  Function: ConfigOTG
//
//  This function is to configure the USB OTG Core.
//
//  Parameters:
//     pRegs - Pointer to 3 USB Core Registers
//     
//  Returns:
//     NULL
//
//-----------------------------------------------------------------------------
static void ConfigOTG(CSP_USB_REGS *pRegs, int speed)
{
    USB_PORTSC_T portsc;
    USB_CTRL_T   ctrl;
    USB_USBMODE_T mode;
    USB_USBCMD_T cmd;   
    DWORD *temp;
            
    DEBUGMSG(1, (TEXT("...... CONFIG OTG ......\r\n")));
    // Stop the controller first
   {
        USB_USBCMD_T cmd;           
        DWORD * temp = (DWORD *)&cmd;
        *temp = INREG32(&pRegs->OTG.USBCMD);
		DEBUGMSG(1, (TEXT("...... Stop the controller......*temp 0x%x\r\n"),*temp));
        cmd.RS = 0;
        OUTREG32(&pRegs->OTG.USBCMD, *temp);
        while ((INREG32(&pRegs->OTG.USBCMD) & 0x1) == 0x1)
		{
            DEBUGMSG(1, (TEXT(" StopOTG USBCMD = 0x%x\r\n"), (INREG32(&pRegs->OTG.USBCMD))));
            Sleep(100);
        }
		DEBUGMSG(1, (TEXT("...... After Stop the controller......*temp 0x%x\r\n"),*temp));

    }

    // Do a reset first no matter what
    {
        USB_USBCMD_T cmd;           
        DWORD * temp = (DWORD *)&cmd;
        *temp = INREG32(&pRegs->OTG.USBCMD);
		
		DEBUGMSG(1, (TEXT("......  Before  reset the controller......*temp 0x%x\r\n"),*temp));

        cmd.RST = 1;
        OUTREG32(&pRegs->OTG.USBCMD, *temp);
        while ((INREG32(&pRegs->OTG.USBCMD) & 0x1<<1) == (0x1<<1))
		{
            DEBUGMSG(1, (TEXT("ResetOTG USBCMD= 0x%x\r\n"), (INREG32(&pRegs->OTG.USBCMD))));
            Sleep(100);
        }

		DEBUGMSG(1, (TEXT("...... After reset the controller......*temp 0x%x\r\n"),*temp));


    }

    //usb_otg_ulpi_interface_configure
    temp  = (DWORD *)&portsc;
    *temp = INREG32(&pRegs->OTG.PORTSC);
    
	DEBUGMSG(1, (TEXT("usb_otg_ulpi_interface_configure  *temp 0X%X\r\n"), *temp));

    if (speed == FULL_SPEED)
    {       
        DEBUGMSG(1, (TEXT("+ConfigOTG Full speed \r\n")));
		portsc.PTS = 0x3;
    }
    else
    {
		DEBUGMSG(1, (TEXT("+ConfigOTG  High speed \r\n")));
        portsc.LS  = 0x2;
        portsc.PTS = 0x2;

    // Configure this to Full Speed for testing purpose
    //portsc.PFSC = 0x1;
    //portsc.PTC =  0x6;

    }
    OUTREG32(&pRegs->OTG.PORTSC, *temp);

    DEBUGMSG(1, (TEXT("ConfigOTG: Write to USBCTRL register \r\n")));
    // usb_ulpi_interrupt_enable
    temp  = (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    
	if (speed == FULL_SPEED)
        ctrl.OUIE = 0;
    else
	{
        DEBUGMSG(1, (TEXT("usb_ulpi_interrupt_enable \r\n")));
		ctrl.OUIE = 1;
		OUTREG32(&pRegs->USB_CTRL, *temp);
    }
    // usb_otg_interrupt_enable
    temp = (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    
	DEBUGMSG(1, (TEXT("usb_otg_interrupt_enable \r\n")));
	ctrl.OWIE = 1;
    OUTREG32(&pRegs->USB_CTRL, *temp);

    // usb_otg_power_mask_enable
    temp = (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
	
	DEBUGMSG(1, (TEXT("usb_otg_power_mask_enable \r\n")));
    ctrl.OPM = 1;
    OUTREG32(&pRegs->USB_CTRL, *temp);

    // usb_otg_tll_disable
    temp = (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    ctrl.H1DT = 1;
    OUTREG32(&pRegs->USB_CTRL, *temp);
    // usb_bypass_inactive
    temp = (DWORD *)&ctrl;  
    *temp=0;