isr.c

瑞星微公司RK27XX系列芯片的SDK开发包

/********************************************************************
   COPYRIGHT (c)   2007 BY ROCK-CHIP FUZHOU
      --  ALL RIGHTS RESERVED  --
* File Name: UsbIsr.c
* Author:  Oliver Miao
* Created:  2007-6-20 9:59
* Modified:
* Revision:  1.00
*
*********************************************************************
********************
* Module History
********************
*2007-6-20 10:10 Created by Oli
*2007-9-24 11:41    去掉UsbSetupReq函数中对ResetFlag的检查 by Oli
*2007-9-24 16:04    Usb_PowerOnInit函数中：
                    //SOFT_CONNECT();                   //降低功耗
*********************************************************************/
#include "hw_include.h"

#include "include.h"
#include "usb.h"
#include "hw_memmap.h"
#include "hw_common.h"
#include "BulkOnly.h"
#include "UsbBlock.h"
//#include "hw_sd.h"

//#define       DEBUG

BOOL bIsFullSpeed;
BOOL bRequestError;
INT32 UsbZeroData;
INT32 ResetFlag;
UINT32 uControlStage;
UINT32 uBulkBlockSize;
UINT32 uCurrentCtrlPacketSize;
UINT32 uCurrentBulklPacketSize;
__align(4)  UINT8   Bulk_buf[4096];
setup_request_t  SetupRequestData;
UINT8   volatile    UsbConnected;       //modiby lxs @2008.1.23
UINT8   volatile    SCSI_MediaReady;    //modiby lxs @2008.1.23
extern UINT16  BulkEndpSize;
extern  UINT32 uControlDataSize;
extern  BYTE    scUsbDscr[];
extern  UINT8 *CtrlInBuffer  ;

extern  UINT8 G_ucBulkPhase;
extern  UINT8 G_ucBulkStausPhase;
uint8  HsRetryTimes = 0; //add by lxs @2008.02.22

void Delay10ms(void)
{
    ;
}

/********************************************************************
Routine  :  UDC_ISR
Input  :  void
Output  :  void
Function :  UDC interrupt routine
*********************************************************************/
void UDC_ISR(void)
{
    UINT32 int2flgReg = INTFLG;

#ifdef DEBUG
    //printf("->UDC_ISR\n");
#endif
    //USB状态中断
    if (int2flgReg & VBUS_INTR)
    {
        UsbVbusIsr();//UsbVbusIntr();
    }
    if (int2flgReg & USBRST_INTR)
    {
        UsbReset();
    }
    if (int2flgReg & SETUP_INTR)
    {
        UsbSetupReq();
    }
    if (int2flgReg & SUSP_INTR)
    {
        UsbSuspend();
    }
    if (int2flgReg & RSUME_INTR)
    {
        UsbResume();
    }

    //USB控制端点中断
    if (int2flgReg & IN0_INTR)
    {
        UsbIn0();
    }
    if (int2flgReg & OUT0_INTR)
    {
        UsbOut0();
    }

    //USB批量传输中断
    if (int2flgReg & ENP1_INTR)
    {
        UsbBulkOutPacket();
    }
    if (int2flgReg & ENP2_INTR)
    {
        UsbBulkInPacket();
    }
}

/********************************************************************
Routine  :  UsbReset
Input  :  void
Output  :  void
Function :  Process the Reset interrupt
*********************************************************************/
void UsbReset()
{
    UINT32 int2flgReg;

    uControlDataSize = 0;//uControlDataSize记录控制传输尚需要传输的字节个数
    G_ucBulkPhase = K_CommandPhase;
    G_ucBulkStausPhase = K_CommandPhase;
    UsbZeroData = 0;
#if 0
    do
    {
        int2flgReg = INTFLG;
    }
    while (int2flgReg & USBRST_INTR);
    if (!IS_HIGH_SPEED() && HsRetryTimes == 0)
    {
        HsRetryTimes = 1;
        USB_PHY_RST();
        DelayMs_nops(200);
        SOFT_CONNECT();
    }
#endif

    UDCInit();
    UsbReadyToReadDataEP(Bulk_buf);
    //2007-9-24 16:01ResetFlag = 1;
}

/********************************************************************
Routine  :  UsbSetupReq
Input  :  void
Output  :  void
Function :  Process the Usb Setup interrupt
*********************************************************************/
void UsbSetupReq()
{
    UINT32*  p;
    UINT32   request_type;

    bRequestError = NO;
    uControlStage = SETUP_STAGE;
    if (IS_HIGH_SPEED())
    {
        bIsFullSpeed = 0;
        uBulkBlockSize  = HI_SPEED_BULK_PACKET_SIZE;
        uCurrentCtrlPacketSize  = HI_SPEED_CTRL_PACKET_SIZE;
        uCurrentBulklPacketSize = HI_SPEED_BULK_PACKET_SIZE;
    }
    else
    {
        bIsFullSpeed = 1;
        uBulkBlockSize  = FULL_SPEED_BULK_PACKET_SIZE;
        uCurrentCtrlPacketSize  = FULL_SPEED_CTRL_PACKET_SIZE;
        uCurrentBulklPacketSize = FULL_SPEED_BULK_PACKET_SIZE;
    }
    scUsbDscr[7] = uCurrentCtrlPacketSize;
    //2007-9-24 16:01ResetFlag = 0;
    //UsbReadyToReadDataEP(ChannelSet[0].pBulkOutBuffer);
    UsbReadyToReadDataEP(Bulk_buf);

    // read setup data
    p = (UINT32*) & SetupRequestData;
    *p++ = *(volatile UINT32 *)UDC_SETUP1;
    *p   = *(volatile UINT32 *)UDC_SETUP2;

    // identify standard request
    request_type = GET_REQ_TYPE(SetupRequestData.bmRequestType);

    if (request_type == REQ_TYPE_STANDARD)  //USB标准请求
    {
        if (SetupRequestData.bRequest == GET_DESCRIPTOR)
        {
            UsbGetDescriptor();
//****************************************************************************
// 修改 PC 不开机 BUG。 2008-03-19 FZF
//****************************************************************************
            if (UsbConnected == 0)
            {
                UsbConnected = 1;   //modify by lxs @2008.1.23
                SCSI_MediaReady = 0;
            }
            //RockOSSendMsg(MBGUI, MS_ISRGU_USBCableInd ,(void*)1);
//****************************************************************************

        }
    }
    else
    {
        if (request_type == REQ_TYPE_CLASS)     //USB类请求
        {
            if (SetupRequestData.bRequest == 0xfe) //GET MAX LUN
            {
                char type = UsbBlkGetMaxLun() - 1;

                HsRetryTimes = 0;
                uControlDataSize = 1;
                UsbWriteCtlEP(1, (UINT8*)(&type));
            }
            else
            {
                if (SetupRequestData.bRequest == 0xff) //USB BULK-ONLY Mass Storage RESET
                {
                    ;
                }
            }
        }
        else
        {
            if (request_type == REQ_TYPE_VENDOR)    //USB厂家请求
            {
                ;
            }
        }
    }

    BulkEndpSize = bIsFullSpeed ? FULL_SPEED_BULK_PACKET_SIZE : HI_SPEED_BULK_PACKET_SIZE;
    uControlStage = DATA_STAGE ;
}

/********************************************************************
Routine  :  UsbSuspend
Input  :  void
Output  :  void
Function :  Process the Suspend interrupt
*********************************************************************/
void UsbSuspend()
{
    if (UsbConnected)
    {
        UsbConnected = 0;
        //RockOSSendMsg(MBGUI, MS_ISRGU_USBCableInd ,(void*)0);
    }
}

/********************************************************************
Routine  :  UsbResume
Input  :  void
Output  :  void
Function :  Process the Resume interrupt
*********************************************************************/
void UsbResume()
{
    UsbClrCtlEP();
}

/********************************************************************
Routine  :  UsbIn0
Input  :  void
Output  :  void
Function :  Process TX0 interrupt
*********************************************************************/
void UsbIn0()
{
    UINT32 STATUS;

    STATUS = TX0_STATUS; //MUST DONE!+oli@2007-6-28 23:13

    if (uControlStage == DATA_STAGE)
    {
        if (uControlDataSize > 0)
        {
            UsbWriteCtlEP(uControlDataSize, CtrlInBuffer);
        }
        else
        {
            if (UsbZeroData == 1)
            {
                UsbWriteCtlEP(0, CtrlInBuffer);
                UsbZeroData = 0;
            }
            else
            {
                // open OUT gate
                UsbEnableRX();
                uControlStage = STATUS_STAGE;
            }
        }
    }
    else
    {
        if (uControlStage == STATUS_STAGE)
        {
            UsbDisableEP0();
        }
    }
}

/********************************************************************
Routine  :  UsbOut0
Input  :  void
Output  :  void
Function :  Process RX0 interrupt
*********************************************************************/
void UsbOut0()
{
    INT32 len;
    UINT32 STATUS;

    if (uControlStage == STATUS_STAGE)
    {
        STATUS = RX0_STATUS;       //MUST DONE!!!+OLI@2007-6-28 23:19
        // assert both TX0NAK, RX0NAK at status stage
        UsbDisableEP0();
    }
    else
    {
        if (uControlStage == DATA_STAGE)
        {
            // read length from H/W
            len = RX0_STATUS & RxCNT;

            // record received result
            uControlDataSize -= len;
            WriteReg32(UDC_DMA0LM_OADDR, virt_to_phy((UINT32)(CtrlInBuffer)));
            WriteReg32(UDC_DMA0CTLO, ENP_DMA_START);

        }
    }
}

/********************************************************************
Routine  :  UsbIntrReq
Input  :  void
Output  :  channel index
Function :  Process Intr_IN interrupt
*********************************************************************/
void UsbIntrReq(UINT32 ch)
{
    return;     //暂时用不到+oli@2007-6-28 23:09
}

/********************************************************************
Routine  :  UsbCtlSetZeroData
Input  :  the data length that need to transfer
Output  :  void
Function :  Judge if it's need to transfer a zero lenth data
               after the last data packet in CtlTrans
*********************************************************************/
void UsbCtlSetZeroData(INT32 len)
{
    if (bIsFullSpeed)
    {
        UsbZeroData = (len % FULL_SPEED_CTRL_PACKET_SIZE) ? 0 : 1;
    }
    else
    {
        UsbZeroData = (len % HI_SPEED_CTRL_PACKET_SIZE) ? 0 : 1;
    }
}