//------------------------------------------------------------------------------ /// Handles CDC-specific SETUP requests. Should be called from a /// re-implementation of USBDCallbacks_RequestReceived() method. /// \param Pointer to a USBGenericRequest instance. //------------------------------------------------------------------------------ void CDCDSerialDriver_RequestHandler(const USBGenericRequest *request) { TRACE_INFO_WP("NewReq "); // Handle the request switch (USBGenericRequest_GetRequest(request)) { case CDCGenericRequest_SETLINECODING: CDCDSerialDriver_SetLineCoding(); break; case CDCGenericRequest_GETLINECODING: CDCDSerialDriver_GetLineCoding(); break; case CDCGenericRequest_SETCONTROLLINESTATE: CDCDSerialDriver_SetControlLineState( CDCSetControlLineStateRequest_ActivateCarrier(request), CDCSetControlLineStateRequest_IsDtePresent(request)); break; default: USBDDriver_RequestHandler(&(cdcdSerialDriver.usbdDriver), request); break; } }
//----------------------------------------------------------------------------- /// Handles composite-specific USB requests sent by the host, and forwards /// standard ones to the USB device driver. /// \param request Pointer to a USBGenericRequest instance. //----------------------------------------------------------------------------- void MULTIDriver_RequestHandler(const USBGenericRequest *request) { // Check if this is a class request if (USBGenericRequest_GetType(request) == USBGenericRequest_CLASS) { unsigned char rc = 0; //rc = CCID_RequestHandler(request); if (!rc) { TRACE_WARNING( "MULTIDriver_RequestHandler: Unsupported request (%d)\n\r", USBGenericRequest_GetRequest(request)); USBD_Stall(0); } } // Check if this is a standard request else if (USBGenericRequest_GetType(request) == USBGenericRequest_STANDARD) { unsigned char rc = 0; // Forward request to the standard handler if (rc == 0) USBDDriver_RequestHandler(&(usbdDriver), request); } // Unsupported request type else { TRACE_WARNING( "MULTIDriver_RequestHandler: Unsupported request type (%d)\n\r", USBGenericRequest_GetType(request)); USBD_Stall(0); } }
/** * Handles composite-specific USB requests sent by the host, and forwards * standard ones to the USB device driver. * \param request Pointer to a USBGenericRequest instance. */ void DUALCDCDDriver_RequestHandler(const USBGenericRequest *request) { CDCDSerialPort *pCdcd = 0; USBDDriver *pUsbd = 0; uint32_t rc, i; TRACE_INFO_WP("NewReq "); for (i = 0; i < NUM_PORTS; i ++) { pCdcd = &dualcdcdDriver.cdcdSerialPort[i]; rc = CDCDSerialPort_RequestHandler(pCdcd, request); if (rc == USBRC_SUCCESS) break; } /* Not handled by CDC Serial */ if (rc != USBRC_SUCCESS) { if (USBGenericRequest_GetType(request) == USBGenericRequest_STANDARD) { pUsbd = pCdcd->pUsbd; USBDDriver_RequestHandler(pUsbd, request); } else { TRACE_WARNING( "DUALCDCDDriver_RequestHandler: Unsupported request (%d,%d)\n\r", USBGenericRequest_GetType(request), USBGenericRequest_GetRequest(request)); USBD_Stall(0); } } }
/** * Handles audio-specific USB requests sent by the host, and forwards * standard ones to the USB device driver. * \param request Pointer to a USBGenericRequest instance. */ void AUDDSpeakerDriver_RequestHandler(const USBGenericRequest *request) { AUDDSpeakerDriver *pAudd = &auddSpeakerDriver; AUDDSpeakerPhone *pAudf = &pAudd->fun; USBDDriver *pUsbd = pAudf->pUsbd; TRACE_INFO_WP("NewReq "); /* Handle Audio Class requests */ if (AUDDSpeakerPhone_RequestHandler(pAudf, request) == USBRC_SUCCESS) { return; } /* Handle STD requests */ if (USBGenericRequest_GetType(request) == USBGenericRequest_STANDARD) { USBDDriver_RequestHandler(pUsbd, request); } /* Unsupported request */ else { TRACE_WARNING( "AUDDSpeakerDriver_RequestHandler: Unsupported request (%d,%x)\n\r", USBGenericRequest_GetType(request), USBGenericRequest_GetRequest(request)); USBD_Stall(0); } }
void fastsource_req_hdlr(const USBGenericRequest *request) { unsigned char entity; unsigned char interface; switch (USBGenericRequest_GetType(request)) { case USBGenericRequest_STANDARD: USBDDriver_RequestHandler(&fast_source_driver, request); return; case USBGenericRequest_CLASS: /* continue below */ break; default: TRACE_WARNING("Unsupported request type %u\n\r", USBGenericRequest_GetType(request)); USBD_Stall(0); return; } switch (USBGenericRequest_GetRequest(request)) { case AUDGenericRequest_SETCUR: entity = AUDGenericRequest_GetEntity(request); interface = AUDGenericRequest_GetInterface(request); if (((entity == AUDDLoopRecDriverDescriptors_FEATUREUNIT) || (entity == AUDDLoopRecDriverDescriptors_FEATUREUNIT_REC)) && (interface == AUDDLoopRecDriverDescriptors_CONTROL)) { fastsource_set_feat_cur_val(entity, AUDFeatureUnitRequest_GetChannel(request), AUDFeatureUnitRequest_GetControl(request), USBGenericRequest_GetLength(request)); } else { TRACE_WARNING("Unsupported entity/interface combination 0x%04x\n\r", USBGenericRequest_GetIndex(request)); USBD_Stall(0); } break; case AUDGenericRequest_GETCUR: entity = AUDGenericRequest_GetEntity(request); interface = AUDGenericRequest_GetInterface(request); if (((entity == AUDDLoopRecDriverDescriptors_FEATUREUNIT) || (entity == AUDDLoopRecDriverDescriptors_FEATUREUNIT_REC)) && (interface == AUDDLoopRecDriverDescriptors_CONTROL)) { fastsource_get_feat_cur_val(entity, AUDFeatureUnitRequest_GetChannel(request), AUDFeatureUnitRequest_GetControl(request), USBGenericRequest_GetLength(request)); } else { TRACE_WARNING("Unsupported entity/interface combination 0x%04x\n\r", USBGenericRequest_GetIndex(request)); USBD_Stall(0); } break; default: TRACE_WARNING("Unsupported request %u\n\r", USBGenericRequest_GetIndex(request)); USBD_Stall(0); break; } }
/** * Handler for incoming SETUP requests on default Control endpoint 0. * * Standard requests are forwarded to the USBDDriver_RequestHandler * method. * \param pMsdDriver Pointer to MSDDriver instance. * \param request Pointer to a USBGenericRequest instance */ void MSDDriver_RequestHandler( const USBGenericRequest *request) { USBDDriver *pUsbd = USBD_GetDriver(); TRACE_INFO_WP("NewReq "); if (MSDFunction_RequestHandler(request)) USBDDriver_RequestHandler(pUsbd, request); }
/** * Handles composite-specific USB requests sent by the host, and forwards * standard ones to the USB device driver. * \param request Pointer to a USBGenericRequest instance. */ void HIDAUDDDriver_RequestHandler(const USBGenericRequest *request) { USBDDriver *pUsbd = USBD_GetDriver(); TRACE_INFO_WP("NewReq "); if (HIDDKeyboard_RequestHandler(request) == USBRC_SUCCESS) return; if (AUDDFunction_RequestHandler(request) == USBRC_SUCCESS) return; USBDDriver_RequestHandler(pUsbd, request); }
/** * Handles CDCMSD-specific USB requests sent by the host, and forwards * standard ones to the USB device driver. * \param request Pointer to a USBGenericRequest instance. */ void CDCMSDDriver_RequestHandler(const USBGenericRequest *request) { USBDDriver *pUsbd = USBD_GetDriver(); TRACE_INFO_WP("NewReq "); if (CDCDSerial_RequestHandler(request) == USBRC_SUCCESS) return; if (MSDFunction_RequestHandler(request) == USBRC_SUCCESS) return; USBDDriver_RequestHandler(pUsbd, request); }
/** * Handles HID-specific SETUP request sent by the host. * \param request Pointer to a USBGenericRequest instance */ void HIDDMouseDriver_RequestHandler(const USBGenericRequest *request) { HIDDMouseDriver * pMouse = &hiddMouseDriver; HIDDFunction * pHidd = &pMouse->hidDrv; USBDDriver * pUsbd = pHidd->pUsbd; TRACE_INFO("NewReq "); /* Process HID requests */ if (USBRC_SUCCESS == HIDDFunction_RequestHandler(pHidd, request)) { return; } /* Process STD requests */ else { USBDDriver_RequestHandler(pUsbd, request); } }
//----------------------------------------------------------------------------- /// Handler for incoming SETUP requests on default Control endpoint 0. /// /// Standard requests are forwarded to the USBDDriver_RequestHandler /// method. /// \param request Pointer to a USBGenericRequest instance //----------------------------------------------------------------------------- void MSDDriver_RequestHandler(const USBGenericRequest *request) { TRACE_INFO_WP("NewReq "); // Handle requests switch (USBGenericRequest_GetRequest(request)) { //--------------------- case USBGenericRequest_CLEARFEATURE: //--------------------- TRACE_INFO_WP("ClrFeat "); switch (USBFeatureRequest_GetFeatureSelector(request)) { //--------------------- case USBFeatureRequest_ENDPOINTHALT: //--------------------- TRACE_INFO_WP("Hlt "); // Do not clear the endpoint halt status if the device is waiting // for a reset recovery sequence if (!msdDriver.waitResetRecovery) { // Forward the request to the standard handler USBDDriver_RequestHandler(&usbdDriver, request); } else { TRACE_INFO_WP("No "); } USBD_Write(0, 0, 0, 0, 0); break; //------ default: //------ // Forward the request to the standard handler USBDDriver_RequestHandler(&usbdDriver, request); } break; //------------------- case MSD_GET_MAX_LUN: //------------------- TRACE_INFO_WP("gMaxLun "); // Check request parameters if ((request->wValue == 0) && (request->wIndex == 0) && (request->wLength == 1)) { USBD_Write(0, &(msdDriver.maxLun), 1, 0, 0); } else { TRACE_WARNING( "MSDDriver_RequestHandler: GetMaxLUN(%d,%d,%d)\n\r", request->wValue, request->wIndex, request->wLength); USBD_Stall(0); } break; //----------------------- case MSD_BULK_ONLY_RESET: //----------------------- TRACE_INFO_WP("Rst "); // Check parameters if ((request->wValue == 0) && (request->wIndex == 0) && (request->wLength == 0)) { // Reset the MSD driver MSDDriver_Reset(); USBD_Write(0, 0, 0, 0, 0); } else { TRACE_WARNING( "MSDDriver_RequestHandler: Reset(%d,%d,%d)\n\r", request->wValue, request->wIndex, request->wLength); USBD_Stall(0); } break; //------ default: //------ // Forward request to standard handler USBDDriver_RequestHandler(&usbdDriver, request); break; } }
/** * Handler for incoming SETUP requests on default Control endpoint 0. * * Standard requests are forwarded to the USBDDriver_RequestHandler * method. * \param pMsdDriver Pointer to MSDDriver instance. * \param request Pointer to a USBGenericRequest instance */ uint32_t MSDFunction_RequestHandler( const USBGenericRequest *request) { MSDDriver *pMsdDriver = &msdFunction; uint32_t reqCode = (USBGenericRequest_GetType(request) << 8) | (USBGenericRequest_GetRequest(request)); TRACE_INFO_WP("Msdf "); /* Handle requests */ switch (reqCode) { /*--------------------- */ case USBGenericRequest_CLEARFEATURE: /*--------------------- */ TRACE_INFO_WP("ClrFeat "); switch (USBFeatureRequest_GetFeatureSelector(request)) { /*--------------------- */ case USBFeatureRequest_ENDPOINTHALT: /*--------------------- */ TRACE_INFO_WP("Hlt "); /* Do not clear the endpoint halt status if the device is waiting */ /* for a reset recovery sequence */ if (!pMsdDriver->waitResetRecovery) { /* Forward the request to the standard handler */ USBDDriver_RequestHandler(USBD_GetDriver(), request); } else { TRACE_INFO_WP("No "); } USBD_Write(0, 0, 0, 0, 0); return USBRC_SUCCESS; /* Handled */ } break; /*------------------- */ case (USBGenericRequest_CLASS<<8)|MSD_GET_MAX_LUN: /*------------------- */ TRACE_INFO_WP("gMaxLun "); /* Check request parameters */ if ((request->wValue == 0) && (request->wIndex == pMsdDriver->interfaceNb) && (request->wLength == 1)) { USBD_Write(0, &(pMsdDriver->maxLun), 1, 0, 0); } else { TRACE_WARNING( "MSDDriver_RequestHandler: GetMaxLUN(%d,%d,%d)\n\r", request->wValue, request->wIndex, request->wLength); USBD_Stall(0); } return USBRC_SUCCESS; /* Handled */ /*----------------------- */ case (USBGenericRequest_CLASS<<8)|MSD_BULK_ONLY_RESET: /*----------------------- */ TRACE_INFO_WP("Rst "); /* Check parameters */ if ((request->wValue == 0) && (request->wIndex == pMsdDriver->interfaceNb) && (request->wLength == 0)) { /* Reset the MSD driver */ MSDFunction_Reset(); USBD_Write(0, 0, 0, 0, 0); } else { TRACE_WARNING( "MSDDriver_RequestHandler: Reset(%d,%d,%d)\n\r", request->wValue, request->wIndex, request->wLength); USBD_Stall(0); } return USBRC_SUCCESS; /* Handled */ } return USBRC_PARAM_ERR; }
//------------------------------------------------------------------------------ /// Handles audio-specific USB requests sent by the host, and forwards /// standard ones to the USB device driver. /// \param request Pointer to a USBGenericRequest instance. //------------------------------------------------------------------------------ void AUDDSpeakerDriver_RequestHandler(const USBGenericRequest *request) { unsigned char entity; unsigned char interface; TRACE_INFO_WP("NewReq "); // Check if this is a class request if (USBGenericRequest_GetType(request) == USBGenericRequest_CLASS) { // Check if the request is supported switch (USBGenericRequest_GetRequest(request)) { case AUDGenericRequest_SETCUR: TRACE_INFO_WP( "sCur(0x%04X) ", USBGenericRequest_GetIndex(request)); // Check the target interface and entity entity = AUDGenericRequest_GetEntity(request); interface = AUDGenericRequest_GetInterface(request); if ((entity == AUDDSpeakerDriverDescriptors_FEATUREUNIT) && (interface == AUDDSpeakerDriverDescriptors_CONTROL)) { AUDDSpeakerDriver_SetFeatureCurrentValue( entity, AUDFeatureUnitRequest_GetChannel(request), AUDFeatureUnitRequest_GetControl(request), USBGenericRequest_GetLength(request)); } else { TRACE_WARNING( "AUDDSpeakerDriver_RequestHandler: Unsupported entity/interface combination (0x%04X)\n\r", USBGenericRequest_GetIndex(request)); USBD_Stall(0); } break; case AUDGenericRequest_GETCUR: TRACE_INFO_WP( "gCur(0x%04X) ", USBGenericRequest_GetIndex(request)); // Check the target interface and entity entity = AUDGenericRequest_GetEntity(request); interface = AUDGenericRequest_GetInterface(request); if ((entity == AUDDSpeakerDriverDescriptors_FEATUREUNIT) && (interface == AUDDSpeakerDriverDescriptors_CONTROL)) { AUDDSpeakerDriver_GetFeatureCurrentValue( entity, AUDFeatureUnitRequest_GetChannel(request), AUDFeatureUnitRequest_GetControl(request), USBGenericRequest_GetLength(request)); } else { TRACE_WARNING( "AUDDSpeakerDriver_RequestHandler: Unsupported entity/interface combination (0x%04X)\n\r", USBGenericRequest_GetIndex(request)); USBD_Stall(0); } break; default: TRACE_WARNING( "AUDDSpeakerDriver_RequestHandler: Unsupported request (%d)\n\r", USBGenericRequest_GetRequest(request)); USBD_Stall(0); } } // Check if this is a standard request else if (USBGenericRequest_GetType(request) == USBGenericRequest_STANDARD) { // Forward request to the standard handler USBDDriver_RequestHandler(&(auddSpeakerDriver.usbdDriver), request); } // Unsupported request type else { TRACE_WARNING( "AUDDSpeakerDriver_RequestHandler: Unsupported request type (%d)\n\r", USBGenericRequest_GetType(request)); USBD_Stall(0); } }
/** * Handles HID-specific SETUP request sent by the host. * \param request Pointer to a USBGenericRequest instance */ void HIDDTransferDriver_RequestHandler(const USBGenericRequest *request) { HIDDTransferDriver *pDrv = &hiddTransferDriver; HIDDFunction *pHidd = &pDrv->hidFunction; 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(pHidd->pUsbd, request); } return; /* Handled, no need to do others */ case USBGenericRequest_CLEARFEATURE: /* Check which is the requested feature */ switch (USBFeatureRequest_GetFeatureSelector(request)) { case USBFeatureRequest_ENDPOINTHALT: { uint8_t ep = USBGenericRequest_GetEndpointNumber(request); if (USBD_IsHalted(ep)) { /* Unhalt endpoint restart OUT EP */ USBD_Unhalt(ep); if (ep == pHidd->bPipeOUT) { HIDDFunction_StartPollingOutputs(pHidd); } } /* and send a zero-length packet */ USBD_Write(0, 0, 0, 0, 0); return; /* Handled, no need to do others */ } } break; } } /* We use different buffer for SetReport */ else if (USBGenericRequest_GetType(request) == USBGenericRequest_CLASS) { switch (USBGenericRequest_GetRequest(request)) { case HIDGenericRequest_SETREPORT: { uint16_t length = USBGenericRequest_GetLength(request); uint8_t type = HIDReportRequest_GetReportType(request); if (type == HIDReportRequest_OUTPUT) { if (length > HIDDTransferDriver_REPORTSIZE) length = HIDDTransferDriver_REPORTSIZE; USBD_Read(0, pDrv->iReportBuf, length, HIDDTransferDriver_ReportReceived, 0); /* No argument to the callback function */ } else { USBD_Stall(0); } } return; /* Handled, no need do others */ } } /* Process HID requests */ if (USBRC_SUCCESS == HIDDFunction_RequestHandler(pHidd, request)) { return; } else USBDDriver_RequestHandler(pHidd->pUsbd, request); }
/** * Invoked whenever a SETUP request is received from the host. Forwards the * request to the standard handler. */ void USBDCallbacks_RequestReceived(const USBGenericRequest *request) { USBDDriver_RequestHandler(&usbdDriver, request); }
/** * USBDCallbacks_RequestReceived - Invoked when a new SETUP request is * received. Does nothing by default. * \param request Pointer to the request to handle. */ WEAK void USBDCallbacks_RequestReceived(const USBGenericRequest *request) { /* Does basic enumeration */ USBDDriver_RequestHandler(USBD_GetDriver(), request); }