hiddtransferdriver.c

本代bootloader通过usb下载代码首先存放在sdram中

//------------------------------------------------------------------------------
/// Callback function when configureation changed
/// \param cfgnum New configuration number
//------------------------------------------------------------------------------
void USBDDriverCallbacks_ConfigurationChanged(unsigned char cfgnum)
{
    if (cfgnum > 0) {

        hiddTransferDriver.iLen = 0;
        USBD_Read(HIDDTransferDriverDescriptors_INTERRUPTOUT,
                  hiddTransferDriver.iBuf,
                  HIDDTransferDriver_REPORTSIZE,
                  HIDDTransferDriver_DataReceived,
                  0);
    }
}

//------------------------------------------------------------------------------
//      Exported functions
//------------------------------------------------------------------------------


//------------------------------------------------------------------------------
/// Initializes the HID Transfer %device driver.
//------------------------------------------------------------------------------
void HIDDTransferDriver_Initialize()
{
    hiddTransferDriver.iReportLen = 0;

    USBDDriver_Initialize(&(hiddTransferDriver.usbdDriver),
                          &hiddTransferDriverDescriptors,
                          0); // Multiple interface settings not supported
    USBD_Init();
}

//------------------------------------------------------------------------------
/// Handles HID-specific SETUP request sent by the host.
/// \param request Pointer to a USBGenericRequest instance
//------------------------------------------------------------------------------
void HIDDTransferDriver_RequestHandler(const USBGenericRequest *request)
{
    TRACE_INFO("NewReq ");

    // Check if this is a standard request
    if (USBGenericRequest_GetType(request) == USBGenericRequest_STANDARD) {

        // This is a standard request
        switch (USBGenericRequest_GetRequest(request)) {
        
            case USBGenericRequest_GETDESCRIPTOR:
                // Check if this is a HID descriptor, otherwise forward it to
                // the standard driver
                if (!HIDDTransferDriver_GetDescriptor(
                        USBGetDescriptorRequest_GetDescriptorType(request),
                        USBGenericRequest_GetLength(request))) {

                    USBDDriver_RequestHandler(&(hiddTransferDriver.usbdDriver),
                                              request);
                }
                break;

            default:
                USBDDriver_RequestHandler(&(hiddTransferDriver.usbdDriver),
                                              request);
        }
    }
    // Check if this is a class request
    else if (USBGenericRequest_GetType(request) == USBGenericRequest_CLASS) {

        unsigned short length = USBGenericRequest_GetLength(request);
        unsigned char type = HIDReportRequest_GetReportType(request);

        switch (USBGenericRequest_GetRequest(request)) {

            case HIDGenericRequest_SETREPORT:

                if (length <= HIDDTransferDriver_REPORTSIZE &&
                    type == HIDReportRequest_OUTPUT) {

                    USBD_Read(0,
                              hiddTransferDriver.iReportBuf,
                              length,
                              HIDDTransferDriver_ReportReceived,
                              0); // No argument to the callback function
                }
                else {

                    USBD_Stall(0);
                }
                break;

            default:
                TRACE_WARNING(
                      "HIDDTransferDriver_RequestHandler: request 0x%02X\n\r",
                      USBGenericRequest_GetRequest(request));
                USBD_Stall(0);
        }
    }
    else {

        // Vendor request ?
        USBD_Stall(0);
    }
}

//------------------------------------------------------------------------------
/// Try to read request buffer of SetReport.
/// Set pData to 0 to get current data length only.
/// \param pData Pointer to data buffer
/// \param dLength Data buffer length
/// \return Number of bytes read
//------------------------------------------------------------------------------
unsigned short HIDDTransferDriver_ReadReport(void *pData,
                                             unsigned int dLength)
{
    if (pData == 0) {

        return hiddTransferDriver.iReportLen;
    }

    if (dLength > HIDDTransferDriver_REPORTSIZE) {

        dLength = HIDDTransferDriver_REPORTSIZE;
    }
    if (dLength > hiddTransferDriver.iReportLen) {

        dLength = hiddTransferDriver.iReportLen;
    }
    hiddTransferDriver.iReportLen = 0;
    memcpy(pData, hiddTransferDriver.iReportBuf, dLength);

    return dLength;
}

//------------------------------------------------------------------------------
/// Try to read request buffer of interrupt OUT EP.
/// Set pData to 0 to get current data length only.
/// \param pData Pointer to data buffer
/// \param dLength Data buffer length
/// \return Number of bytes read
//------------------------------------------------------------------------------
unsigned short HIDDTransferDriver_Read(void *pData,
                                       unsigned int dLength)
{
    if (pData == 0) {

        return hiddTransferDriver.iLen;
    }

    if (dLength > HIDDTransferDriver_REPORTSIZE) {

        dLength = HIDDTransferDriver_REPORTSIZE;
    }
    if (dLength > hiddTransferDriver.iLen) {

        dLength = hiddTransferDriver.iLen;
    }
    hiddTransferDriver.iLen = 0;
    memcpy(pData, hiddTransferDriver.iBuf, dLength);

    return dLength;
}

//------------------------------------------------------------------------------
/// Write data through USB interrupt IN EP.
/// \param pData Pointer to the data sent.
/// \param dLength The data length.
/// \param fCallback Callback function invoked when transferring done.
/// \param pArg Pointer to additional arguments.
//------------------------------------------------------------------------------
unsigned char HIDDTransferDriver_Write(const void *pData,
                                       unsigned int dLength,
                                       TransferCallback fCallback,
                                       void *pArg)
{
    if (dLength != HIDDTransferDriver_REPORTSIZE) {

        dLength = HIDDTransferDriver_REPORTSIZE;
    }
    return USBD_Write(HIDDTransferDriverDescriptors_INTERRUPTIN,
                      pData, dLength,
                      fCallback, pArg);
}

//------------------------------------------------------------------------------
/// Starts a remote wake-up sequence if the host has explicitely enabled it
/// by sending the appropriate SET_FEATURE request.
//------------------------------------------------------------------------------
void HIDDTransferDriver_RemoteWakeUp(void)
{
    // Remote wake-up has been enabled
    if (USBDDriver_IsRemoteWakeUpEnabled(&(hiddTransferDriver.usbdDriver))) {

        USBD_RemoteWakeUp();
    }
}