USBWriteCommand(USB_COMMAND_SET_MODE);
    USBWriteData(USB_CONFIG1_NO_LAZY_CLOCK | USB_CONFIG1_CLOCK_RUNNING |
                 USB_CONFIG1_SOFT_CONNECT);
    USBWriteData(USB_CONFIG2_SET_TO_ONE | USB_CONFIG2_CLOCK_12M);
    Uart_Printf("USB ON\n");
    Uart_Printf("Your PC will add the new USB\n");
    Uart_Printf("Press any key ,close USB and exit\n");
    USBEnable();
    do{
    	USBISRPOLLING(0);
    }
    while(!Uart_GetKey());
    USBOFF();
    rSYSCFG=saveSyscfg;
}

void USBOFF(void)
{
    USBWriteCommand(USB_COMMAND_SEND_RESUME);
    Delay(10000);
    USBWriteCommand(USB_COMMAND_SET_ADDRESS_ENABLE);
    USBWriteData(0);
    
    USBWriteCommand(USB_COMMAND_SET_ENDPOINT_ENABLE);
    USBWriteData(0);
    //
    // Enable the interrupts for the bulk endpoints.
    //
    USBWriteCommand(USB_COMMAND_SET_DMA);
    USBWriteData(USB_DMA_ENDP4_INT_ENABLE | USB_DMA_ENDP5_INT_ENABLE);
     
    USBWriteCommand(USB_COMMAND_SET_MODE);
    USBWriteData(0);
    USBWriteData(USB_CONFIG2_SET_TO_ONE | USB_CONFIG2_CLOCK_12M);
 }

//****************************************************************************
//
// USBISR is the interrupt handler routine for the USB.
//
//****************************************************************************
void __irq USBISR(void)
{
    unsigned long ulIntStatus, ulTransactionStatus, ulLength,uSize;
    U8 *pucChar;

    
    // Read the PDIUSBD12 interrupt register.
    rI_ISPC=BIT_EINT0;	//clear pending_bit
    USBWriteCommand(USB_COMMAND_READ_INTERRUPT);
    ulIntStatus = USBReadData();
    ulIntStatus |= USBReadData() << 8;

    // Do nothing if there was a bus reset.
      if(ulIntStatus & USB_INT1_BUS_RESET)
    {
    	return;
    }
    // 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();
        //Uart_Printf("Status: %u\n",ulTransactionStatus);

        // 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.
        	uSize=USBReadEndpoint(USB_ENDPOINT_BULK_OUT, &sUSB.pucBulkOut, &sUSB.ulBulkOutCount);
        	//Uart_Printf("Size: %u\n",uSize);
        	Uart_Printf("usbbuffer0: %s\n",usbbuffer0);
        	Uart_Printf("usbbuffer1: %s\n",usbbuffer1);
        	Uart_Printf("usbbuffer2: %s\n",usbbuffer2);
         }
    }
    // 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;
        }