usb.c

EV440B实验源码

    USBWriteCommand(USB_COMMAND_READ_INTERRUPT);
    ulIntStatus = USBReadData();
    ulIntStatus |= USBReadData() << 8;

    // Do nothing if there was a bus reset.
      if(ulIntStatus & USB_INT1_BUS_RESET)
    {
    }
    // Handle an interrupt on the bulk out endpoint.
     if(ulIntStatus & USB_INT1_ENDPOINT2_OUT)
    {
       Uart_Printf("Occur USB_INT1_ENDPOINT2_OUT interrupt\n");
        // Read the status of the last transaction on the bulk out endpoint.
         USBWriteCommand(USB_COMMAND_READ_LAST_XACTION_STATUS +
                        USB_ENDPOINT_BULK_OUT);
        ulTransactionStatus = USBReadData();

        // Was a packet of data received successfully?
        if(ulTransactionStatus & USB_XACTION_STATUS_DATA_RX_TX_SUCCESS)
        {
       // If there is a buffer to read this data into, then read the data into that buffer.
       // Read the packet.
        USBReadEndpoint(USB_ENDPOINT_BULK_OUT, &sUSB.pucBulkOut, &sUSB.ulBulkOutCount);
         }
    }
    // Handle an interrupt on the control out endpoint.
    if(ulIntStatus & USB_INT1_CONTROL_OUT)
    {
        Uart_Printf("Occur USB_INT1_CONTROL_OUT interrupt\n");
        // Read the status of the last transaction on the control out endpoint.
       USBWriteCommand(USB_COMMAND_READ_LAST_XACTION_STATUS +  USB_ENDPOINT_CONTROL_OUT);
        ulTransactionStatus = USBReadData();
        // Was a setup packet received?
        if(ulTransactionStatus & USB_XACTION_STATUS_SETUP_PACKET)
        {
        // Read the packet.
            pucChar = (U8 *)&sUSB.sControlOut;
            ulLength = sizeof(ControlTransfer);
            if(USBReadEndpoint(USB_ENDPOINT_CONTROL_OUT, &pucChar,
                               &ulLength) != sizeof(ControlTransfer))
            {
          // The size of the setup packet is incorrect, so stall both of the control endpoints.
                USBStallEndpoint(USB_ENDPOINT_CONTROL_OUT, 1);
                USBStallEndpoint(USB_ENDPOINT_CONTROL_IN, 1);
            }
            else
            {
             // Acknowledge both the control in and control out endpoints,
             // and send a clear buffer command to the control out endpoint.
                USBWriteCommand(USB_COMMAND_SELECT_ENDPOINT + USB_ENDPOINT_CONTROL_OUT);
                USBWriteCommand(USB_COMMAND_ACKNOWLEDGE_ENDPOINT);
                USBWriteCommand(USB_COMMAND_CLEAR_BUFFER);
                USBWriteCommand(USB_COMMAND_SELECT_ENDPOINT + USB_ENDPOINT_CONTROL_IN);
                USBWriteCommand(USB_COMMAND_ACKNOWLEDGE_ENDPOINT);

            // Process the command in the setup packet.
            if(((sUSB.sControlOut.bmRequestType & USB_RT_TYPE_MASK) ==
                    USB_RT_TYPE_STANDARD) && (sUSB.sControlOut.bRequest < 16))
                {
            // This is a standard request, so call the appropriate routine.
              (*USBStandardDeviceRequest[sUSB.sControlOut.bRequest])();
                }
                else
                {
            // All other requests are treated as reserved requests.
                    USBReserved();
                }
            }
        }
        else
        {  // The packet was not a setup packet, so ignore it.  Send a clear
            // buffer command to the control out endpoint so it will receive new packets.
            //
            USBWriteCommand(USB_COMMAND_SELECT_ENDPOINT +
                            USB_ENDPOINT_CONTROL_OUT);
            USBWriteCommand(USB_COMMAND_CLEAR_BUFFER);
            // Acknowledge both the control in and control out endpoints.
            USBWriteCommand(USB_COMMAND_ACKNOWLEDGE_ENDPOINT);
            USBWriteCommand(USB_COMMAND_SELECT_ENDPOINT + USB_ENDPOINT_CONTROL_IN);
            USBWriteCommand(USB_COMMAND_ACKNOWLEDGE_ENDPOINT);
        }
    }
    // Handle an interrupt on the control in endpoint.
    if(ulIntStatus & USB_INT1_CONTROL_IN)
    {
        Uart_Printf("Occur USB_INT1_CONTROL_IN interrupt\n");
        // Read the status of the last transaction on the control in endpoint.
        USBWriteCommand(USB_COMMAND_READ_LAST_XACTION_STATUS + USB_ENDPOINT_CONTROL_IN);
        USBReadData();

        // Was this the last block of data to be sent back to the host?
         if(sUSB.ulControlInCount != 0)
        {
            // Send the next packet of data to the host.
        USBWriteEndpoint(USB_ENDPOINT_CONTROL_IN, &sUSB.pucControlIn,&sUSB.ulControlInCount);
        }
        else
        {  // There is no more data to send, so send an empty packet.
            ulLength = 0;
            USBWriteEndpoint(USB_ENDPOINT_CONTROL_IN, 0, &ulLength);
        }
    }
    // Handle an interrupt on the bulk in endpoint.
    if(ulIntStatus & USB_INT1_ENDPOINT2_IN)
    {
        Uart_Printf("Occur USB_INT1_ENDPOINT2_IN interrupt\n");
        // Read the status of the last transaction on the bulk in endpoint.
        USBWriteCommand(USB_COMMAND_READ_LAST_XACTION_STATUS + USB_ENDPOINT_BULK_IN);
        USBReadData();

        // Was this the last block of data to be sent back to the host?
        if(sUSB.ulBulkInCount != 0)
        {// Send the next packet of data to the host.
         USBWriteEndpoint(USB_ENDPOINT_BULK_IN, &sUSB.pucBulkIn, &sUSB.ulBulkInCount);
        }
    }
}

//****************************************************************************
//
// USBReadData will read a  value from the data register of the PDIUSBD12.
//
//****************************************************************************
unsigned char 
USBReadData(void)
{
    unsigned char * volatile dataregister = (unsigned char*)(unsigned char *)(Usb_Base_Address + Usb_Data_Address);
    int delay;
    U8 datavalue;

    // Write the value to the data register.
    datavalue = * dataregister;
    for(delay = 0; delay < 24; delay++)
    {
    }
    return(datavalue);
}

//****************************************************************************
//
// USBWriteEndpoint writes data to the specified endpoint.
//
//****************************************************************************
void USBWriteEndpoint(unsigned long ulEndpoint, const unsigned char **ppucData,
                 unsigned long *pulLength)
{
    U32 ulIdx, ulLength;

    // Determine the size of the packet to be sent based on the endpoint.
    if(ulEndpoint == USB_ENDPOINT_CONTROL_IN)
    {
        // The maximum packet size for the control endpoint is 16.
        ulLength = (*pulLength > 16) ? 16 : *pulLength;
    }
    else
    {
        // The maxmium packet size for the bulk endpoint is 64.
         ulLength = (*pulLength > 64) ? 64 : *pulLength;
    }
    // Select the appropriate endpoint.
    USBWriteCommand(USB_COMMAND_SELECT_ENDPOINT + ulEndpoint);

    // Send the write buffer command.
    USBWriteCommand(USB_COMMAND_WRITE_BUFFER);

    // Write the reserved byte to the buffer.
    USBWriteData(0);

    // Write the length of the data packet.
    USBWriteData(ulLength);

    // Write the data into the transmit buffer.
    for(ulIdx = 0; ulIdx < ulLength; ulIdx++)
    {
        USBWriteData(*(*ppucData)++);
    }

    //
    // Decrement the count of bytes to write.
    *pulLength -= ulLength;


    // Send the validate buffer command so that the endpoint will transmit the packet.
    USBWriteCommand(USB_COMMAND_VALIDATE_BUFFER);
}

//****************************************************************************
//
// USBReadEndpoint reads data from the specified endpoint.
//
//****************************************************************************
unsigned long
USBReadEndpoint(unsigned long ulEndpoint, unsigned char **ppucData,unsigned long *pulLength)
{
    U32 ulIdx, ulLength;
     
    // Select the appropriate endpoint.
    USBWriteCommand(USB_COMMAND_SELECT_ENDPOINT + ulEndpoint);

    // Is there buffer space to fill with this data or should we throw the data away?
    if(*pulLength)
    {    // Send the read buffer command.
       USBWriteCommand(USB_COMMAND_READ_BUFFER);
        // Throw away the reserved byte from the beginning of the buffer.

        USBReadData();
        // Read the length of the data buffer.
        ulLength = USBReadData();
        // Read the data into the receive buffer.
        for(ulIdx = 0; (ulIdx < ulLength) && (ulIdx < *pulLength); ulIdx++)
        {
            *(*ppucData)++ = USBReadData();
        }

        // Decrement the count of bytes to read.
        *pulLength -= ulIdx;
    }  
    // Send the clear buffer command so that the endpoint can receive another packet.
    USBWriteCommand(USB_COMMAND_CLEAR_BUFFER);

    // Return the size of the packet received.
    return(ulLength);
}

//****************************************************************************
//
// USBSendACK transmits a block of data back to the host via the bulk
// endpoint 1.
//
//****************************************************************************
unsigned long
USBSendACK(const unsigned char *pucData, unsigned long ulLength)
{
    // If a block is already being transmitted, then return a failure.
     if(sUSB.ulACKInCount)
    {
        return(0);
    }
    // Prepare to transmit this block back to the host.
    sUSB.pucACKIn = pucData;
    sUSB.ulACKInCount = ulLength;

    // Send the first packet of this block back to the host.
    USBWriteEndpoint(USB_ENDPOINT_ACK_IN, &sUSB.pucACKIn,&sUSB.ulACKInCount);
    return(1);
}

//****************************************************************************
//
// USBReserved handles device requests which are not supported by this USB
// device implementation.
//
//****************************************************************************
void USBReserved(void)
{
    // Stall both control endpoints.
    USBStallEndpoint(USB_ENDPOINT_CONTROL_OUT, 1);
    USBStallEndpoint(USB_ENDPOINT_CONTROL_IN, 1);
}

//****************************************************************************
//
// USBStallEndpoint stalls or un-stalls the specified endpoint.
//
//****************************************************************************
void USBStallEndpoint(unsigned long ulEndpoint, unsigned long bStall)
{
    //
    // Send the appropriate set endpoint status command to the PDIUSBD12.
    //
    USBWriteCommand(USB_COMMAND_SET_ENDPOINT_STATUS + ulEndpoint);
    USBWriteData(bStall ? 1 : 0);
}

//****************************************************************************
//
// USBGetStatus implements the USB Get_Status device request.
//
//****************************************************************************
void USBGetStatus(void)
{
    U8 ucStatus[2];
    U32 ulEndpoint;
    // Determine how to handle this request based on the recipient.

    switch(sUSB.sControlOut.bmRequestType & USB_RT_RECIPIENT_MASK)
    {
        // If the recipient is a device, return the state of the device's
        // remote wakeup and self powered states.
         case USB_RT_RECIPIENT_DEVICE:
        {
            // The player is self powered and does not support remote wakeup.
            ucStatus[0] = USB_DEVICE_STATUS_SELF_POWERED;
            ucStatus[1] = 0;

            // Send our response back to the host.
            USBSendControl(ucStatus, 2);

            // We're done handling this request.
             break;
        }
        // If the recipient is a device interface, return a value of
        // 0x00 as required by the USB spec.
        case USB_RT_RECIPIENT_INTERFACE:
        {
       // The USB spec. requires a GetStatus request for an interface return a pair of zero bytes.
            ucStatus[0] = 0;
            ucStatus[1] = 0;
            // Send our response back to the host.
            USBSendControl(ucStatus, 2);

            // We're done handling this request.
            break;
        }

        //
        // If the recipient is an endpoint, determine whether it is stalled or
        // not and return that information to the host.
        //
        case USB_RT_RECIPIENT_ENDPOINT:
        {
            // Find out which endpoint is the recipient of the request.
            ulEndpoint = sUSB.sControlOut.wIndex & USB_ENDPOINT_ADDRESS_MASK;
            // Determine whether the IN or the OUT endpoint is being addressed
            // in the device request.
            ulEndpoint *= 2;
            if(sUSB.sControlOut.wIndex & USB_ENDPOINT_DIRECTION_MASK)
            {
                ulEndpoint++;
            }

            // Read the endpoint status.
            USBWriteCommand(USB_COMMAND_SELECT_ENDPOINT);
            ulEndpoint = USBReadData();

            // Send the endpoint's status to the host.
            if(ulEndpoint & USB_ENDPOINT_STALL)
            {
                ucStatus[0] = USB_ENDPOINT_STATUS_STALLED;
            }
            else
            {
                ucStatus[0] = 0;
            }
            ucStatus[1] = 0;

            // Send our response back to the host.
            USBSendControl(ucStatus, 2);

            // We're done handling this request.
            break;
        }
        // If an invalid request is received, stall the control endpoint.

        default:
        {
            // Stall the both control endpoints.
            USBStallEndpoint(USB_ENDPOINT_CONTROL_OUT, 1);
            USBStallEndpoint(USB_ENDPOINT_CONTROL_IN, 1);

            // We're done handling this request.
            break;
        }
    }
}

//****************************************************************************
//
// USBSendControl transmits a block of data back to the host via the control
// endpoint.
//
//****************************************************************************
unsigned long
USBSendControl(const unsigned char *pucData, unsigned long ulLength)
{
    // If a block is already being transmitted, then return a failure.
    if(sUSB.ulControlInCount)
    {
        return(0);
    }
    // Prepare to transmit this block back to the host.
    sUSB.pucControlIn = pucData;
    sUSB.ulControlInCount = ulLength;

    // Send the first packet of this block back to the host.
     USBWriteEndpoint(USB_ENDPOINT_CONTROL_IN, &sUSB.pucControlIn,&sUSB.ulControlInCount);
    return(1);
}

//****************************************************************************
//
// USBClearFeature implements the USB Clear_Feature device request.
//
//****************************************************************************
void USBClearFeature(void)
{
    U32 ulEndpoint;

    // The only feature we support is stall on an endpoint.
   if(((sUSB.sControlOut.bmRequestType & USB_RT_RECIPIENT_MASK) == USB_RT_RECIPIENT_ENDPOINT) &&
       (sUSB.sControlOut.wValue == USB_FEATURE_ENDPOINT_STALL))
    {
        // Compute the endpoint number.
        ulEndpoint = (sUSB.sControlOut.wIndex & USB_ENDPOINT_ADDRESS_MASK) * 2;
        if(sUSB.sControlOut.wIndex & USB_ENDPOINT_DIRECTION_MASK)
        {
            ulEndpoint++;
        }

        // Clear the stall condition on the specified endpoint.
        USBStallEndpoint(ulEndpoint, 0);
    }
    else
    {
        // An unknown feature was specified, so stall both control endpoints.
        USBStallEndpoint(USB_ENDPOINT_CONTROL_OUT, 1);
        USBStallEndpoint(USB_ENDPOINT_CONTROL_IN, 1);
    }
}