usb.c

LV24000的单片机DEMO程序

    _USCTRL = 0xc0;
    #endif
}

/*-------------------------------------------------------------------
  SOF Interrupt
  Endpoint Interrupt
  -----------------------------------------------------------------*/
void EndpointAck(void) 
{
    if(DeviceInfo.State.bm.Default) 
    {
        if(_AK0FG & _AK0EN)
            Ep0Ack();
        else if(_AK1FG & _AK1EN)
            Ep1Ack();
        else if(_AK2FG & _AK2EN)
            Ep2Ack();
        else if(_AK3FG & _AK3EN)
            Ep3Ack();
        else if(_AK4FG & _AK4EN)
            Ep4Ack();
        else if(_AK5FG & _AK5EN)
            Ep5Ack();
        else if(_AK6FG & _AK6EN)
            Ep6Ack();
        else if(_ER5EN & _ER5FG)
            Ep5Err();
    }
} // End EndpointAck

void Ep0Ack(void) 
{
    unsigned char       TokenCode;              // 僩乕僋儞偺庬椶
    unsigned char       RxCount;                // 庴怣僶僀僩悢
    struct RequestST    Request_Tmp;            // 儕僋僄僗僩忣曬

    TokenCode = _EPINFO & 0x03;
    RxCount = _EP0RX & 0x7f;
    _AK0FG = 0;                                 // EP0 妱傝崬傒僼儔僌僋儕傾

    switch(TokenCode) 
    {
    case SETUP_CODE:
        Request_Tmp = EP0Rx.Request;            // 儕僋僄僗僩忣曬懸旔
        if ((EndpointInfo[0].State = Setup(&Request_Tmp)) == ERROR)      // 儕僋僄僗僩忣曬傪億僀儞僞堷搉偟
            _E0STL = 1;
        break;
    case IN_CODE:
        switch (EndpointInfo[0].State) 
        {
        // "Set Address" 偺僗僥乕僞僗僗僥乕僕
        case C_ADDR:
            if ((_USBADR = DeviceInfo.Address) != 0) 
            {    // 傾僪儗僗侽埲奜
                DeviceInfo.State.bm.Addressed = TRUE;
                _USBADR |= 0x80;                        // ADREN = 1
            }
            else                                        // 傾僪儗僗侽
                DeviceInfo.State.bm.Addressed = FALSE;
        // 僗僥乕僞僗僗僥乕僕
        case C_NO_DATA:
        case C_WRITE_END:
            EndpointInfo[0].State = SETUP_READY;
            break;
        // 僐儞僩儘乕儖儕乕僪
        case C_READ:
            EndpointInfo[0].State = DescriptorRead(&LengthRemain, &DataRemain);
            break;
        // 僐儞僩儘乕儖儕乕僪乮揮憲僨乕僞側偟乯
        case C_READ_END:
//          _E0CST = 1;
//          _E0ACK = 1;
            _EP0STA |= 0x0a;
        }
        break;
    case OUT_CODE:
        switch(EndpointInfo[0].State) {
        case C_WRITE:
        case C_AC_SET:
            EndpointInfo[0].State = ControlWrite(RxCount,&LengthRemain,&pRxData);
            break;
        case C_READ_END:
            EndpointInfo[0].State = SETUP_READY;
        }
    }
} // End Ep0Ack

void Ep1Ack(void) 
{
	_AK1FG = 0;
} // End Ep1Ack

void Ep2Ack(void) 
{
	BYTE i, byRxCount;
	
	if (g_byUsbRxCnt == 0)
	{
		byRxCount = _EP2RX & 0x7f;
		for (i=0; i<byRxCount; i++)
			g_ReceiveBuf[i] = EP2BK0.B[i];

		// Let application known something is is the buffer
		g_byUsbRxCnt = byRxCount;
	}
    	_AK2FG = 0;
	_E2ACK = 1;

} // End Ep2Ack

void    Ep3Ack(void) 
{
    _AK3FG = 0;
}
void    Ep4Ack(void) 
{
    _AK4FG = 0;
}
void    Ep5Ack(void) 
{
    _AK5FG = 0;
}
void    Ep6Ack(void) 
{
    _AK6FG = 0;
}
void    Ep5Err(void) 
{
    _ER5FG = 0;
    _E5ACK = 1;
}
/*-------------------------------------------------------------------
        僙僢僩傾僢僾僩儔儞僓僋僔儑儞張棟
-------------------------------------------------------------------*/
unsigned char   Setup  (struct RequestST* pRequest) 
{

    pRxData = RxData;
    switch(pRequest->bmRequestType) 
    {
    /*----- Host to Device Request --------------------------------*/
    /*----- Standard -----*/
    case 0x00:                                  /* Device */
        switch(pRequest->bRequest) 
        {
        case CLEAR_FEATURE:
            return(ClearFeatureDevice(pRequest->wValue.B.L));
        case SET_ADDRESS:
            return(SetAddress(pRequest->wValue.B.L));
        case SET_CONFIGURATION:
            return(SetConfiguration(pRequest->wValue.B.L));
//      case SET_DESCRIPTOR:
        case SET_FEATURE:
            return(SetFeatureDevice(pRequest->wValue.B.L));
        }
        break;
    case 0x01:                                  /* Interface */
        switch(pRequest->bRequest) 
        {
//      case CLEAR_FEATURE:
//      case SET_FEATURE:
        case SET_INTERFACE:
            return(SetInterface(pRequest->wIndex.B.L, pRequest->wValue.B.L));
        }
        break;
    case 0x02:                                  /* Endpoint */
        switch(pRequest->bRequest) 
        {
        case CLEAR_FEATURE:
            return(ClearFeatureEndpoint(pRequest->wValue.B.L,pRequest->wIndex.B.L & ~0x80));
        case SET_FEATURE:
            return(SetFeatureEndpoint(pRequest->wValue.B.L,pRequest->wIndex.B.L & ~0x80));
        }
        break;
    /*----- Class -----*/

    /*----- Device to Host Request --------------------------------*/
    /*----- Standard -----*/
    case 0x80:                                  /* Device */
        switch(pRequest->bRequest) 
        {
        case GET_CONFIGURATION:
            return(GetConfiguration());
        case GET_DESCRIPTOR:
            return(GetDescriptor(pRequest->wValue.B.H,pRequest->wValue.B.L,pRequest->wLength.W));
        case GET_STATUS:
            return(GetStatusDevice());
        }
        break;
    case 0x81:                                  /* Interface */
        switch(pRequest->bRequest) 
        {
        case GET_INTERFACE:
            return(GetInterface(pRequest->wIndex.B.L));
        case GET_STATUS:
            return(GetStatusInterface(pRequest->wIndex.B.L));
        case GET_DESCRIPTOR:
            return(GetDescriptor(pRequest->wValue.B.H,pRequest->wIndex.B.L,pRequest->wLength.W));
        }
        break;
    case 0x82:                                  /* Endpoint */
        switch(pRequest->bRequest) 
        {
        case GET_STATUS:
            return(GetStatusEndpoint(pRequest->wIndex.B.L & ~0x80));    // 僄儞僪億僀儞僩斣崋偺價僢僩俈偼揮憲曽岦
//      case SYNCH_FRAME:
        }
        break;
    /*----- Class -----*/
    }
    /*----- 儕僋僄僗僩僄儔乕 -----*/
    return(ERROR);
}

/*-------------------------------------------------------------------
  9.4   Standard Device Request
-------------------------------------------------------------------*/
/*-------------------------------------------------------------------
   9.4.1  Clear Feature
-------------------------------------------------------------------*/
/*-------------------------------------------------------------------
        Clear Feature Device
-------------------------------------------------------------------*/
unsigned char   ClearFeatureDevice (unsigned char FeatureSelector) 
{
    /* << Addressed >> */
    if((FeatureSelector == DEVICE_REMOTE_WAKEUP) && DeviceInfo.State.bm.Addressed) 
    {
        DeviceInfo.RemoteWakeup = FALSE;
        return(NoDataControl());
    }
    else
        return(ERROR);
}
/*-------------------------------------------------------------------
        Clear Feature Endpoint
-------------------------------------------------------------------*/
unsigned char   ClearFeatureEndpoint(unsigned char FeatureSelector, unsigned char Number) 
{
    if((FeatureSelector == ENDPOINT_HALT) &&
       ((DeviceInfo.State.bm.Addressed && (Number==0)) ||
        (DeviceInfo.State.bm.Configured && (Number < NUM_OF_EP)))) {
        EndpointInfo[Number].HaltFeature = FALSE;
        EndpointInfo[Number].DataToggle  = FALSE;
        return(NoDataControl());
    }
    else
        return(ERROR);
}
/*-------------------------------------------------------------------
   9.4.2  Get Configuration
-------------------------------------------------------------------*/
unsigned char GetConfiguration(void) 
{
    /* << Addressed >> */
    if(DeviceInfo.State.bm.Addressed) 
    {
        /* << Configured >> */
        if(DeviceInfo.State.bm.Configured)
            EP0Tx.B[0] = 1;
        else
            EP0Tx.B[0] = 0;
        ControlRead(1);
        return(C_READ_END);
    }
    else
        return(ERROR);
}

/*-------------------------------------------------------------------
   9.4.3  Get Descriptor
-------------------------------------------------------------------*/
unsigned char   GetDescriptor (unsigned char Type, unsigned char Index, unsigned int Length) 
{
    switch(Type) 
    {
    case DEVICE:
        DataRemain = sizeof(DeviceDescriptor);
        pTxData = (unsigned char _rom *) &DeviceDescriptor;
        break;
    case CONFIGURATION:
        DataRemain = sizeof(ConfigurationDescriptor);
        pTxData = ConfigurationDescriptor;
        break;
    case STRING:
        switch(Index) 
        {
        // LANGID
        case 0:
            DataRemain = sizeof(Unicode);
            pTxData = (unsigned char _rom *) &Unicode;
            break;
        // Manufacturer
        case 1:
            DataRemain = sizeof(iManufacturer);
            pTxData = (unsigned char _rom *) &iManufacturer;
            break;
        // Product
        case 2:
            DataRemain = sizeof(iProduct);
            pTxData = (unsigned char _rom *) &iProduct;
            break;
        default:
            return(ERROR);
        }
        break;
    default:
        return(ERROR);
    }
    LengthRemain = Length;
    return(DescriptorRead(&LengthRemain, &DataRemain));
}

/*-------------------------------------------------------------------
  9.4.4  Get Interface
-------------------------------------------------------------------*/
unsigned char   GetInterface (unsigned char Number) 
{
    if(DeviceInfo.State.bm.Configured && (Number < NUM_OF_IF)) 
    {
        EP0Tx.B[0] = InterfaceInfo[Number].AltSetting;
        ControlRead(1);
        return(C_READ_END);
    }
    else
        return(ERROR);
}
/*-------------------------------------------------------------------
   9.4.5  Get Status
-------------------------------------------------------------------*/
/*-------------------------------------------------------------------
        Get Status Device
-------------------------------------------------------------------*/
unsigned char   GetStatusDevice (void) 
{
    unsigned char       RemoteWakeup;
    /* << Addressed >> */
    if(DeviceInfo.State.bm.Addressed) 
    {
        if(DeviceInfo.RemoteWakeup)
            RemoteWakeup = 0x02;
        else