/** * @brief USBH_CDC_ClassRequest * The function is responsible for handling Standard requests * for CDC class. * @param phost: Host handle * @retval USBH Status */ static USBH_StatusTypeDef USBH_CDC_ClassRequest (USBH_HandleTypeDef *phost) { USBH_StatusTypeDef status = USBH_FAIL ; CDC_HandleTypeDef *CDC_Handle = (CDC_HandleTypeDef*) phost->pActiveClass->pData; /*Issue the get line coding request*/ status = GetLineCoding(phost, &CDC_Handle->LineCoding); if(status == USBH_OK) { phost->pUser(phost, HOST_USER_CLASS_ACTIVE); } return status; }
//***************************************************************************** // // Handles CDC driver notifications related to control and setup of the device. // // \param pvCBData is the client-supplied callback pointer for this channel. // \param ui32Event identifies the event we are being notified about. // \param ui32MsgValue is an event-specific value. // \param pvMsgData is an event-specific pointer. // // This function is called by the CDC driver to perform control-related // operations on behalf of the USB host. These functions include setting // and querying the serial communication parameters, setting handshake line // states and sending break conditions. // // \return The return value is event-specific. // //***************************************************************************** uint32_t ControlHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue, void *pvMsgData) { uint32_t ui32IntsOff; // // Which event are we being asked to process? // switch(ui32Event) { // // We are connected to a host and communication is now possible. // case USB_EVENT_CONNECTED: g_bUSBConfigured = true; // // Flush our buffers. // USBBufferFlush(&g_sTxBuffer); USBBufferFlush(&g_sRxBuffer); // // Tell the main loop to update the display. // ui32IntsOff = ROM_IntMasterDisable(); g_pcStatus = "Connected"; g_ui32Flags |= COMMAND_STATUS_UPDATE; if(!ui32IntsOff) { ROM_IntMasterEnable(); } break; // // The host has disconnected. // case USB_EVENT_DISCONNECTED: g_bUSBConfigured = false; ui32IntsOff = ROM_IntMasterDisable(); g_pcStatus = "Disconnected"; g_ui32Flags |= COMMAND_STATUS_UPDATE; if(!ui32IntsOff) { ROM_IntMasterEnable(); } break; // // Return the current serial communication parameters. // case USBD_CDC_EVENT_GET_LINE_CODING: GetLineCoding(pvMsgData); break; // // Set the current serial communication parameters. // case USBD_CDC_EVENT_SET_LINE_CODING: SetLineCoding(pvMsgData); break; // // Set the current serial communication parameters. // case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE: SetControlLineState((uint16_t)ui32MsgValue); break; // // Send a break condition on the serial line. // case USBD_CDC_EVENT_SEND_BREAK: SendBreak(true); break; // // Clear the break condition on the serial line. // case USBD_CDC_EVENT_CLEAR_BREAK: SendBreak(false); break; // // Ignore SUSPEND and RESUME for now. // case USB_EVENT_SUSPEND: case USB_EVENT_RESUME: break; // // We don't expect to receive any other events. Ignore any that show // up in a release build or hang in a debug build. // default: #ifdef DEBUG while(1); #else break; #endif } return(0); }
/** * @brief USBH_CDC_Process * The function is for managing state machine for CDC data transfers * @param phost: Host handle * @retval USBH Status */ static USBH_StatusTypeDef USBH_CDC_Process (USBH_HandleTypeDef *phost) { USBH_StatusTypeDef status = USBH_BUSY; USBH_StatusTypeDef req_status = USBH_OK; CDC_HandleTypeDef *CDC_Handle = (CDC_HandleTypeDef*) phost->pActiveClass->pData; switch(CDC_Handle->state) { case CDC_IDLE_STATE: status = USBH_OK; break; case CDC_SET_LINE_CODING_STATE: req_status = SetLineCoding(phost, CDC_Handle->pUserLineCoding); if(req_status == USBH_OK) { CDC_Handle->state = CDC_GET_LAST_LINE_CODING_STATE; } else if(req_status != USBH_BUSY) { CDC_Handle->state = CDC_ERROR_STATE; } break; case CDC_GET_LAST_LINE_CODING_STATE: req_status = GetLineCoding(phost, &(CDC_Handle->LineCoding)); if(req_status == USBH_OK) { CDC_Handle->state = CDC_IDLE_STATE; if((CDC_Handle->LineCoding.b.bCharFormat == CDC_Handle->pUserLineCoding->b.bCharFormat) && (CDC_Handle->LineCoding.b.bDataBits == CDC_Handle->pUserLineCoding->b.bDataBits) && (CDC_Handle->LineCoding.b.bParityType == CDC_Handle->pUserLineCoding->b.bParityType) && (CDC_Handle->LineCoding.b.dwDTERate == CDC_Handle->pUserLineCoding->b.dwDTERate)) { USBH_CDC_LineCodingChanged(phost); } } else if(req_status != USBH_BUSY) { CDC_Handle->state = CDC_ERROR_STATE; } break; case CDC_TRANSFER_DATA: CDC_ProcessTransmission(phost); CDC_ProcessReception(phost); break; case CDC_ERROR_STATE: req_status = USBH_ClrFeature(phost, 0x00); if(req_status == USBH_OK ) { /*Change the state to waiting*/ CDC_Handle->state = CDC_IDLE_STATE ; } break; default: break; } return status; }
//***************************************************************************** // // Handles CDC driver notifications related to control and setup of the device. // // \param pvCBData is the client-supplied callback pointer for this channel. // \param ulEvent identifies the event we are being notified about. // \param ulMsgValue is an event-specific value. // \param pvMsgData is an event-specific pointer. // // This function is called by the CDC driver to perform control-related // operations on behalf of the USB host. These functions include setting // and querying the serial communication parameters, setting handshake line // states and sending break conditions. // // \return The return value is event-specific. // //***************************************************************************** uint32_t ControlHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue, void *pvMsgData) { // // Which event are we being asked to process? // switch(ui32Event) { // // We are connected to a host and communication is now possible. // case USB_EVENT_CONNECTED: { // // Now connected and ready for normal operation. // HWREGBITW(&g_ui32Flags, FLAG_USB_CONFIGURED) = 1; // // Flush our buffers. // USBBufferFlush(&g_sTxBuffer); USBBufferFlush(&g_sRxBuffer); // // Tell the main loop to update the display. // g_pcStatus = "Host connected."; // // Set the command status update flag. // HWREGBITW(&g_ui32Flags, FLAG_STATUS_UPDATE) = 1; break; } // // The host has disconnected. // case USB_EVENT_DISCONNECTED: { // // No longer connected. // HWREGBITW(&g_ui32Flags, FLAG_USB_CONFIGURED) = 0; g_pcStatus = "Host disconnected."; // // Set the command status update flag. // HWREGBITW(&g_ui32Flags, FLAG_STATUS_UPDATE) = 1; break; } // // Return the current serial communication parameters. // case USBD_CDC_EVENT_GET_LINE_CODING: { GetLineCoding(pvMsgData, UART_CLOCK); break; } // // Set the current serial communication parameters. // case USBD_CDC_EVENT_SET_LINE_CODING: { SetLineCoding(pvMsgData, UART_CLOCK); break; } // // Set the current serial communication parameters. // case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE: { SetControlLineState((uint16_t)ui32MsgValue); break; } // // Send a break condition on the serial line. // case USBD_CDC_EVENT_SEND_BREAK: { SendBreak(true); break; } // // Clear the break condition on the serial line. // case USBD_CDC_EVENT_CLEAR_BREAK: { SendBreak(false); break; } // // Ignore SUSPEND and RESUME for now. // case USB_EVENT_SUSPEND: case USB_EVENT_RESUME: { break; } // // We don't expect to receive any other events. Ignore any that show // up in a release build or hang in a debug build. // default: { #ifdef DEBUG while(1); #else break; #endif } } return(0); }
//***************************************************************************** // // Handles CDC driver notifications related to control and setup of the device. // // \param pvCBData is the client-supplied callback pointer for this channel. // \param ulEvent identifies the notification event. // \param ulMsgValue is an event-specific value. // \param pvMsgData is an event-specific pointer. // // This function is called by the CDC driver to perform control-related // operations on behalf of the USB host. These functions include setting // and querying the serial communication parameters, setting handshake line // states and sending break conditions. // // \return The return value is event-specific. // //***************************************************************************** unsigned long ControlHandler(void *pvCBData, unsigned long ulEvent, unsigned long ulMsgValue, void *pvMsgData) { // // Which event was sent? // switch(ulEvent) { // // The host has connected. // case USB_EVENT_CONNECTED: { // // Turn on the user LED. // GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0, GPIO_PIN_0); // // Flush the buffers. // USBBufferFlush(&g_sTxBuffer); USBBufferFlush(&g_sRxBuffer); break; } // // The host has disconnected. // case USB_EVENT_DISCONNECTED: { // // Turn off the user LED. // GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0, 0); break; } // // Return the current serial communication parameters. // case USBD_CDC_EVENT_GET_LINE_CODING: { GetLineCoding(pvMsgData); break; } // // Set the current serial communication parameters. // case USBD_CDC_EVENT_SET_LINE_CODING: { SetLineCoding(pvMsgData); break; } // // Set the current serial communication parameters. // case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE: { break; } // // Send a break condition on the serial line. // case USBD_CDC_EVENT_SEND_BREAK: { SendBreak(true); break; } // // Clear the break condition on the serial line. // case USBD_CDC_EVENT_CLEAR_BREAK: { SendBreak(false); break; } // // Ignore SUSPEND and RESUME for now. // case USB_EVENT_SUSPEND: case USB_EVENT_RESUME: { break; } // // Other events can be safely ignored. // default: { break; } } return(0); }
//***************************************************************************** // // Handles CDC driver notifications related to control and setup of the device. // // \param pvCBData is the client-supplied callback pointer for this channel. // \param ulEvent identifies the notification event. // \param ulMsgValue is an event-specific value. // \param pvMsgData is an event-specific pointer. // // This function is called by the CDC driver to perform control-related // operations on behalf of the USB host. These functions include setting // and querying the serial communication parameters, setting handshake line // states and sending break conditions. // // \return The return value is event-specific. // //***************************************************************************** static unsigned long ControlHandler(void *pvCBData, unsigned long ulEvent, unsigned long ulMsgValue, void *pvMsgData) { // // Which event was sent? // switch(ulEvent) { // // The host has connected. // case USB_EVENT_CONNECTED: { // // Indicate that the USB is connected. // g_bUSBConnected = true; // // Flush the buffers. // USBBufferFlush(&g_sTxBuffer); USBBufferFlush(&g_sRxBuffer); break; } // // The host has disconnected. // case USB_EVENT_DISCONNECTED: { // // If USB is currently being used to play the game, then halt the // Z-machine interpreter. // if(g_ulGameIF == GAME_IF_USB) { halt = 1; } // // Indicate that the USB is no longer connected. // g_bUSBConnected = false; break; } // // Return the current serial communication parameters. // case USBD_CDC_EVENT_GET_LINE_CODING: { GetLineCoding(pvMsgData); break; } // // Set the current serial communication parameters. // case USBD_CDC_EVENT_SET_LINE_CODING: { break; } // // Set the current serial communication parameters. // case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE: { break; } // // Send a break condition on the serial line. // case USBD_CDC_EVENT_SEND_BREAK: { break; } // // Clear the break condition on the serial line. // case USBD_CDC_EVENT_CLEAR_BREAK: { break; } // // Ignore SUSPEND and RESUME for now. // case USB_EVENT_SUSPEND: case USB_EVENT_RESUME: { break; } // // Other events can be safely ignored. // default: { break; } } return(0); }
//***************************************************************************** // // Handles CDC driver notifications related to control and setup of the device. // // \param pvCBData is the client-supplied callback pointer for this channel. // \param ulEvent identifies the event we are being notified about. // \param ulMsgValue is an event-specific value. // \param pvMsgData is an event-specific pointer. // // This function is called by the CDC driver to perform control-related // operations on behalf of the USB host. These functions include setting // and querying the serial communication parameters, setting handshake line // states and sending break conditions. // // \return The return value is event-specific. // //***************************************************************************** unsigned long ControlHandler(void *pvCBData, unsigned long ulEvent, unsigned long ulMsgValue, void *pvMsgData) { // // Which event are we being asked to process? // switch(ulEvent) { // // We are connected to a host and communication is now possible. // case USB_EVENT_CONNECTED: { g_bUSBDevConnected = true; // // Flush our buffers. // USBBufferFlush(&g_sTxBuffer); USBBufferFlush(&g_sRxBuffer); break; } // // The host has disconnected. // case USB_EVENT_DISCONNECTED: { g_bUSBDevConnected = false; break; } // // Return the current serial communication parameters. // case USBD_CDC_EVENT_GET_LINE_CODING: { GetLineCoding(pvMsgData); break; } // // Set the current serial communication parameters. // case USBD_CDC_EVENT_SET_LINE_CODING: { SetLineCoding(pvMsgData); break; } // // The following line control events can be ignored because there is // no physical serial port to manage. // case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE: case USBD_CDC_EVENT_SEND_BREAK: case USBD_CDC_EVENT_CLEAR_BREAK: { break; } // // Ignore SUSPEND and RESUME for now. // case USB_EVENT_SUSPEND: case USB_EVENT_RESUME: { break; } // // An unknown event occurred. // default: { break; } } // // Return control to USB stack // return(0); }
unsigned long USB_ControlHandler(void *pvCBData, unsigned long ulEvent, unsigned long ulMsgValue, void *pvMsgData) { // // Which event are we being asked to process? // switch(ulEvent) { // // We are connected to a host and communication is now possible. // case USB_EVENT_CONNECTED: g_bUSBConfigured = true; // Flush our buffers. USBBufferFlush(&g_sTxBuffer); USBBufferFlush(&g_sRxBuffer); #ifdef __DEBUG__ UARTprintf("\nUSB Connected"); #ifdef __DEBUG_TRACEBACK__ UARTprintf(" File: %s Line: %d", __FILE__,__LINE__); #endif #endif break; // // The host has disconnected. // case USB_EVENT_DISCONNECTED: g_bUSBConfigured = false; #ifdef __DEBUG__ UARTprintf("\nUSB Disconnected"); #ifdef __DEBUG_TRACEBACK__ UARTprintf(" File: %s Line: %d", __FILE__,__LINE__); #endif #endif break; // // Return the current serial communication parameters. // case USBD_CDC_EVENT_GET_LINE_CODING: GetLineCoding(pvMsgData); break; case USBD_CDC_EVENT_SET_LINE_CODING: break; case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE: break; case USBD_CDC_EVENT_SEND_BREAK: break; case USBD_CDC_EVENT_CLEAR_BREAK: break; case USB_EVENT_SUSPEND: break; case USB_EVENT_RESUME: break; default: #ifdef DEBUG #else break; #endif } return(0); }
/****************************************************************************** * * * \brief Handles CDC driver notifications related to control and setup of * * the device.\n * * * * \param pvCBData is the client-supplied callback pointer for this channel. * * * * \param ulEvent identifies the event we are being notified about. * * * * \param ulMsgValue is an event-specific value. * * * * \param pvMsgData is an event-specific pointer. * * * * \return The return value is event-specific. * * * ******************************************************************************/ unsigned int ControlHandler(void *pvCBData, unsigned int ulEvent, unsigned int ulMsgValue, void *pvMsgData) { unsigned char ulIntsOff; /* Which event are we being asked to process? */ switch(ulEvent) { /* We are connected to a host and communication is now possible. */ case USB_EVENT_CONNECTED: /* Flush our buffers. */ USBBufferFlush(&g_sTxBuffer); USBBufferFlush(&g_sRxBuffer); ulIntsOff = IntDisable(); g_pcStatus = "Host connected."; g_ulFlags |= COMMAND_STATUS_UPDATE; IntEnable(ulIntsOff); break; /* The host has disconnected. */ case USB_EVENT_DISCONNECTED: ulIntsOff = IntDisable(); g_pcStatus = "Host disconnected."; g_ulFlags |= COMMAND_STATUS_UPDATE; IntEnable(ulIntsOff); break; /* Return the current serial communication parameters. */ case USBD_CDC_EVENT_GET_LINE_CODING: GetLineCoding(pvMsgData); break; /* Set the current serial communication parameters. */ case USBD_CDC_EVENT_SET_LINE_CODING: SetLineCoding(pvMsgData); break; /* Set the current serial communication parameters. */ case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE: SetControlLineState((unsigned short)ulMsgValue); break; /* Send a break condition on the serial line.*/ case USBD_CDC_EVENT_SEND_BREAK: SendBreak(true); break; /* Clear the break condition on the serial line. */ case USBD_CDC_EVENT_CLEAR_BREAK: SendBreak(false); break; /* Ignore SUSPEND and RESUME for now. */ case USB_EVENT_SUSPEND: case USB_EVENT_RESUME: break; /* We don't expect to receive any other events. Ignore any that show up in a release build or hang in a debug build. */ default: break; } return(0); }