request.c

ISP1362 Fat32 coldfire523x

#include"Request.h"

SUDEV  uDev;
uint16 PTD [20];
uint8 DESC[40];
extern SFLAGS bFlags;

uint8 EnumUSBDev(void)
{
	uint8 ConfigTLen;

	/**************************(1)GET DEVICE DESCRIPER***************************/
	if(! GetDeviceDesc(0))
	{
		return FALSE;
	}
	/**************************(2)SET ADDDRESS***********************************/
	if(! SetAddress(1))
	{
		return FALSE;
	}
	/**************************(3)GET DEVICE DESCRIPER AGAIN*********************/
	if(! GetDeviceDesc(1))
	{
		return FALSE;
	}
	/**************************(4)GET CONFIGRATION DESCRIPER*********************/
	ConfigTLen = GetConfigDesc();
	if(! ConfigTLen)
	{
		return FALSE;
	}
	/**************************(5)GET ALL CONFIGRATION DESCRIPER AGING***********/
	if(! GetAllConfigDesc(ConfigTLen))
	{
		return FALSE;
	}
	/**************************(6)SET CONFIGURATION******************************/
	if(! SetConfig())
	{
		return FALSE;
	}
	/**************************(7)GET EVERY ENDPOINT INFOMATIONS*****************/
    if(! GetDevEPInfo())
	{
	    return FALSE;
	}
	return TRUE;
}

uint8 GetDeviceDesc(uint8 FunAddr)
{			
	uint32 Index = 0;
	uint8  FAddr;
	uint16 Setup_GetDevDesc[4]  = {0x0680, 0x0100, 0x0000, 0x0012};
	//uint8  Result[100];
	
    FAddr = (FunAddr & 0x7F);

	/* SETUP */	
	PTD[0] = 0xF800;
	PTD[1] = 0x0008;
	PTD[2] = 0x0008;
	PTD[3] = (0x0000 | FAddr);
    WriteATLDirect(Setup_GetDevDesc, (ATLSTARTADDR + 8), 8);
    //WriteATLDirect(PTD, ATLSTARTADDR, 8);             /* 写PTD头 */
    if(! Ep0Xfer(PTD, ATLSTARTADDR, Index++))
    {
        return FALSE;
    }
	/* IN */
	PTD[0] = 0xFC00;
	PTD[1] = 0x0020;
	PTD[2] = 0x0812;
	PTD[3] = (0x0000 | FAddr);
    //WriteATLDirect(PTD, (ATLSTARTADDR + 40), 8);             /* 写PTD头 */
    if(! Ep0Xfer(PTD, (ATLSTARTADDR + Hc_PTDLen), Index++))
    {
        return FALSE;
    }
	/* OUT */
	PTD[0] = 0xFC00;
	PTD[1] = 0x0000;
	PTD[2] = 0x0400;
	PTD[3] = (0x0000 | FAddr);
    //WriteATLDirect(PTD, (ATLSTARTADDR + 80), 8);             /* 写PTD头 */
    if(! Ep0Xfer(PTD, (ATLSTARTADDR + (Hc_PTDLen << 1)), Index))
    {
        return FALSE;
    }	
    //ISP1362Reg32Write(Hc_ATLPTDSkipMap, 0xFFFFFFF8);		  /* ACTIVE BLOCK */
    //ISP1362Reg32Write(Hc_ATLLastPTD, 0x00000004);
    //ActiveATLPTD();									  /* ACTIVE BUFFER */

    //Delay_1ms(5);
	//ReadATLDirect((uint16 *)Result, ATLSTARTADDR, 100L);  /* 读PTD头 */

	return TRUE;
}		

uint8 SetAddress(uint8 NewAddr)
{		
	uint32 Index = 0;
	uint8  FAddr;
  uint16 Setup_SetAddr[4] = {0x0500, 0x0000, 0x0000, 0x0000};
  
  FAddr = (NewAddr & 0x7F);
	
	/* SETUP */	
	PTD[0] = 0xF800;
	PTD[1] = 0x0008;
	PTD[2] = 0x0008;
	PTD[3] = 0x0000;
    Setup_SetAddr[1] |= FAddr;
    WriteATLDirect(Setup_SetAddr, (ATLSTARTADDR + 8), 8);
    if(! Ep0Xfer(PTD, ATLSTARTADDR, Index++))
    {
        return FALSE;
    }
	/* IN */
	PTD[0] = 0xFC00;
	PTD[1] = 0x0000;
	PTD[2] = 0x0800;
	PTD[3] = 0x0000;
    if(! Ep0Xfer(PTD, (ATLSTARTADDR + Hc_PTDLen), Index))
    {
        return FALSE;
    }

	return TRUE;
}

uint8 GetConfigDesc(void)
{		
	uint32 Index = 0;
	uint8  CfgTLen = 0;
	uint16 Setup_GetCofgDesc[4] = {0x0680, 0x0200, 0x0000, 0x0009};
	
	/* SETUP */	
	PTD[0] = 0xF800;
	PTD[1] = 0x0008;
	PTD[2] = 0x0008;
	PTD[3] = 0x0001;
    WriteATLDirect(Setup_GetCofgDesc, (ATLSTARTADDR + 8), 8);
    if(! Ep0Xfer(PTD, ATLSTARTADDR, Index++))
    {
        return FALSE;
    }
	/* IN */
	PTD[0] = 0xFC00;
	PTD[1] = 0x0010;
	PTD[2] = 0x0809;
	PTD[3] = 0x0001;
    if(! Ep0Xfer(PTD, (ATLSTARTADDR + Hc_PTDLen), Index++))
    {
        return FALSE;
    }
	/* OUT */
	PTD[0] = 0xFC00;
	PTD[1] = 0x0000;
	PTD[2] = 0x0400;
	PTD[3] = 0x0001;
    if(! Ep0Xfer(PTD, (ATLSTARTADDR + (Hc_PTDLen << 1)), Index))
    {
        return FALSE;
    }
    CfgTLen = DESC[2];	

	return CfgTLen;
}

uint8 GetAllConfigDesc(uint8 CfgTotalLen)
{
	uint32 Index = 0;
	uint16 Length = 0;
	uint16 Setup_GetAllCofgDesc[4] = {0x0680, 0x0200, 0x0000, 0x0000};

    if(CfgTotalLen > Hc_ATLBlkLen)
    {
        Length = Hc_ATLBlkLen;
    }
    else
    {
        Length = (uint16)CfgTotalLen;
    }
	
	/* SETUP */	
	PTD[0] = 0xF800;
	PTD[1] = 0x0008;
	PTD[2] = 0x0008;
	PTD[3] = 0x0001;
	Setup_GetAllCofgDesc[3] |= Length;
    WriteATLDirect(Setup_GetAllCofgDesc, (ATLSTARTADDR + 8), 8);
    if(! Ep0Xfer(PTD, ATLSTARTADDR, Index++))
    {
        return FALSE;
    }
	/* IN */
	PTD[0] = 0xFC00;
	PTD[1] = 0x0040;
	PTD[2] = (0x0800 | Length);
	PTD[3] = 0x0001;
    if(! Ep0Xfer(PTD, (ATLSTARTADDR + Hc_PTDLen), Index++))
    {
        return FALSE;
    }
	/* OUT */
	PTD[0] = 0xFC00;
	PTD[1] = 0x0000;
	PTD[2] = 0x0400;
	PTD[3] = 0x0001;
    if(! Ep0Xfer(PTD, (ATLSTARTADDR + (Hc_PTDLen << 1)), Index))
    {
        return FALSE;
    }	
	
	return TRUE;
}

uint8 SetConfig(void)
{			
	uint32 Index = 0;
	uint16 Setup_setCofg[4] = {0x0900, 0x0001, 0x0000, 0x0000};

	/* SETUP */	
	PTD[0] = 0xF800;
	PTD[1] = 0x0008;
	PTD[2] = 0x0008;
	PTD[3] = 0x0001;
    WriteATLDirect(Setup_setCofg, (ATLSTARTADDR + 8), 8);
    if(! Ep0Xfer(PTD, ATLSTARTADDR, Index++))
    {
        return FALSE;
    }
	/* IN */
	PTD[0] = 0xFC00;
	PTD[1] = 0x0000;
	PTD[2] = 0x0800;
	PTD[3] = 0x0001;
    if(! Ep0Xfer(PTD, (ATLSTARTADDR + Hc_PTDLen), Index))
    {
        return FALSE;
    }

	return TRUE;
}

uint8 GetDevEPInfo(void)
{										  
    uint32 i, EpTLen = 0;
	uint8 BulkEpNum;

	uDev.bNumOfEPs = ((DESC[9 + 4] <= MAX_EP) ? DESC[9 + 4] : MAX_EP);
	uDev.bInterfaceCls = DESC[9 + 5];
	uDev.bInterfaceSubCls = DESC[9 + 6];

    if((uDev.bInterfaceCls == 0x08) && (uDev.bInterfaceSubCls == 0x06))
    {
      bFlags.SLAVE_MASSDEVICE = 1;
    }
    else
    {
      bFlags.SLAVE_MASSDEVICE = 0;
    }

    for(i = 1; i <= uDev.bNumOfEPs; i++)
    {
        uDev.bEPAddr[i] = DESC[18 + EpTLen + 2];
		uDev.bEPAttr[i] = DESC[18 + EpTLen + 3];
        uDev.wEPMaxPSize[i] = LSwapuint16(DESC[18 + EpTLen + 4], DESC[18 + EpTLen + 5]);
        uDev.bDataTog[i] = 0;

        if(uDev.bEPAttr[i] == 0x02)
        {
            if(uDev.bEPAddr[i] & 0x80)
            {
                uDev.epbulkin = (uDev.bEPAddr[i] & 0x7F);
				uDev.InTogl = uDev.bDataTog[i];
            }
            else
            {
                uDev.epbulkout = uDev.bEPAddr[i];
				uDev.OutTogl = uDev.bDataTog[i];
            }
			BulkEpNum ++;
        }
		EpTLen += 7;
    }

    return BulkEpNum;
}

uint8 Ep0Xfer(uint16 * pBuf, uint16 ATLAddr, uint32 Shift)
{
    uint32 Skip, Last/*, Done*/;
	uint16 ActualBytes = 0, TotalBytes = 0;
	uint8  Result[8] = {0};
	uint32 ErrCounter = 0; 

	Last = (0x00000001 << Shift);
	Skip = ~(0x00000001 << Shift); 
	Skip &= 0xFFFFFFFF;

//        _ASMLINE(" move.w #$2700,SR ");
    WriteATLDirect(pBuf, ATLAddr, 8);             /* 写PTD头 */
    ActiveATLPTD();									  /* ACTIVE BUFFER */

    ISP1362Reg32Write(Hc_ATLPTDSkipMap, Skip);		  /* ACTIVE BLOCK */
    ISP1362Reg32Write(Hc_ATLLastPTD, Last);

    //Done = ISP1362Reg32Read(Hc_ATLPTDDoneMap);
    //---------------------------------------------------------------
    while(1)
    {
        ReadATLDirect((uint16 *)Result, ATLAddr, 8);
        ActualBytes = ((uint16)Result[0] | ((uint16)(Result[1] & 0x03) << 8));
        TotalBytes  = ((uint16)Result[4] | ((uint16)(Result[5] & 0x03) << 8));
        if((((Result[1] >> 3) & 0x01) == 0) && (((Result[1] >> 4) & 0x0F) == 0)
           	&& (ActualBytes == TotalBytes))
        {
              break;
        }
		else
		{
		    ErrCounter ++;
		}

        if(ErrCounter > 0xFFFF)
        {
	        ErrCounter = 0UL;
	        bFlags.ERROR = TRUE;
	        return FALSE;
        }
	}
//        _ASMLINE(" move.w #$2000,SR ");
	if(((*(pBuf + 2) & 0x03FF) != 0) && (((*(pBuf + 2) >> 10) & 0x0003) == 2) 
	          && (((*(pBuf + 1) >> 12) & 0x000F) == 0))
	{
	    ReadATLDirect((uint16 *)DESC, (ATLAddr + 8), (*(pBuf + 2) & 0x03FF));  /* 读描述符 */
	}
	else if(((*(pBuf + 1) & 0xF000) >> 12) != 0)
	{
	    if((*(pBuf + 2) & 0x0C00) == 0x0800) 
	    {
	        uDev.InTogl ^= 1;
	    }
	    else if((*(pBuf + 2) & 0x0C00) == 0x0400)
	    {
	    	uDev.OutTogl ^= 1;
	    }
		else{}
	}
	else{}

	return TRUE;
}

uint8 CheckPingPong(uint16 PingPongFlag)
{
	uint32 Done[3];
	uint16 ActualBytes = 0, TotalBytes = 0;
	uint8  Result[8] = {0};

    ActiveATLPTD();

    ISP1362Reg32Write(Hc_ATLPTDSkipMap, 0xFFFFFFFC);		  /* ACTIVE BLOCK */
    ISP1362Reg32Write(Hc_ATLLastPTD, 0x00000002);

	if(PingPongFlag)
	{
        Done[0] = ISP1362Reg32Read(Hc_ATLPTDDoneMap);
        Done[1] = ISP1362Reg16Read(HC_BUFFERSTATUS);
		Done[2] = ISP1362Reg16Read(Hc_ATLCurrentActivePTD);
        /*if(((Done[0] >> Shift) & 0x0001) == 1)
        {
       	}
		else 
			return FALSE;
          */do
		    {
            	ReadATLDirect((uint16 *)Result, ATLSTARTADDR, 8L);
            	ActualBytes = ((uint16)Result[0] | ((uint16)(Result[1] & 0x03) << 8));
            	TotalBytes  = ((uint16)Result[4] | ((uint16)(Result[5] & 0x03) << 8));
			}while(ActualBytes != TotalBytes);
	}
	else
	{
        Done[0] = ISP1362Reg32Read(Hc_ATLPTDDoneMap);
        Done[1] = ISP1362Reg16Read(HC_BUFFERSTATUS);
		Done[2] = ISP1362Reg16Read(Hc_ATLCurrentActivePTD);
        /*if(((Done[0] >> Shift) & 0x0001) == 1)
        {
       	}
		else 
			return FALSE;*/
        	do
			{
            	ReadATLDirect((uint16 *)Result, ATLSTARTADDR + Hc_PTDLen, 8L);
            	ActualBytes = ((uint16)Result[0] | ((uint16)(Result[1] & 0x03) << 8));
                TotalBytes  = ((uint16)Result[4] | ((uint16)(Result[5] & 0x03) << 8));
			}while(ActualBytes != TotalBytes);
	}

	return TRUE;
}