예제 #1
0
USB_DEVICE_CDC_EVENT_RESPONSE APP_USBDeviceCDCEventHandler
(
    USB_DEVICE_CDC_INDEX index ,
    USB_DEVICE_CDC_EVENT event ,
    void * pData,
    uintptr_t userData
)
{
    APP2_DATA * app2DataObject;
    app2DataObject = (APP2_DATA *)userData;
    USB_CDC_CONTROL_LINE_STATE * controlLineStateData;

    switch ( event )
    {
        case USB_DEVICE_CDC_EVENT_GET_LINE_CODING:

            /* This means the host wants to know the current line
             * coding. This is a control transfer request. Use the
             * USB_DEVICE_ControlSend() function to send the data to
             * host.  */

            USB_DEVICE_ControlSend(app2DataObject->deviceHandle,
                    &app2DataObject->getLineCodingData, sizeof(USB_CDC_LINE_CODING));

            break;

        case USB_DEVICE_CDC_EVENT_SET_LINE_CODING:

            /* This means the host wants to set the line coding.
             * This is a control transfer request. Use the
             * USB_DEVICE_ControlReceive() function to receive the
             * data from the host */

            USB_DEVICE_ControlReceive(app2DataObject->deviceHandle,
                    &app2DataObject->setLineCodingData, sizeof(USB_CDC_LINE_CODING));

            break;

        case USB_DEVICE_CDC_EVENT_SET_CONTROL_LINE_STATE:

            /* This means the host is setting the control line state.
             * Read the control line state. We will accept this request
             * for now. */

            controlLineStateData = (USB_CDC_CONTROL_LINE_STATE *)pData;
            app2DataObject->controlLineStateData.dtr = controlLineStateData->dtr;
            app2DataObject->controlLineStateData.carrier = controlLineStateData->carrier;

            USB_DEVICE_ControlStatus(app2DataObject->deviceHandle, USB_DEVICE_CONTROL_STATUS_OK);

            break;

        case USB_DEVICE_CDC_EVENT_SEND_BREAK:

            /* This means that the host is requesting that a break of the
             * specified duration be sent. Read the break duration */

            app2DataObject->breakData = ((USB_DEVICE_CDC_EVENT_DATA_SEND_BREAK *)pData)->breakDuration;
            
            /* Complete the control transfer by sending a ZLP  */
            USB_DEVICE_ControlStatus(app2DataObject->deviceHandle, USB_DEVICE_CONTROL_STATUS_OK);
            
            break;

        case USB_DEVICE_CDC_EVENT_READ_COMPLETE:

            /* This means that the host has sent some data*/
            //SYS_CONSOLE_MESSAGE("Read flag set\n");
            app2DataObject->isReadComplete = true;
            break;

        case USB_DEVICE_CDC_EVENT_CONTROL_TRANSFER_DATA_RECEIVED:

            /* The data stage of the last control transfer is
             * complete. For now we accept all the data */

            USB_DEVICE_ControlStatus(app2DataObject->deviceHandle, USB_DEVICE_CONTROL_STATUS_OK);
            break;

        case USB_DEVICE_CDC_EVENT_CONTROL_TRANSFER_DATA_SENT:

            /* This means the GET LINE CODING function data is valid. We dont
             * do much with this data in this demo. */
            break;

        case USB_DEVICE_CDC_EVENT_WRITE_COMPLETE:

            /* This means that the data write got completed. We can schedule
             * the next read. */

            app2DataObject->isWriteComplete = true;
            break;

        default:
            break;
    }

    return USB_DEVICE_CDC_EVENT_RESPONSE_NONE;
}
예제 #2
0
파일: app.c 프로젝트: samuelsam93/Sam_ME433
void APP_USBDeviceHIDEventHandler(USB_DEVICE_HID_INDEX hidInstance,
        USB_DEVICE_HID_EVENT event, void * eventData, uintptr_t userData)
{
    APP_DATA * appData = (APP_DATA *)userData;

    switch(event)
    {
        case USB_DEVICE_HID_EVENT_REPORT_SENT:

            /* This means the mouse report was sent.
             We are free to send another report */

            appData->isMouseReportSendBusy = false;
            break;

        case USB_DEVICE_HID_EVENT_REPORT_RECEIVED:

            /* Dont care for other event in this demo */
            break;

        case USB_DEVICE_HID_EVENT_SET_IDLE:

             /* Acknowledge the Control Write Transfer */
           USB_DEVICE_ControlStatus(appData->deviceHandle, USB_DEVICE_CONTROL_STATUS_OK);

            /* save Idle rate received from Host */
            appData->idleRate = ((USB_DEVICE_HID_EVENT_DATA_SET_IDLE*)eventData)->duration;
            break;

        case USB_DEVICE_HID_EVENT_GET_IDLE:

            /* Host is requesting for Idle rate. Now send the Idle rate */
            USB_DEVICE_ControlSend(appData->deviceHandle, &(appData->idleRate),1);

            /* On successfully receiving Idle rate, the Host would acknowledge back with a
               Zero Length packet. The HID function driver returns an event
               USB_DEVICE_HID_EVENT_CONTROL_TRANSFER_DATA_SENT to the application upon
               receiving this Zero Length packet from Host.
               USB_DEVICE_HID_EVENT_CONTROL_TRANSFER_DATA_SENT event indicates this control transfer
               event is complete */ 

            break;

        case USB_DEVICE_HID_EVENT_SET_PROTOCOL:
            /* Host is trying set protocol. Now receive the protocol and save */
            appData->activeProtocol = *(USB_HID_PROTOCOL_CODE *)eventData;

              /* Acknowledge the Control Write Transfer */
            USB_DEVICE_ControlStatus(appData->deviceHandle, USB_DEVICE_CONTROL_STATUS_OK);
            break;

        case  USB_DEVICE_HID_EVENT_GET_PROTOCOL:

            /* Host is requesting for Current Protocol. Now send the Idle rate */
             USB_DEVICE_ControlSend(appData->deviceHandle, &(appData->activeProtocol), 1);

             /* On successfully receiving Idle rate, the Host would acknowledge
               back with a Zero Length packet. The HID function driver returns
               an event USB_DEVICE_HID_EVENT_CONTROL_TRANSFER_DATA_SENT to the
               application upon receiving this Zero Length packet from Host.
               USB_DEVICE_HID_EVENT_CONTROL_TRANSFER_DATA_SENT event indicates
               this control transfer event is complete */
             break;

        case USB_DEVICE_HID_EVENT_CONTROL_TRANSFER_DATA_SENT:
            break;

        default:
            break;
    }
}
예제 #3
0
/* Function:
   void _USB_DEVICE_AUDIO_SetupPacketHandler
   (
       USB_DEVICE_AUDIO_INDEX iAudio ,
       USB_SETUP_PACKET * setupPkt
   )

  Summary:
    Handles a fresh SETUP packet received from Host.

  Description:
    Handles a fresh SETUP packet received from Host.

  Returns:
    This is a local function and should not be called directly by the
    application.
*/
void _USB_DEVICE_AUDIO_SetupPacketHandler 
(
    USB_DEVICE_AUDIO_INDEX iAudio , 
    USB_SETUP_PACKET * setupPkt
)
{
    uint8_t audioControlInterfaceId;
    uint8_t interfaceId;
    uint8_t curAlternateSetting;
    uint8_t prevAlternateSetting;
    uint8_t streamIntfcIndex;
    uint8_t noOfEndpoints;
    USB_ENDPOINT ep; 
    uint16_t maxPacketSize;
    USB_DEVICE_HANDLE usbDeviceHandle;
    USB_DEVICE_AUDIO_EVENT event;
    USB_DEVICE_AUDIO_EVENT_DATA_INTERFACE_SETTING_CHANGED interfaceInfo;
    USB_ERROR endpointEnableResult; 
    USB_DEVICE_AUDIO_STREAMING_INTERFACE_ALTERNATE_SETTING *pCurAlternateStng;
    USB_DEVICE_AUDIO_STREAMING_INTERFACE_ALTERNATE_SETTING *pPrevAlternateStng;
    USB_DEVICE_AUDIO_STREAMING_INTERFACE *pStreamingInterface;
    
    uint16_t adjustedMaxPacketSize =1;

    /* Obtain pointer to the Audio Instance that is being addressed*/
    USB_DEVICE_AUDIO_INSTANCE* audioInstance = &gUsbDeviceAudioInstance[iAudio];

    /* Obtain pointer to the Audio Interface collection*/
    USB_DEVICE_AUDIO_INTERFACE_COLLECTION *curInfCollection =
            &(audioInstance->infCollection);

    /* Get the Device Layer handle */
    usbDeviceHandle = gUsbDeviceAudioInstance[iAudio].devLayerHandle;
    
    /* Check if the request is a standard interface request*/
    if (  (setupPkt->RequestType == USB_SETUP_REQUEST_TYPE_STANDARD)
       && (setupPkt->Recipient == USB_SETUP_REQUEST_RECIPIENT_INTERFACE))

    {
        /* We have received Standard Set request */

        /* retrieve interface number from the Setup packet */
        interfaceId = setupPkt->bIntfID;

        /* retrieve audio Control interface number*/
        audioControlInterfaceId = curInfCollection->bControlInterfaceNum;
        
        switch(setupPkt->bRequest)
        {
            case USB_REQUEST_SET_INTERFACE:
                curAlternateSetting = setupPkt->bAltID;
                if (interfaceId == audioControlInterfaceId)
                {
                    /*SET INTERFACE command was received to Audio Control
                      Interface */
                    curInfCollection->bControlAltSetng = curAlternateSetting;
                }
                else
                {
                    /*An Audio Streaming interface has received SET INTERFACE
                      command */
                    streamIntfcIndex = interfaceId - audioControlInterfaceId - 1;

                    /* Get pointer to the current audio streaming interface */
                    pStreamingInterface = &(curInfCollection->streamInf[streamIntfcIndex]);
                    
                    /* Get pointer to the Interface Alternate setting. */
                    pCurAlternateStng
                    = &(pStreamingInterface->alterntSetting[curAlternateSetting]);
                    
                    /* Find out how many endpoint are present for this Interface
                     * Alternate setting */
                    noOfEndpoints = pCurAlternateStng->numEndPoints;

                    if ((noOfEndpoints) && (curAlternateSetting))
                    {
                        /* We have to enable the endpoint only if this alternate
                         setting has at least one endpoint and the alternate
                         setting is a non zero value */
                        
                        /*Retrieve endpoint size */
                        ep = pCurAlternateStng->isoDataEp.epAddr;
                        
                        /* retrieve max packet size. */
                        maxPacketSize
                             = pCurAlternateStng->isoDataEp.epMaxPacketSize;

                        /* maxpacket size should be adjusted to upper power of
                           two. As per the PIC32MZ USB module requirement.*/
                        if (maxPacketSize)
                        {
                            while(adjustedMaxPacketSize < maxPacketSize)
                                adjustedMaxPacketSize <<= 1;
                        }
                        else
                            adjustedMaxPacketSize = 0;
                        /* Enable Isochronous Data Endpoint */
                        endpointEnableResult = USB_DEVICE_EndpointEnable
                        (
                            usbDeviceHandle ,
                            0,
                            ep ,
                            USB_TRANSFER_TYPE_ISOCHRONOUS ,
                            adjustedMaxPacketSize
                        );
                        if (endpointEnableResult != USB_ERROR_NONE)
                        {
                            SYS_ASSERT (false, "Endpoint not Enabled");
                        }

                        if (noOfEndpoints == 2)
                        {
                            /* If number of Endpoints is Two, then it is sure
                             * that this alternate setting reports a Isochronous
                             * Sync Endpoint. Enable the Sync Endpoint. */
                        }

                        //Change Audio Instance object state to Initialized.
                        pStreamingInterface->state
                                    = USB_DEVICE_AUDIO_STRMNG_INTFC_INITIALIZED;
                    }
                    else //alternateSetting  = 0
                    {
                        if (pStreamingInterface->state
                                   == USB_DEVICE_AUDIO_STRMNG_INTFC_INITIALIZED)
                        {
                            //Disable the Endpoint in the previous Active Alternate setting.
                            prevAlternateSetting = pStreamingInterface->activeSetting;

                            //get a pointer to the previous alternate setting.
                            pPrevAlternateStng = &(pStreamingInterface->alterntSetting[prevAlternateSetting]);

                            //Get endpoint no of the previous alternate setting
                            ep = pPrevAlternateStng->isoDataEp.epAddr;

                            //Disable the Endpoint
                            USB_DEVICE_EndpointDisable(usbDeviceHandle ,ep);


                            if (noOfEndpoints == 2)
                            {
                                /* If number of Endpoints is Two, then it is sure
                                * that this alternate setting reports a Isochronous
                                * Sync Endpoint. Disable the Sync Endpoint. */
                            }
                            curInfCollection->streamInf[streamIntfcIndex].state
                                = USB_DEVICE_AUDIO_STRMNG_INTFC_NOT_INITIALIZED;
                            USB_DEVICE_IRPCancelAll(usbDeviceHandle,  ep);
                        }  
                    }

                    /* Remember the new alternate setting received */
                    curInfCollection->streamInf[streamIntfcIndex].activeSetting 
                    = curAlternateSetting;


                    /* Notify application about the SET_INTERFACE request */
                    interfaceInfo.interfaceNumber = interfaceId;
                    interfaceInfo.interfaceAlternateSetting = curAlternateSetting;
                    audioInstance->appEventCallBack
                    (
                        iAudio,
                        USB_DEVICE_AUDIO_EVENT_INTERFACE_SETTING_CHANGED,
                        &interfaceInfo,
                        0
                    );
                }
                /* Send an Acknowledgement to the Host */ 
                USB_DEVICE_ControlStatus( usbDeviceHandle,
                                USB_DEVICE_CONTROL_STATUS_OK);
            break;
            case USB_REQUEST_GET_INTERFACE:
                if (interfaceId == audioControlInterfaceId)
                {
                    curAlternateSetting = curInfCollection->bControlAltSetng;
                }
                else
                {
                    streamIntfcIndex = interfaceId - audioControlInterfaceId - 1;
                    curAlternateSetting
                    = curInfCollection->streamInf[streamIntfcIndex].activeSetting;
                }

                USB_DEVICE_ControlSend( usbDeviceHandle,
                        (void *)&curAlternateSetting, 1);
                break;
            default:
                break;

        }      
    }//end of if((setupPkt->bmRequestType ==
    else if ( (setupPkt->RequestType == USB_SETUP_REQUEST_TYPE_CLASS )
            && (setupPkt->Recipient == USB_SETUP_REQUEST_RECIPIENT_INTERFACE))
    {
        /* We have recived a Audio Class specific Interface request */
        switch (setupPkt->bRequest)
        {
            case USB_AUDIO_CS_SET_CUR:
                event = USB_DEVICE_AUDIO_EVENT_CONTROL_SET_CUR;
                break;
            case USB_AUDIO_CS_GET_CUR:
                event = USB_DEVICE_AUDIO_EVENT_CONTROL_GET_CUR;
                break;
            case USB_AUDIO_CS_SET_MIN:
                event = USB_DEVICE_AUDIO_EVENT_CONTROL_SET_MIN;
                break;
            case USB_AUDIO_CS_GET_MIN:
                event = USB_DEVICE_AUDIO_EVENT_CONTROL_GET_MIN;
                break;
            case USB_AUDIO_CS_SET_MAX:
                event = USB_DEVICE_AUDIO_EVENT_CONTROL_SET_MAX;
                break;
            case USB_AUDIO_CS_GET_MAX:
                event = USB_DEVICE_AUDIO_EVENT_CONTROL_GET_MAX;
                break;
            case USB_AUDIO_CS_SET_RES:
                event = USB_DEVICE_AUDIO_EVENT_CONTROL_SET_RES;
                break;
            case USB_AUDIO_CS_GET_RES:
                event = USB_DEVICE_AUDIO_EVENT_CONTROL_GET_RES;
                break;
            case USB_AUDIO_CS_SET_MEM:
                event = USB_DEVICE_AUDIO_EVENT_ENTITY_SET_MEM;
                break;
            case USB_AUDIO_CS_GET_MEM:
                event = USB_DEVICE_AUDIO_EVENT_ENTITY_GET_MEM;
                break;
            case USB_AUDIO_CS_GET_STAT:
                event = USB_DEVICE_AUDIO_EVENT_ENTITY_GET_STAT;
                break;
            default:
            /* Unknown request. Stall the request */
                event = 0;
                USB_DEVICE_ControlStatus(audioInstance->devLayerHandle,
                                               USB_DEVICE_CONTROL_STATUS_ERROR);
        }
        if (( audioInstance->appEventCallBack) && (event))
        {
            /* inform the application about the request */
            /* the application needs to handle both EP and entity specific 
               requests */
           audioInstance->appEventCallBack ( iAudio, event, setupPkt, 0);
        }        
    }// end of else if
}//end of function _USB_DEVICE_AUDIO_SetupPacketHandler
예제 #4
0
파일: app.c 프로젝트: therrma2/me433
USB_DEVICE_CDC_EVENT_RESPONSE APP_USBDeviceCDCEventHandler
(
    USB_DEVICE_CDC_INDEX index ,
    USB_DEVICE_CDC_EVENT event ,
    void* pData,
    uintptr_t userData
)
{
    APP_DATA * appDataObject;
    appDataObject = (APP_DATA *)userData;
    USB_CDC_CONTROL_LINE_STATE * controlLineStateData;
    uint16_t * breakData;

    switch ( event )
    {
        case USB_DEVICE_CDC_EVENT_GET_LINE_CODING:

            /* This means the host wants to know the current line
             * coding. This is a control transfer request. Use the
             * USB_DEVICE_ControlSend() function to send the data to
             * host.  */

             USB_DEVICE_ControlSend(appDataObject->deviceHandle,
                    &appDataObject->getLineCodingData, sizeof(USB_CDC_LINE_CODING));

            break;

        case USB_DEVICE_CDC_EVENT_SET_LINE_CODING:

            /* This means the host wants to set the line coding.
             * This is a control transfer request. Use the
             * USB_DEVICE_ControlReceive() function to receive the
             * data from the host */

            USB_DEVICE_ControlReceive(appDataObject->deviceHandle,
                    &appDataObject->setLineCodingData, sizeof(USB_CDC_LINE_CODING));

            break;

        case USB_DEVICE_CDC_EVENT_SET_CONTROL_LINE_STATE:

            /* This means the host is setting the control line state.
             * Read the control line state. We will accept this request
             * for now. */

            controlLineStateData = (USB_CDC_CONTROL_LINE_STATE *)pData;
            appDataObject->controlLineStateData.dtr = controlLineStateData->dtr;
            appDataObject->controlLineStateData.carrier =
                    controlLineStateData->carrier;

            USB_DEVICE_ControlStatus(appDataObject->deviceHandle, USB_DEVICE_CONTROL_STATUS_OK);

            break;

        case USB_DEVICE_CDC_EVENT_SEND_BREAK:

            /* This means that the host is requesting that a break of the
             * specified duration be sent. Read the break duration */

            breakData = (uint16_t *)pData;
            appDataObject->breakData = *breakData;
            break;

        case USB_DEVICE_CDC_EVENT_READ_COMPLETE:

            /* This means that the host has sent some data*/
            appDataObject->isReadComplete = true;
            appDataObject->readLength =
                    ((USB_DEVICE_CDC_EVENT_DATA_READ_COMPLETE*)pData)->length;
            break;

        case USB_DEVICE_CDC_EVENT_CONTROL_TRANSFER_DATA_RECEIVED:

            /* The data stage of the last control transfer is
             * complete. We have received the line coding from the host. Call
             * the usart driver routine to change the baud. We can call this
             * function here as it is not blocking. */

            DRV_USART_BaudSet(appDataObject->usartHandle, appDataObject->setLineCodingData.dwDTERate);

            USB_DEVICE_ControlStatus(appDataObject->deviceHandle, USB_DEVICE_CONTROL_STATUS_OK);
            break;

        case USB_DEVICE_CDC_EVENT_CONTROL_TRANSFER_DATA_SENT:

            /* This means the GET LINE CODING function data is valid. We dont
             * do much with this data in this demo. */
            break;

        case USB_DEVICE_CDC_EVENT_WRITE_COMPLETE:

            /* This means that the data write got completed. We can schedule
             * the next read. */

            break;

        default:
            break;
    }

    return USB_DEVICE_CDC_EVENT_RESPONSE_NONE;
}
예제 #5
0
파일: app.c 프로젝트: neslerc/Homework2
USB_DEVICE_HID_EVENT_RESPONSE APP_USBDeviceHIDEventHandler
(
    USB_DEVICE_HID_INDEX iHID,
    USB_DEVICE_HID_EVENT event,
    void * eventData,
    uintptr_t userData
)
{
    USB_DEVICE_HID_EVENT_DATA_REPORT_SENT * reportSent;
    USB_DEVICE_HID_EVENT_DATA_REPORT_RECEIVED * reportReceived;

    /* Check type of event */
    switch (event)
    {
        case USB_DEVICE_HID_EVENT_REPORT_SENT:

            /* The eventData parameter will be USB_DEVICE_HID_EVENT_REPORT_SENT
             * pointer type containing details about the report that was
             * sent. */
            reportSent = (USB_DEVICE_HID_EVENT_DATA_REPORT_SENT *) eventData;
            if(reportSent->handle == appData.txTransferHandle )
            {
                // Transfer progressed.
                appData.hidDataTransmitted = true;
            }
            
            break;

        case USB_DEVICE_HID_EVENT_REPORT_RECEIVED:

            /* The eventData parameter will be USB_DEVICE_HID_EVENT_REPORT_RECEIVED
             * pointer type containing details about the report that was
             * received. */

            reportReceived = (USB_DEVICE_HID_EVENT_DATA_REPORT_RECEIVED *) eventData;
            if(reportReceived->handle == appData.rxTransferHandle )
            {
                // Transfer progressed.
                appData.hidDataReceived = true;
            }
          
            break;

        case USB_DEVICE_HID_EVENT_SET_IDLE:

            /* For now we just accept this request as is. We acknowledge
             * this request using the USB_DEVICE_HID_ControlStatus()
             * function with a USB_DEVICE_CONTROL_STATUS_OK flag */

            USB_DEVICE_ControlStatus(appData.usbDevHandle, USB_DEVICE_CONTROL_STATUS_OK);

            /* Save Idle rate recieved from Host */
            appData.idleRate = ((USB_DEVICE_HID_EVENT_DATA_SET_IDLE*)eventData)->duration;
            break;

        case USB_DEVICE_HID_EVENT_GET_IDLE:

            /* Host is requesting for Idle rate. Now send the Idle rate */
            USB_DEVICE_ControlSend(appData.usbDevHandle, & (appData.idleRate),1);

            /* On successfully reciveing Idle rate, the Host would acknowledge back with a
               Zero Length packet. The HID function drvier returns an event
               USB_DEVICE_HID_EVENT_CONTROL_TRANSFER_DATA_SENT to the application upon
               receiving this Zero Length packet from Host.
               USB_DEVICE_HID_EVENT_CONTROL_TRANSFER_DATA_SENT event indicates this control transfer
               event is complete */

            break;
        default:
            // Nothing to do.
            break;
    }
    return USB_DEVICE_HID_EVENT_RESPONSE_NONE;
}