usbio.c

IT projecotr reference design.

                                /* sent.                                    */
                                /********************************************/

            ep -> send_actual_len = ep -> send_actual_len + send_size_in_bytes;

            if( ep -> send_total_len == ep -> send_actual_len )
            {
                ep -> send_total_len  = 0;
                ep -> send_actual_len = 0;

                if( ep->send_zero_byte == TRUE )/* zero byte IN data needed */
                {
                    result = USB_WriteData( Ep, &zero_buffer, 0 );
                    ep -> send_zero_byte = FALSE;
                }
            }
        }
                                /********************************************/
                                /* No data to send. HW will respond with a  */
                                /* NAK to the next IN request too.          */
                                /********************************************/
        else
        {
            result = FAIL;
        }
    }
                                /********************************************/
                                /* Invalid endopint.                        */
                                /********************************************/
    else
    {
        result = FAIL;
    }

    return result;
}



/****************************************************************************/
/* Return HID idle rate.                                                    */
/****************************************************************************/

int08 USBMAIN_HidGetIdleRecv( uint08 Ep, uint16 interface )
{
    uint16 HID_Idle_Rate;
    USBMAIN_EP_DATA *ep = &Ep_Data[Ep];

    if( interface == (uint16)Ep_KeyboardData.interface )
        HID_Idle_Rate = KEYBOARD_HID_Idle_Rate;
    else
        HID_Idle_Rate = MOUSE_HID_Idle_Rate;

                                /********************************************/
                                /* HID idle rate was multiplied by 4 in     */
                                /* USBMAIN_RecvSetupDataHandler.            */
                                /********************************************/

  *(ep -> send_data)      = HID_Idle_Rate / 4;
    ep -> send_total_len  = 1;
    ep -> send_actual_len = 0;

    return USBMAIN_SendDataHandler( Ep );
}



/****************************************************************************/
/* Configure factory endpoints per descriptors that will be sent to host.   */
/****************************************************************************/

int08 USBMAIN_ConfigEps_FactoryMode( void )
{
    BOOL isPass = TRUE;
    int i;

    USB_EP_CONFIG Ep_Config[8] =
    {
        { USB_EP0,                        USB_EP_IN,  USB_CONTROL_EP,   0,                   0,                               0,                 USB_MAX_PACKET_64 },
        { USB_EP0,                        USB_EP_OUT, USB_CONTROL_EP,   0,                   0,                               0,                 USB_MAX_PACKET_64 },
        { USB_PROJ_ENDPOINT_FACTORYMODE,  USB_EP_IN,  USB_INTERRUPT_EP, USB_CONFIGURATION_1, USB_INTERFACE_0,                 USB_ALT_SETTING_0, USB_MAX_PACKET_64 },
        { USB_PROJ_ENDPOINT_FACTORYMODE,  USB_EP_OUT, USB_BULK_EP,      USB_CONFIGURATION_1, USB_INTERFACE_0,                 USB_ALT_SETTING_0, USB_MAX_PACKET_64 },
        { USB_RFC_ENDPOINT_FACTORYMODE,   USB_EP_IN,  USB_INTERRUPT_EP, USB_CONFIGURATION_1, USB_INTERFACE_0,                 USB_ALT_SETTING_0, USB_MAX_PACKET_64 },
        { USB_RFC_ENDPOINT_FACTORYMODE,   USB_EP_OUT, USB_BULK_EP,      USB_CONFIGURATION_1, USB_INTERFACE_0,                 USB_ALT_SETTING_0, USB_MAX_PACKET_64 },
        { USB_MOUSE_ENDPOINT_FACTORYMODE, USB_EP_IN,  USB_INTERRUPT_EP, USB_CONFIGURATION_1, USB_INTERFACE_MOUSE_FACTORYMODE, USB_ALT_SETTING_0, USB_MAX_PACKET_8  },
        { USB_KEY_ENDPOINT_FACTORYMODE,   USB_EP_IN,  USB_INTERRUPT_EP, USB_CONFIGURATION_1, USB_INTERFACE_KEY_FACTORYMODE,   USB_ALT_SETTING_0, USB_MAX_PACKET_8  }
    };

                                /********************************************/
                                /* Set endpoint configurations.             */
                                /********************************************/

    USB_MouseEP    = USB_MOUSE_ENDPOINT_FACTORYMODE;
    USB_KeyBoardEP = USB_KEY_ENDPOINT_FACTORYMODE;

    for( i = 0; i < 8; i++ )
        isPass &= ( PASS == USB_SetEpConfiguration( Ep_Config[i] ));

                                /********************************************/
                                /* Set TxFIFO size, in 32-bit words.        */
                                /********************************************/

    isPass &= ( PASS == USB_SetEpTxFIFOSize( USB_EP0,                        16 ));
    isPass &= ( PASS == USB_SetEpTxFIFOSize( USB_PROJ_ENDPOINT_FACTORYMODE,  16 ));
    isPass &= ( PASS == USB_SetEpTxFIFOSize( USB_RFC_ENDPOINT_FACTORYMODE,   16 ));
    isPass &= ( PASS == USB_SetEpTxFIFOSize( USB_MOUSE_ENDPOINT_FACTORYMODE, 16 ));
    isPass &= ( PASS == USB_SetEpTxFIFOSize( USB_KEY_ENDPOINT_FACTORYMODE,   16 ));
    isPass &= ( PASS == USB_SetEpRxFIFOSize( USB_EP0,                        16 ));
    isPass &= ( PASS == USB_SetEpRxFIFOSize( USB_PROJ_ENDPOINT_FACTORYMODE,  16 ));
    isPass &= ( PASS == USB_SetEpRxFIFOSize( USB_RFC_ENDPOINT_FACTORYMODE,   16 ));

                                /********************************************/
                                /* Control EP                               */
                                /********************************************/

    Ep_Data[0].IN_max_pkt     = USB_MAX_PACKET_64;
    Ep_Data[0].OUT_max_pkt    = USB_MAX_PACKET_64;
    Ep_Data[0].send_zero_byte = FALSE;
    Ep_Data[0].send_data      = EP_Ctrl_send;
    Ep_Data[0].recv_data      = EP_Ctrl_recv;

                                /********************************************/
                                /* Projector control EP                     */
                                /********************************************/

    Ep_Data[1].IN_max_pkt     = USB_MAX_PACKET_64;
    Ep_Data[1].OUT_max_pkt    = USB_MAX_PACKET_64;
    Ep_Data[1].send_zero_byte = FALSE;

    #ifndef __NO_FACTORYMODE_USB
        Ep_Data[1].recv_data  = EP_PCtl_recv;
    #else
        Ep_Data[1].recv_data  = NULL;
    #endif

                                /********************************************/
                                /* RFC EP                                   */
                                /********************************************/

    Ep_Data[2].IN_max_pkt     = USB_MAX_PACKET_64;
    Ep_Data[2].OUT_max_pkt    = USB_MAX_PACKET_64;
    Ep_Data[2].send_zero_byte = FALSE;

    #ifndef __NO_FACTORYMODE_USB
        Ep_Data[2].recv_data  = EP_RFC_recv;
    #else
        Ep_Data[2].recv_data  = NULL;
    #endif

                                /********************************************/
                                /* Emulated mouse/keyboard EPs              */
                                /********************************************/

    Ep_MouseData.IN_max_pkt     = USB_MAX_PACKET_8;
    Ep_MouseData.send_zero_byte = FALSE;
    Ep_MouseData.interface      = USB_INTERFACE_MOUSE_FACTORYMODE;
    Ep_MouseData.send_data      = mouseDataBuffer;
    Ep_MouseData.recv_data      = NULL;

    Ep_KeyboardData.IN_max_pkt     = USB_MAX_PACKET_8;
    Ep_KeyboardData.send_zero_byte = FALSE;
    Ep_KeyboardData.interface      = USB_INTERFACE_KEY_FACTORYMODE;
    Ep_KeyboardData.send_data      = keyboardDataBuffer;
    Ep_KeyboardData.recv_data      = NULL;

    return isPass ? PASS : FAIL;
}



/****************************************************************************/
/* Configure user endpoints per descriptors that will be sen to host.       */
/****************************************************************************/

int08 USBMAIN_ConfigEps_UserMode( void )
{
    BOOL isPass = TRUE;
    int i;

    USB_EP_CONFIG Ep_Config[4] =
    {
        {USB_EP0, USB_EP_IN,  USB_CONTROL_EP,   0,                   0,               0,                 USB_MAX_PACKET_64},
        {USB_EP0, USB_EP_OUT, USB_CONTROL_EP,   0,                   0,               0,                 USB_MAX_PACKET_64},
        {USB_EP1, USB_EP_IN,  USB_INTERRUPT_EP, USB_CONFIGURATION_1, USB_INTERFACE_0, USB_ALT_SETTING_0, USB_MAX_PACKET_8 },
        {USB_EP2, USB_EP_IN,  USB_INTERRUPT_EP, USB_CONFIGURATION_1, USB_INTERFACE_1, USB_ALT_SETTING_0, USB_MAX_PACKET_8 }
    };

                                /********************************************/
                                /* Set endpoint configurations.             */
                                /********************************************/

    USB_MouseEP    = USB_MOUSE_ENDPOINT_USERMODE;
    USB_KeyBoardEP = USB_KEY_ENDPOINT_USERMODE;

    for( i = 0; i < 4; i++ )
        isPass &= ( PASS == USB_SetEpConfiguration( Ep_Config[i] ));

                                /********************************************/
                                /* Set TxFIFO size, in 32-bit words.        */
                                /********************************************/

    isPass &= ( PASS == USB_SetEpTxFIFOSize( USB_EP0, 16 ));
    isPass &= ( PASS == USB_SetEpTxFIFOSize( USB_EP1, 16 ));
    isPass &= ( PASS == USB_SetEpTxFIFOSize( USB_EP2, 16 ));
    isPass &= ( PASS == USB_SetEpRxFIFOSize( USB_EP0, 16 ));

                                /********************************************/
                                /* Set packet sizes and interface numbers.  */
                                /********************************************/

    Ep_Data[0].IN_max_pkt     = USB_MAX_PACKET_64;
    Ep_Data[0].OUT_max_pkt    = USB_MAX_PACKET_64;
    Ep_Data[0].send_zero_byte = FALSE;

    Ep_MouseData.IN_max_pkt     = USB_MAX_PACKET_8;
    Ep_MouseData.send_zero_byte = FALSE;
    Ep_MouseData.interface      = USB_INTERFACE_0;

    Ep_KeyboardData.IN_max_pkt     = USB_MAX_PACKET_8;
    Ep_KeyboardData.send_zero_byte = FALSE;
    Ep_KeyboardData.interface      = USB_INTERFACE_1;

    return isPass ? PASS : FAIL;
}



/****************************************************************************/
/* Copy from an aligned receive buffer to caller's buffer.                  */
/****************************************************************************/

void USBMAIN_TranslateEpdataToMsg( uint08 Ep, uint08* unload_address, uint08 size )
{
    USBMAIN_EP_DATA *ep = &Ep_Data[Ep];

    memcpy((void*)unload_address, (const void*)&ep -> recv_data[0], (size_t)size );
}



/****************************************************************************/
/* Set send data pointer to an aligned transmit buffer and initialize the   */
/* endpoint struct to transmit to host.                                     */
/****************************************************************************/

void USBMAIN_TranslateMsgToEpdata( uint08 Ep, uint08* msg, uint16 count )
{
    USBMAIN_EP_DATA *ep = &Ep_Data[Ep];

    dbmsg_ftrace( DBM_USB, "TranslateMsgToEpdata ep=%d bytes=%d\r\n", Ep, count );

    ep -> send_data = msg;

    ep -> send_total_len  = count;
    ep -> send_actual_len = 0;

    ep -> recv_total_len  = 0;
    ep -> recv_actual_len = 0;
}


/****************************************************************************/
/* Get a single packet of a projector control message request.              */
/****************************************************************************/

uint16 usbIO_GetCmdPacket( uint08 *pPkt, uint32 waitMs )
{
    uint16 pktSize;

    if( RTA_SUCCESS != RTA_EventWait( ID_USBCmd_Event, TRUE, TMR_ConvertMSToTicks( waitMs )))
        return 0;                                    /* zero bytes received */

    pktSize = Ep_Data[USB_EP1].recv_actual_len;  /* number of bytes waiting */
    USBMAIN_TranslateEpdataToMsg( USB_EP1, pPkt, pktSize );  /* copy caller */
    RTA_EventClear( ID_USBCmd_Event );   /* clear event to receive next pkt */
    RTA_SemRelease( ID_USBCmd_Sem );                      /* release buffer */

    return pktSize;
}



/****************************************************************************/
/* Send a complete projector control message response.                      */
/****************************************************************************/

uint16 usbIO_PutCmdResponse( uint16 nbt, uint08 *pRsp )
{
    USBMAIN_TranslateMsgToEpdata( USB_EP1, pRsp, nbt );

                                /********************************************/