usbio.c

IT projecotr reference design.

                                /* have been requested.                     */
                                /********************************************/

    if( isMouse )                                               /* if mouse */
    {
        if( USBMAIN_GetEpDataRequested( USB_MouseEP ) == TRUE )
        {
            Ep_MouseData.send_data[0] =  kd;                 /* mouse click */
            Ep_MouseData.send_data[1] =  pRep -> mouse_x;        /* delta x */
            Ep_MouseData.send_data[2] = -pRep -> mouse_y;        /* delta y */

            USB_WriteData( USB_MouseEP, (uint32 *)(Ep_MouseData.send_data), 3 );
            USBMAIN_SetEpDataRequested( USB_MouseEP, FALSE );
        }

        if( NULL != MOUSE_HID_Timer_Id )
            TMR_Set( MOUSE_HID_Timer_Id, MOUSE_HID_Idle_Rate * 1000 );
    }

    else                                                     /* if keyboard */
    {
        if( USBMAIN_GetEpDataRequested( USB_KeyBoardEP ) == TRUE )
        {
            Ep_KeyboardData.send_data[0] = 0;                        /* pad */
            Ep_KeyboardData.send_data[1] = 0;                        /* pad */
            Ep_KeyboardData.send_data[2] = kd;                       /* key */
            Ep_KeyboardData.send_data[3] = 0;                        /* pad */
            Ep_KeyboardData.send_data[4] = 0;                        /* pad */
            Ep_KeyboardData.send_data[5] = 0;                        /* pad */
            Ep_KeyboardData.send_data[6] = 0;                        /* pad */
            Ep_KeyboardData.send_data[7] = 0;                        /* pad */

            USB_WriteData( USB_KeyBoardEP, (uint32 *)(Ep_KeyboardData.send_data), 8 );
            USBMAIN_SetEpDataRequested( USB_KeyBoardEP, FALSE );

            Ep_KeyboardData.send_data[2] = 0; /* zero out the key for keyup */

            USB_WriteData( USB_KeyBoardEP, (uint32 *)(Ep_KeyboardData.send_data), 8 );
        }

        if( NULL != KEYBOARD_HID_Timer_Id )
            TMR_Set( KEYBOARD_HID_Timer_Id, KEYBOARD_HID_Idle_Rate * 1000 );
    }
}



/****************************************************************************/
/* Interrupt service routine to send periodic mouse idle report to host.    */
/****************************************************************************/

void USBMAIN_MouseIdleISR( void )
{
    if( USBMAIN_GetEpDataRequested( USB_MouseEP ) == TRUE )
    {
        Ep_MouseData.send_data[0] = 0;                          /* no click */
        Ep_MouseData.send_data[1] = 0;                        /* no delta x */
        Ep_MouseData.send_data[2] = 0;                        /* no delta y */

        USB_WriteData(USB_MouseEP, (uint32 *)(Ep_MouseData.send_data), 3 );
        USBMAIN_SetEpDataRequested(USB_MouseEP, FALSE );
    }

    TMR_Clear( MOUSE_HID_Timer_Id );                /* clear elapsed status */
    TMR_Set( MOUSE_HID_Timer_Id, MOUSE_HID_Idle_Rate * 1000 );    /*restart */
}



/****************************************************************************/
/* Interrupt service routine to send periodic keyboard idle report to host. */
/****************************************************************************/

void USBMAIN_KeyboardIdleISR( void )
{
    if( USBMAIN_GetEpDataRequested( USB_KeyBoardEP ) == TRUE )
    {
        Ep_KeyboardData.send_data[0] = 0;                            /* pad */
        Ep_KeyboardData.send_data[1] = 0;                            /* pad */
        Ep_KeyboardData.send_data[2] = 0;                            /* key */
        Ep_KeyboardData.send_data[3] = 0;                            /* pad */
        Ep_KeyboardData.send_data[4] = 0;                            /* pad */
        Ep_KeyboardData.send_data[5] = 0;                            /* pad */
        Ep_KeyboardData.send_data[6] = 0;                            /* pad */
        Ep_KeyboardData.send_data[7] = 0;                            /* pad */

        USB_WriteData(USB_KeyBoardEP, (uint32 *)(Ep_KeyboardData.send_data), 3 );
        USBMAIN_SetEpDataRequested( USB_KeyBoardEP, FALSE );
    }

    TMR_Clear( KEYBOARD_HID_Timer_Id );            /* clear elapsed status */
    TMR_Set( KEYBOARD_HID_Timer_Id, KEYBOARD_HID_Idle_Rate * 1000 );
}


/****************************************************************************/
/* Initialize USB communications, then perform enumeration and data         */
/* transfer as requested by host.                                           */
/****************************************************************************/

void USBMAIN_Task( void )
{
    const uint32 timeout = 1000;  /* mode change check period, milliseconds */
    int08 result;

                        /****************************************************/
                        /* If factory mode is enabled, allow selection of   */
                        /* startup user/factory mode. If not, mode is set   */
                        /* to user mode.                                    */
                        /*  1: Factory mode                                 */
                        /*  2: User mode.                                   */
                        /****************************************************/

    #ifndef __NO_FACTORYMODE_USB
        USB_Mode = gpConfiguration -> Peripherals.UsbMode;
    #else
        USB_Mode = 2;
    #endif

    USB_Mode_Changed = FALSE;                        /* no mode change flag */

                        /****************************************************/
                        /* Ensure USB is disconnected and reset at startup  */
                        /* and at re-start.                                 */
                        /****************************************************/

    USB_InitHostConnection();                          /* ensure disconnect */
    USB_Reset_Core();

                        /****************************************************/
                        /* Device setup                                     */
                        /****************************************************/

    USBDESC_InitDescriptors( USB_Mode );      /* initialize descriptor data */
    USB_SetDeviceINTMask( USB_DEV_SOF_DETECTED_IRQ ); /* mask SOF interrupt.*/
    ID_USBEvent = USB_GetGroupEventId();      /* get the USB group event ID */
    USB_EnableInterrupts();

                                /********************************************/
                                /* Delay so host takes note of disconnect   */
                                /* if link was connected, then connect.     */
                                /********************************************/

    RTA_TaskDelay( TMR_ConvertMSToTicks( 1000 )); /* 1000 millisecond delay */
    USB_ConnectHost();

                                /********************************************/
                                /* Process USB events. On timeout, check if */
                                /* USB protocol mode is to change.          */
                                /********************************************/

    while (1)
    {
        result = RTA_GroupEventWait(ID_USBEvent, USBMAIN_EVT_MASK, USBMAIN_EVT_MASK, GRP_SET_OR,
             TMR_ConvertMSToTicks(timeout));

        if (result == RTA_SUCCESS)                 /* if USB event received */
        {
            if( USB_Mode == USBMAIN_USERMODE )
                USBMAIN_UserModeProcessEvent();
            else
                USBMAIN_FactoryModeProcessEvent();
        }

        if( USB_Mode_Changed == TRUE )                    /* if mode change */
        {
            if (USB_Mode == USBMAIN_FACTORYMODE)
                USB_Mode = USBMAIN_USERMODE;
            else
                USB_Mode = USBMAIN_FACTORYMODE;

            iox_pinSet( IOX_D1_RED, FALSE );          /* not-configured LED */
            USB_DisconnectHost();                             /* disconnect */
            USBDESC_InitDescriptors( USB_Mode );  /* re-init descriptor data*/
            RTA_TaskDelay(TMR_ConvertMSToTicks(1000));  /* disconnect delay */
            USB_ConnectHost();                                /* re-connect */

            USB_Mode_Changed = FALSE;
        }
    }
}



/****************************************************************************/
/* Set flag to request switching operating modes between projector control  */
/* interface + mouse pass thru, or only mouse pass thru.                    */
/****************************************************************************/

void usbIO_ToggleMode( void )
{
    #ifndef __NO_FACTORYMODE_USB
        USB_Mode_Changed = TRUE;
    #endif
}



/****************************************************************************/
/* Set state of endpoint-data-requested flag.                               */
/*                                                                          */
/* Saves the state after the interrupt event has been cleared.              */
/****************************************************************************/

int08 USBMAIN_SetEpDataRequested( uint08 Ep, BOOL Data_Request_Pending )
{
    int08 result = PASS;

    switch (Ep)
    {
        case USB_EP1:
            USBMAIN_Ep1DataRequested = Data_Request_Pending;
            break;

        case USB_EP2:
            USBMAIN_Ep2DataRequested = Data_Request_Pending;
            break;

        case USB_EP3:
            USBMAIN_Ep3DataRequested = Data_Request_Pending;
            break;

        case USB_EP4:
            USBMAIN_Ep4DataRequested = Data_Request_Pending;
            break;

        default:
            result = FAIL;
    };

    return(result);
}



/****************************************************************************/
/* Return state of endpoint-data-requested flag.                            */
/*                                                                          */
/* Called to check that the host has a pending request before sending       */
/* data.                                                                    */
/****************************************************************************/

BOOL USBMAIN_GetEpDataRequested( uint08 Ep )
{
    int08 DataRequested = FALSE;

    if( Ep == USB_EP1 )
        DataRequested = USBMAIN_Ep1DataRequested;
    else if( Ep == USB_EP2 )
        DataRequested = USBMAIN_Ep2DataRequested;
    else if( Ep == USB_EP3 )
        DataRequested = USBMAIN_Ep3DataRequested;
    else if( Ep == USB_EP4 )
        DataRequested = USBMAIN_Ep4DataRequested;

    return DataRequested;
}



/****************************************************************************/
/* Receive setup.                                                           */
/****************************************************************************/

int08 USBMAIN_RecvSetupDataHandler( uint08 Ep, uint08 Data_Len )
{
    volatile int08   result = PASS;
    BOOL             error  = FALSE;
    USBMAIN_EP_DATA *ep     = &Ep_Data[Ep];
    USB_DEV_REQUEST *Dev_Request;
    uint32           zero_buffer;               /* dummy zero-length buffer */

                                /********************************************/
                                /* Read setup data.                         */
                                /********************************************/

    result = USB_ReadData( Ep, (uint32 *)ep -> recv_data, Data_Len );
    ep -> recv_total_len  = Data_Len;
    ep -> recv_actual_len = Data_Len;

    if(( result != PASS ) || ( Data_Len == 0 ))
        return result;

                                /********************************************/
                                /* Flush TxFIFO, reset ep->send_total_len   */
                                /* send_actual_len, and ep->send_zero_byte. */
                                /* If this setup message was received pre-  */
                                /* maturely (i.e. before the last setup     */
                                /* transaction finished) then abort the     */
                                /* last transaction in favor of the new one */
                                /*  (See USB 1.1 spec section 5.5.5)        */