static void PIOS_USB_HID_SendReport(struct pios_usb_hid_dev * usb_hid_dev)
{
	uint16_t bytes_to_tx;

	if (!usb_hid_dev->tx_out_cb) {
		return;
	}

	bool need_yield = false;
#ifdef PIOS_USB_BOARD_BL_HID_HAS_NO_LENGTH_BYTE
	bytes_to_tx = (usb_hid_dev->tx_out_cb)(usb_hid_dev->tx_out_context,
					       &usb_hid_dev->tx_packet_buffer[1],
					       sizeof(usb_hid_dev->tx_packet_buffer)-1,
					       NULL,
					       &need_yield);
#else
	bytes_to_tx = (usb_hid_dev->tx_out_cb)(usb_hid_dev->tx_out_context,
					       &usb_hid_dev->tx_packet_buffer[2],
					       sizeof(usb_hid_dev->tx_packet_buffer)-2,
					       NULL,
					       &need_yield);
#endif
	if (bytes_to_tx == 0) {
		return;
	}

	/* Always set type as report ID */
	usb_hid_dev->tx_packet_buffer[0] = 1;

#ifdef PIOS_USB_BOARD_BL_HID_HAS_NO_LENGTH_BYTE
	UserToPMABufferCopy(usb_hid_dev->tx_packet_buffer,
			GetEPTxAddr(usb_hid_dev->cfg->data_tx_ep),
			bytes_to_tx + 1);
#else
	usb_hid_dev->tx_packet_buffer[1] = bytes_to_tx;
	UserToPMABufferCopy(usb_hid_dev->tx_packet_buffer,
			GetEPTxAddr(usb_hid_dev->cfg->data_tx_ep),
			bytes_to_tx + 2);
#endif
	/* Is this correct?  Why do we always send the whole buffer? */
	SetEPTxCount(usb_hid_dev->cfg->data_tx_ep, sizeof(usb_hid_dev->tx_packet_buffer));
	SetEPTxValid(usb_hid_dev->cfg->data_tx_ep);

#if defined(PIOS_INCLUDE_FREERTOS)
	if (need_yield) {
		vPortYieldFromISR();
	}
#endif	/* PIOS_INCLUDE_FREERTOS */
}
Exemple #2
0
/*******************************************************************************
* Function Name  : DataStageOut.
* Description    : Data stage of a Control Write Transfer.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void DataStageOut(void)
{
    ENDPOINT_INFO *pEPinfo = &pInformation->Ctrl_Info;
    uint32_t save_rLength;

    save_rLength = pEPinfo->Usb_rLength;

    if (pEPinfo->CopyData && save_rLength)
    {
        uint8_t *Buffer;
        uint32_t Length;

        Length = pEPinfo->PacketSize;
        if (Length > save_rLength)
        {
            Length = save_rLength;
        }

        Buffer = (*pEPinfo->CopyData)(Length);
        pEPinfo->Usb_rLength -= Length;
        pEPinfo->Usb_rOffset += Length;
        PMAToUserBufferCopy(Buffer, GetEPRxAddr(ENDP0), Length);

    }

    if (pEPinfo->Usb_rLength != 0)
    {
        vSetEPRxStatus(EP_RX_VALID);/* re-enable for next data reception */
        SetEPTxCount(ENDP0, 0);
        vSetEPTxStatus(EP_TX_VALID);/* Expect the host to abort the data OUT stage */
    }
    /* Set the next State*/
    if (pEPinfo->Usb_rLength >= pEPinfo->PacketSize)
    {
        pInformation->ControlState = OUT_DATA;
    }
    else
    {
        if (pEPinfo->Usb_rLength > 0)
        {
            pInformation->ControlState = LAST_OUT_DATA;
        }
        else if (pEPinfo->Usb_rLength == 0)
        {
            pInformation->ControlState = WAIT_STATUS_IN;
            USB_StatusIn();
        }
    }
}
Exemple #3
0
/*******************************************************************************
* Function Name  : Read_Memory
* Description    : Handle the Read operation from the microSD card.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void Read_Memory(uint8_t lun, uint32_t Memory_Offset, uint32_t Transfer_Length)
{
    static uint32_t Offset, Length;

    if (TransferState == TXFR_IDLE )
    {
        Offset = Memory_Offset * Mass_Block_Size[lun];
        Length = Transfer_Length * Mass_Block_Size[lun];
        TransferState = TXFR_ONGOING;
    }

    if (TransferState == TXFR_ONGOING )
    {
        if (!Block_Read_count)
        {
            MAL_Read(lun ,
                     Offset ,
                     Data_Buffer,
                     Mass_Block_Size[lun]);

            USB_SIL_Write(EP2_IN, (uint8_t *)Data_Buffer, BULK_MAX_PACKET_SIZE);

            Block_Read_count = Mass_Block_Size[lun] - BULK_MAX_PACKET_SIZE;
            Block_offset = BULK_MAX_PACKET_SIZE;
        }
        else
        {
            USB_SIL_Write(EP2_IN, (uint8_t *)Data_Buffer + Block_offset, BULK_MAX_PACKET_SIZE);

            Block_Read_count -= BULK_MAX_PACKET_SIZE;
            Block_offset += BULK_MAX_PACKET_SIZE;
        }

        SetEPTxCount(ENDP2, BULK_MAX_PACKET_SIZE);
        SetEPTxStatus(ENDP2, EP_TX_VALID);
        Offset += BULK_MAX_PACKET_SIZE;
        Length -= BULK_MAX_PACKET_SIZE;

        CSW.dDataResidue -= BULK_MAX_PACKET_SIZE;
    }
    if (Length == 0)
    {
        Block_Read_count = 0;
        Block_offset = 0;
        Offset = 0;
        Bot_State = BOT_DATA_IN_LAST;
        TransferState = TXFR_IDLE;
    }
}
Exemple #4
0
/*******************************************************************************
* Function Name  : Read_Memory
* Description    : Handle the Read operation from the microSD card.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void Read_Memory(u8 lun, u32 Memory_Offset, u32 Transfer_Length)
{
  static u32 Offset, Length;

  if (TransferState == TXFR_IDLE )
  {
    Offset = Memory_Offset * Mass_Block_Size[lun];
    Length = Transfer_Length * Mass_Block_Size[lun];
    TransferState = TXFR_ONGOING;
  }

  if (TransferState == TXFR_ONGOING )
  {
    if (!Block_Read_count)
    {
      MAL_Read(lun ,
               Offset ,
               Data_Buffer,
               Mass_Block_Size[lun]);

      UserToPMABufferCopy((u8 *)Data_Buffer, ENDP1_TXADDR, BULK_MAX_PACKET_SIZE);
      Block_Read_count = Mass_Block_Size[lun] - BULK_MAX_PACKET_SIZE;
      Block_offset = BULK_MAX_PACKET_SIZE;
    }
    else
    {
      UserToPMABufferCopy((u8 *)Data_Buffer + Block_offset, ENDP1_TXADDR, BULK_MAX_PACKET_SIZE);
      Block_Read_count -= BULK_MAX_PACKET_SIZE;
      Block_offset += BULK_MAX_PACKET_SIZE;
    }

    SetEPTxCount(ENDP1, BULK_MAX_PACKET_SIZE);
    SetEPTxStatus(ENDP1, EP_TX_VALID);
    Offset += BULK_MAX_PACKET_SIZE;
    Length -= BULK_MAX_PACKET_SIZE;

    CSW.dDataResidue -= BULK_MAX_PACKET_SIZE;
    Led_RW_ON();
  }
  if (Length == 0)
  {
    Block_Read_count = 0;
    Block_offset = 0;
    Offset = 0;
    Bot_State = BOT_DATA_IN_LAST;
    TransferState = TXFR_IDLE;
    Led_RW_OFF();
  }
}
Exemple #5
0
/*******************************************************************************
* Function Name  : UART_To_USB_Send_Data.
* Description    : send the received data from UART 0 to USB.
* Input          : None.
* Return         : none.
*******************************************************************************/
void USART_To_USB_Send_Data(void)
{
  if (USART_InitStructure.USART_WordLength == USART_WordLength_8b)
  {
    buffer_in[count_in] = USART_ReceiveData(USART1) & 0x7F;
  }
  else if (USART_InitStructure.USART_WordLength == USART_WordLength_9b)
  {
    buffer_in[count_in] = USART_ReceiveData(USART1);
  }
  count_in++;
  UserToPMABufferCopy(buffer_in, ENDP1_TXADDR, count_in);
  SetEPTxCount(ENDP1, count_in);
  SetEPTxValid(ENDP1);
}
/*******************************************************************************
* Function Name  : Set_CSW
* Description    : Set the SCW with the needed fields.
* Input          : u8 CSW_Status this filed can be CSW_CMD_PASSED,CSW_CMD_FAILED,
*                  or CSW_PHASE_ERROR.
* Output         : None.
* Return         : None.
*******************************************************************************/
void Set_CSW (u8 CSW_Status, u8 Send_Permission)
{
  CSW.dSignature = BOT_CSW_SIGNATURE;
  CSW.bStatus = CSW_Status;

  UserToPMABufferCopy(((u8 *)& CSW), ENDP1_TXADDR, CSW_DATA_LENGTH);

  SetEPTxCount(ENDP1, CSW_DATA_LENGTH);
  Bot_State = BOT_ERROR;
  if (Send_Permission)
  {
    Bot_State = BOT_CSW_Send;
    SetEPTxStatus(ENDP1, EP_TX_VALID);
  }

}
Exemple #7
0
//
//	仮想COMポートからのデータをPC側に返送する.
//
void EP1_IN_Callback (void)
{
#if	0
	if(	GetEPTxStatus(ENDP1) == EP_TX_VALID) return;

	int Recv_Size = USART_RecvData(Recv_Buffer);
	if(	Recv_Size ) {
		UserToPMABufferCopy(Recv_Buffer, ENDP1_TXADDR, Recv_Size);
		SetEPTxCount(ENDP1, Recv_Size);
		SetEPTxValid(ENDP1);
	}
#if	LED_DEBUG
	led2_blink(0);
#endif
#endif
	countTx = 0;
}
Exemple #8
0
/**
 * send data to USB.
 */
void usb_send_data(void) {
    uint8_t txBuffer[VIRTUAL_COM_PORT_DATA_SIZE];
    uint16_t txCount;

    if (g_usb_deviceState != CONFIGURED) {
        return;
    }

    txCount = min(usb_tx_ring_buffer.available, VIRTUAL_COM_PORT_DATA_SIZE);
    if (txCount > 0) {
        ring_buffer_read(&usb_tx_ring_buffer, txBuffer, txCount);

        UserToPMABufferCopy(txBuffer, ENDP1_TXADDR, txCount);
        SetEPTxCount(ENDP1, txCount);
        SetEPTxValid(ENDP1);
    }
}
Exemple #9
0
/*******************************************************************************
* Function Name  : DataStageIn.
* Description    : Data stage of a Control Read Transfer.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void DataStageIn(void) {
    ENDPOINT_INFO *pEPinfo = &pInformation->Ctrl_Info;
    uint32_t save_wLength = pEPinfo->Usb_wLength;
    uint32_t ControlState = pInformation->ControlState;

    uint8_t *DataBuffer;
    uint32_t Length;

    if ((save_wLength == 0) && (ControlState == LAST_IN_DATA)) {
        if (Data_Mul_MaxPacketSize == TRUE) {
            /* No more data to send and empty packet */
            Send0LengthData();
            ControlState = LAST_IN_DATA;
            Data_Mul_MaxPacketSize = FALSE;
        }
        else  {
            /* No more data to send so STALL the TX Status*/
            ControlState = WAIT_STATUS_OUT;
            vSetEPTxStatus(EP_TX_STALL);
        }
        goto Expect_Status_Out;
    }

    Length          = pEPinfo->PacketSize;
    ControlState    = (save_wLength <= Length) ? LAST_IN_DATA : IN_DATA;

    if (Length > save_wLength) {
        Length = save_wLength;
    }

    DataBuffer = (*pEPinfo->CopyData)(Length);
  
    UserToPMABufferCopy(DataBuffer, GetEPTxAddr(ENDP0), Length);

    SetEPTxCount(ENDP0, Length);

    pEPinfo->Usb_wLength -= Length;
    pEPinfo->Usb_wOffset += Length;
    vSetEPTxStatus(EP_TX_VALID);

    USB_StatusOut();/* Expect the host to abort the data IN stage */

    Expect_Status_Out:
    pInformation->ControlState = ControlState;
}
uint8_t UartUsbPutChar( Uart_t *obj, uint8_t data )
{
    if( UsbMcuIsDeviceConfigured( ) == false )
    {
        return 2;
    }

    if( IsFifoFull( &obj->FifoTx ) == false )
    {
        __disable_irq( );
        FifoPush( &obj->FifoTx, data );
        __enable_irq( );

        if( UsbPacketTx == 1 )
        {
            /*Sent flag*/
            UsbPacketTx = 0;
            SetEPTxCount( ENDP1, 0 );
            SetEPTxValid( ENDP1 );
        }
        return 0; // OK
    }
    return 1; // Busy
//    if( UsbPacketTx == 1 )
//    {
//        /*Sent flag*/
//        UsbPacketTx = 0;
//        /* send  packet to PMA*/
//        UserToPMABufferCopy( ( unsigned char* )&data, ENDP1_TXADDR, 1 );
//        SetEPTxCount( ENDP1, 1 );
//        SetEPTxValid( ENDP1 );
//        return 0; // OK
//    }
//    else
//    {
//        if( IsFifoFull( &obj->FifoTx ) == false )
//        {
//            __disable_irq( );
//            FifoPush( &obj->FifoTx, data );
//            __enable_irq( );
//            return 0; // OK
//        }
//    }
//    return 1; // Busy
}
/*******************************************************************************
* Function Name  : PIOS_HID_Reset.
* Description    : Custom HID reset routine.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void PIOS_HID_Reset(void)
{
  /* Set Joystick_DEVICE as not configured */
  pInformation->Current_Configuration = 0;
  pInformation->Current_Interface = 0;/*the default Interface*/
  
  /* Current Feature initialization */
  pInformation->Current_Feature = PIOS_HID_ConfigDescriptor[7];
  
#ifdef STM32F10X_CL   
  /* EP0 is already configured in DFU_Init() by USB_SIL_Init() function */
  
  /* Init EP1 IN as Interrupt endpoint */
  OTG_DEV_EP_Init(EP1_IN, OTG_DEV_EP_TYPE_INT, 2);
  
  /* Init EP1 OUT as Interrupt endpoint */
  OTG_DEV_EP_Init(EP1_OUT, OTG_DEV_EP_TYPE_INT, 2);
#else 
  SetBTABLE(BTABLE_ADDRESS);

  /* Initialize Endpoint 0 */
  SetEPType(ENDP0, EP_CONTROL);
  SetEPTxStatus(ENDP0, EP_TX_STALL);
  SetEPRxAddr(ENDP0, ENDP0_RXADDR);
  SetEPTxAddr(ENDP0, ENDP0_TXADDR);
  Clear_Status_Out(ENDP0);
  SetEPRxCount(ENDP0, Device_Property.MaxPacketSize);
  SetEPRxValid(ENDP0);

  /* Initialize Endpoint 1 */
  SetEPType(ENDP1, EP_INTERRUPT);
  SetEPTxAddr(ENDP1, ENDP1_TXADDR);
  SetEPRxAddr(ENDP1, ENDP1_RXADDR);
  SetEPTxCount(ENDP1, PIOS_USB_HID_DATA_LENGTH+2);  /* add two for indicating report id and valid data length */
  SetEPRxCount(ENDP1, PIOS_USB_HID_DATA_LENGTH+2);
  SetEPRxStatus(ENDP1, EP_RX_VALID);
  SetEPTxStatus(ENDP1, EP_TX_NAK);

  /* Set this device to response on default address */
  SetDeviceAddress(0);
#endif /* STM32F10X_CL */

  bDeviceState = ATTACHED;
}
/*******************************************************************************
* Function Name  : USB_SIL_Write
* Description    : Write a buffer of data to a selected endpoint.
* Input          : - bEpAddr: The address of the non control endpoint.
*                  - pBufferPointer: The pointer to the buffer of data to be written
*                    to the endpoint.
*                  - wBufferSize: Number of data to be written (in bytes).
* Output         : None.
* Return         : Status.
*******************************************************************************/
uint32_t USB_SIL_Write(uint8_t bEpAddr, uint8_t* pBufferPointer, uint32_t wBufferSize)
{
#ifndef STM32F10X_CL

  /* Use the memory interface function to write to the selected endpoint */
  UserToPMABufferCopy(pBufferPointer, GetEPTxAddr(bEpAddr & 0x7F), wBufferSize);

  /* Update the data length in the control register */
  SetEPTxCount((bEpAddr & 0x7F), wBufferSize);
  
#else
  
   /* Use the PCD interface layer function to write to the selected endpoint */
   PCD_EP_Write (bEpAddr, pBufferPointer, wBufferSize); 
   
#endif /* STM32F10X_CL */

  return 0;
}
Exemple #13
0
void monkey_ep_reset(void) {
  int i;

  /* Set Joystick_DEVICE as not configured */
  pInformation->Current_Configuration = 0;
  pInformation->Current_Interface = 0;/*the default Interface*/

  /* Current Feature initialization */
  pInformation->Current_Feature = config1_descriptor[7];

  for(i=0; i<8; ++i) {
    if(ep_conf_list[i].direct==0) continue;
    
		switch(ep_conf_list[i].attr) {
			case 0x00:
        SetEPType(i, EP_BULK);
        ClearEPDoubleBuff(i);
        break;
			case 0x01:
        SetEPType(i, EP_CONTROL);
        Clear_Status_Out(i);
        break;
			case 0x02:
        SetEPType(i, EP_ISOCHRONOUS);
        break;
			case 0x03:
        SetEPType(i, EP_INTERRUPT);
        break;
		}

    if(ep_conf_list[i].direct & EP_IN) {
      SetEPTxStatus(i, ep_conf_list[i].tx_status);
      SetEPTxAddr(i, ep_conf_list[i].tx_addr);
      SetEPTxCount(i, ep_conf_list[i].tx_max);
    }
    if(ep_conf_list[i].direct & EP_OUT) {
      SetEPRxAddr(i, ep_conf_list[i].rx_addr);
      SetEPRxCount(i, ep_conf_list[i].rx_max);
      SetEPRxStatus(i, ep_conf_list[i].rx_status);
    }
	}
}
Exemple #14
0
/*******************************************************************************
* Function Name  : EP1_IN_Callback
* Description    :
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void EP1_IN_Callback (void)
{
	uint16_t USB_Tx_ptr;
	uint16_t USB_Tx_length;

	if (USB_Tx_State == 1)
	{
		if (caribou_bytequeue_level(caribou_uart_rx_queue(CONSOLE_USART)) == 0) 
		{
			USB_Tx_State = 0;
		}
		else 
		{
			USB_Tx_length = caribou_bytequeue_gets(caribou_uart_rx_queue(CONSOLE_USART),USART_Rx_Buffer,VIRTUAL_COM_PORT_DATA_SIZE);
			UserToPMABufferCopy(&USART_Rx_Buffer, ENDP1_TXADDR, USB_Tx_length);
			SetEPTxCount(ENDP1, USB_Tx_length);
			SetEPTxValid(ENDP1); 
		}
	}
}
static void PIOS_USB_RCTX_SendReport(struct pios_usb_rctx_dev *usb_rctx_dev)
{
#ifdef PIOS_INCLUDE_FREERTOS
    bool need_yield = false;
#endif /* PIOS_INCLUDE_FREERTOS */

    usb_rctx_dev->report.id = 3; /* FIXME: shouldn't hard-code this report ID */

    UserToPMABufferCopy((uint8_t *)&usb_rctx_dev->report,
                        GetEPTxAddr(usb_rctx_dev->cfg->data_tx_ep),
                        sizeof(usb_rctx_dev->report));

    SetEPTxCount(usb_rctx_dev->cfg->data_tx_ep, sizeof(usb_rctx_dev->report));
    SetEPTxValid(usb_rctx_dev->cfg->data_tx_ep);

#ifdef PIOS_INCLUDE_FREERTOS
    if (need_yield) {
        vPortYield();
    }
#endif /* PIOS_INCLUDE_FREERTOS */
}
void EP1_IN_Callback (void)
{
    UsbPacketTx = 1;
    
    UsbTxLength = 0;
    
    while( IsFifoEmpty( &UartUsb.FifoTx ) == false )
    {
        UsbTxBuffer[UsbTxLength] = FifoPop( &UartUsb.FifoTx );
        UsbTxLength++;
    }

    if( UsbTxLength > 0 )
    {
        UsbPacketTx = 0;
        UserToPMABufferCopy( ( unsigned char* )UsbTxBuffer, ENDP1_TXADDR, UsbTxLength );
        SetEPTxCount( ENDP1, UsbTxLength );
        SetEPTxValid( ENDP1 );

    }
}
/*
 * This code has been adapted from the ST Microelectronics CDC
 * Example, which is covered under the V2 Liberty License:
 * http://www.st.com/software_license_agreement_liberty_v2
 */
static void usb_handle_transfer(void)
{
        portBASE_TYPE hpta = false;
        xQueueHandle queue = serial_get_tx_queue(usb_state.serial);
        uint8_t *buff = usb_state.USB_Tx_Buffer;
        size_t len = 0;

        for (; len < VIRTUAL_COM_PORT_DATA_SIZE; ++len)
                if (!xQueueReceiveFromISR(queue, buff + len, &hpta))
                        break;

        /* Check if we actually have something to send */
	if (len) {
                UserToPMABufferCopy(usb_state.USB_Tx_Buffer,
                                    ENDP1_TXADDR, len);
                SetEPTxCount(ENDP1, len);
                SetEPTxValid(ENDP1);
        }

        portEND_SWITCHING_ISR(hpta);
}
Exemple #18
0
/*******************************************************************************
* Function Name  : EP1_IN_Callback
* Description    :
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void EP1_IN_Callback (void)
{
  uint16_t USB_Tx_ptr;
  uint16_t USB_Tx_length;
  
  if (USB_Tx_State == 1)
  {
    if (USART_Rx_length == 0) 
    {
      USB_Tx_State = 0;
    }
    else 
    {
      if (USART_Rx_length > VIRTUAL_COM_PORT_DATA_SIZE)
	  {
        USB_Tx_ptr = USART_Rx_ptr_out;
        USB_Tx_length = VIRTUAL_COM_PORT_DATA_SIZE;
        
        USART_Rx_ptr_out += VIRTUAL_COM_PORT_DATA_SIZE;
        USART_Rx_length -= VIRTUAL_COM_PORT_DATA_SIZE;    
      }
      else 
      {
        USB_Tx_ptr = USART_Rx_ptr_out;
        USB_Tx_length = USART_Rx_length;
        
        USART_Rx_ptr_out += USART_Rx_length;
        USART_Rx_length = 0;
      }
      
#ifdef USE_STM3210C_EVAL
      USB_SIL_Write(EP1_IN, &USART_Rx_Buffer[USB_Tx_ptr], USB_Tx_length);  
#else
      UserToPMABufferCopy(&USART_Rx_Buffer[USB_Tx_ptr], ENDP1_TXADDR, USB_Tx_length);
      SetEPTxCount(ENDP1, USB_Tx_length);
      SetEPTxValid(ENDP1); 
#endif  
    }
  }
}
/*******************************************************************************
* Function Name  : Read_Memory
* Description    : Handle the Read operation from the microSD card. 
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void Read_Memory(void)
{ //unsigned int a=0,b=0;	 
	NAND_ADDRESS Nand_Addr;
 // GPIO_SetBits(GPIOB, GPIO_Pin_5);
  if (!Block_Read_count)
  {	
		//NAND_ConvertOffsetToAddress(Memory_Offset, 64, &Nand_Addr);
		NAND_ConvertOffsetToAddress(Memory_Offset, 2048, &Nand_Addr);
		NAND_ReadSmallPage(Data1_Buffer, Nand_Addr, 1);
		//NAND_ReadSpareArea(Data1_Buffer, Nand_Addr, 1);
    UserToPMABufferCopy(Data1_Buffer, ENDP1_TXADDR, BULK_MAX_PACKET_SIZE);
    Block_Read_count = 2048 - BULK_MAX_PACKET_SIZE;
		//Block_Read_count = 64 - BULK_MAX_PACKET_SIZE;
    Block_offset = BULK_MAX_PACKET_SIZE;	 
  }
  else
  {
    UserToPMABufferCopy(Data1_Buffer + Block_offset, ENDP1_TXADDR, BULK_MAX_PACKET_SIZE);
    Block_Read_count -= BULK_MAX_PACKET_SIZE;
    Block_offset += BULK_MAX_PACKET_SIZE;
  }

  SetEPTxCount(ENDP1, BULK_MAX_PACKET_SIZE);
  SetEPTxStatus(ENDP1, EP_TX_VALID);

  Memory_Offset += BULK_MAX_PACKET_SIZE;
  Transfer_Length -= BULK_MAX_PACKET_SIZE;

  CSW.dDataResidue -= BULK_MAX_PACKET_SIZE;
  //Led_RW_ON();

  if (Transfer_Length == 0)
  {
    Block_Read_count = 0;
    Block_offset = 0;
    Memory_Offset = 0;
    Bot_State = BOT_DATA_IN_LAST;
    //Led_RW_OFF();
  }
}
/*******************************************************************************
* Function Name  : DataStageIn.
* Description    : Data stage of a Control Read Transfer.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void DataStageIn(void)
{
  ENDPOINT_INFO *pEPinfo = &pInformation->Ctrl_Info;
  u32 save_wLength = pEPinfo->Usb_wLength;
  u32 ControlState = pInformation->ControlState;

  u8 *DataBuffer;
  u32 Length;

  if ((save_wLength == 0) && (ControlState == LAST_IN_DATA))
  {
    /* no more data to send so STALL the TX Status*/
    ControlState = WAIT_STATUS_OUT;
    vSetEPTxStatus(EP_TX_STALL);
    goto Expect_Status_Out;
  }

  Length = pEPinfo->PacketSize;
  ControlState = (save_wLength <= Length) ? LAST_IN_DATA : IN_DATA;

  if (Length > save_wLength)
  {
    Length = save_wLength;
  }

  DataBuffer = (*pEPinfo->CopyData)(Length);

  UserToPMABufferCopy(DataBuffer, GetEPTxAddr(ENDP0), Length);

  SetEPTxCount(ENDP0, Length);

  pEPinfo->Usb_wLength -= Length;
  pEPinfo->Usb_wOffset += Length;
  vSetEPTxStatus(EP_TX_VALID);

  USB_StatusOut();/* Expect the host to abort the data IN stage */

Expect_Status_Out:
  pInformation->ControlState = ControlState;
}
/*******************************************************************************
* Function Name  : OTPWriter_Reset.
* Description    : OTPWriter Mouse reset routine.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void OTPWriter_Reset(void)
{
  /* Set OTPWriter_DEVICE as not configured */
  pInformation->Current_Configuration = 0;
  pInformation->Current_Interface = 0;/*the default Interface*/

  /* Current Feature initialization */
  pInformation->Current_Feature = OTPWriter_ConfigDescriptor[7];

  SetBTABLE(BTABLE_ADDRESS);

  /* Initialize Endpoint 0 */
  SetEPType(ENDP0, EP_CONTROL);
  SetEPTxStatus(ENDP0, EP_TX_STALL);
  SetEPRxAddr(ENDP0, ENDP0_RXADDR);
  SetEPTxAddr(ENDP0, ENDP0_TXADDR);
  Clear_Status_Out(ENDP0);
  SetEPRxCount(ENDP0, Device_Property.MaxPacketSize);
  SetEPRxValid(ENDP0);

  /* Initialize Endpoint 1 */
  SetEPType(ENDP1, EP_INTERRUPT);
  SetEPRxAddr(ENDP1, ENDP1_RXADDR);
  SetEPRxCount(ENDP1, ReceiveLength);
  SetEPRxStatus(ENDP1, EP_RX_VALID);
  //SetEPTxStatus(ENDP1, EP_TX_DIS);

  /* Initialize Endpoint 2 */
  SetEPType(ENDP2, EP_INTERRUPT);
  SetEPTxAddr(ENDP2, ENDP2_TXADDR);
  SetEPTxCount(ENDP2, SendLength);
  // SetEPTxStatus(ENDP2, EP_TX_DIS);
  SetEPTxStatus(ENDP2, EP_TX_NAK);

  bDeviceState = ATTACHED;

  /* Set this device to response on default address */
  SetDeviceAddress(0);
}
Exemple #22
0
void EP7_IN_Callback (void)
{
  if (USB_Tx_State == 1)
  {
    u8_t *buf;
    int avail = ringbuf_available_linear(&tx_rb, &buf);
    if (avail  == 0) {
      USB_Tx_State = 0;
      return;
    }

    if (avail > VIRTUAL_COM_PORT_DATA_SIZE)
    {
      avail = VIRTUAL_COM_PORT_DATA_SIZE;
    }

    UserToPMABufferCopy(buf, ENDP7_TXADDR, avail);
    ringbuf_get(&tx_rb, 0, avail);
    SetEPTxCount(ENDP7, avail);
    SetEPTxValid(ENDP7);
  }
}
Exemple #23
0
/*******************************************************************************
* Function Name  : CustomHID_Reset.
* Description    : Custom HID reset routine.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void CustomHID_Reset(void)
{
  /* Set Joystick_DEVICE as not configured */
  pInformation->Current_Configuration = 0;
  pInformation->Current_Interface = 0;/*the default Interface*/
  
  /* Current Feature initialization */
  pInformation->Current_Feature = CustomHID_ConfigDescriptor[7];
  
  *(volatile unsigned *)(0x40005C50L)=(0x00&0xFFF8);//设置USB分组缓冲区描述表起始地址:0

  /* Initialize Endpoint 0 */
  //设置EP0控制端点	 ENDP0   ((u8)0)   EP_CONTROL     (0x0200)
  *(((volatile unsigned *)(0x40005C00L)) + ENDP0)=((_GetENDPOINT(ENDP0) & 0x898f) | EP_CONTROL);
  SetEPTxStatus(ENDP0, EP_TX_STALL);	  //设置EP0端点发送延迟
  SetEPRxAddr(ENDP0, ENDP0_RXADDR);		  //设置EP0的接受地址  ENDP0_RXADDR        (0x18)
  SetEPTxAddr(ENDP0, ENDP0_TXADDR);		  //设置EP0的发送地址  ENDP0_TXADDR        (0x58)
  _ClearEP_KIND(ENDP0);					  //设置端点EP0的类型DBL_BUF 双缓冲端点
  SetEPRxCount(ENDP0, Device_Property.MaxPacketSize);	//设置EP0的计数器的值
  _SetEPRxStatus(ENDP0, EP_RX_VALID);					  //设置端点接受有效 EP_RX_VALID=0x3000

  /* Initialize Endpoint 1 */
     SetEPType(ENDP1, EP_INTERRUPT);
     SetEPRxAddr(ENDP1, ENDP1_RXADDR);	//ADDR内部寄存器被用作当前缓冲区的指针 ENDP1_RXADDR=(0x98)
     SetEPRxCount(ENDP1, 22);			//COUNT寄存器用于记录剩下未传输的字节数
     SetEPRxStatus(ENDP1, EP_RX_VALID);	//设置端点接受有效 EP_RX_VALID=0x3000

  /* Initialize Endpoint 2 */
     SetEPType(ENDP2, EP_INTERRUPT);
     SetEPTxAddr(ENDP2, ENDP2_TXADDR);
     SetEPTxCount(ENDP2, 22);
     SetEPTxStatus(ENDP2, EP_TX_NAK);//设置端点发送不应答 EP_TX_NAK=(0x0020)

  bDeviceState = ATTACHED;	//ATTACHED=1
  
  /* Set this device to response on default address */
  SetDeviceAddress(0);
}
Exemple #24
0
/*******************************************************************************
* Function Name  : EP1_IN_Callback
* Description    :
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void EP1_IN_Callback (void)
{
  uint16_t USB_Tx_ptr;
  uint16_t USB_Tx_length;
  
  if (USB_Tx_State == 1)
  {
    if (USART_Rx_length == 0) 
    {
      USB_Tx_State = 0;
    }
    else 
    {
      if (USART_Rx_length > VIRTUAL_COM_PORT_DATA_SIZE){
        USB_Tx_ptr = USART_Rx_ptr_out;
        USB_Tx_length = VIRTUAL_COM_PORT_DATA_SIZE;
        
        USART_Rx_ptr_out += VIRTUAL_COM_PORT_DATA_SIZE;
        USART_Rx_length -= VIRTUAL_COM_PORT_DATA_SIZE;    
      }
      else 
      {
        USB_Tx_ptr = USART_Rx_ptr_out;
        USB_Tx_length = USART_Rx_length;
        
        USART_Rx_ptr_out += USART_Rx_length;
        USART_Rx_length = 0;
      }
      UserToPMABufferCopy(&USART_Rx_Buffer[USB_Tx_ptr], ENDP1_TXADDR, USB_Tx_length);
      SetEPTxCount(ENDP1, USB_Tx_length);
      SetEPTxValid(ENDP1); 

      //dbg_print("USB Tx\r\n");
    }
  }
}
Exemple #25
0
vsf_err_t stm32_usbd_ep_set_IN_epsize(uint8_t idx, uint16_t epsize)
{
	int8_t index;
	
	index = stm32_usbd_get_ep(idx);
	if (index < 0)
	{
		return VSFERR_FAIL;
	}
	idx = (uint8_t)index;
	
	if ((EP_Cfg_Ptr - epsize) < STM32_USBD_EP_NUM * 8)
	{
		return VSFERR_NOT_ENOUGH_RESOURCES;
	}
	
	stm32_usbd_IN_epsize[idx] = epsize;
	SetEPTxCount(idx, epsize);
	// fix for 16-bit aligned memory
	EP_Cfg_Ptr -= epsize & 1 ? epsize + 1 : epsize;
	SetEPTxAddr(idx, EP_Cfg_Ptr);
	SetEPTxStatus(idx, EP_TX_NAK);
	return VSFERR_NONE;
}
Exemple #26
0
/*******************************************************************************
* Function Name  : NoData_Setup0.
* Description    : Proceed the processing of setup request without data stage.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void NoData_Setup0(void) {
	RESULT Result = USB_UNSUPPORT;
	uint32_t RequestNo = pInformation->USBbRequest;
	uint32_t ControlState;

	if (Type_Recipient == (STANDARD_REQUEST | DEVICE_RECIPIENT)) {
		// Device Request
		// SET_CONFIGURATION
		if (RequestNo == SET_CONFIGURATION) Result = Standard_SetConfiguration();
		// SET ADDRESS
		else if (RequestNo == SET_ADDRESS) {
			if ((pInformation->USBwValue0 > 127) || (pInformation->USBwValue1 != 0)
					|| (pInformation->USBwIndex != 0)
					|| (pInformation->Current_Configuration != 0)) {
				// Device Address should be 127 or less
				ControlState = STALLED;
				pInformation->ControlState = ControlState;

				return;
			} else Result = USB_SUCCESS;
		} else if (RequestNo == SET_FEATURE) {
			// SET FEATURE for Device
			if ((pInformation->USBwValue0 == DEVICE_REMOTE_WAKEUP)
					&& (pInformation->USBwIndex == 0)) {
				Result = Standard_SetDeviceFeature();
			} else {
				Result = USB_UNSUPPORT;
			}
		} else if (RequestNo == CLEAR_FEATURE) {
			// Clear FEATURE for Device
			if (pInformation->USBwValue0 == DEVICE_REMOTE_WAKEUP
					&& pInformation->USBwIndex == 0
					&& ValBit(pInformation->Current_Feature, 5)) {
				Result = Standard_ClearFeature();
			} else {
				Result = USB_UNSUPPORT;
			}
		}
	} else if (Type_Recipient == (STANDARD_REQUEST | INTERFACE_RECIPIENT)) {
		// Interface Request
		// SET INTERFACE
		if (RequestNo == SET_INTERFACE) Result = Standard_SetInterface();
	} else if (Type_Recipient == (STANDARD_REQUEST | ENDPOINT_RECIPIENT)) {
		// EndPoint Request
		// CLEAR FEATURE for EndPoint
		if (RequestNo == CLEAR_FEATURE) {
			Result = Standard_ClearFeature();
		} else if (RequestNo == SET_FEATURE) {
		    // SET FEATURE for EndPoint
			Result = Standard_SetEndPointFeature();
		}
	} else Result = USB_UNSUPPORT;

	if (Result != USB_SUCCESS) {
		Result = (*pProperty->Class_NoData_Setup)(RequestNo);
		if (Result == USB_NOT_READY) {
			ControlState = PAUSE;
			pInformation->ControlState = ControlState;

			return;
		}
	}

	if (Result != USB_SUCCESS) {
		ControlState = STALLED;
		pInformation->ControlState = ControlState;

		return;
	}

	ControlState = WAIT_STATUS_IN; // After no data stage SETUP
	SetEPTxCount(ENDP0,0);
	SaveTState = EP_TX_VALID;
	pInformation->ControlState = ControlState;

	return;
}
Exemple #27
0
/*******************************************************************************
* Function Name  : EP1_Send_Callback.
* Description    : EP1 Sending data Callback Routine.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void EP1_Send_Callback(void)
{
  UserToPMABufferCopy((u8 *)USB_S_Buffer, ENDP1_TXADDR, USB_S_Size);
  SetEPTxCount(ENDP1, USB_S_Size);
  SetEPTxStatus(ENDP1, EP_TX_VALID);
}
void dfu_main(void)
{
    int send_report;
    uint8_t kbd_report_loc[KBD_SIZE];

#if defined (USE_STM32L152D_EVAL)
    FLASH_Unlock();
    FLASH_ClearFlag(FLASH_FLAG_OPTVERRUSR);
#endif

    Pointer = (uint32_t)&_application_start;

    DeviceState = STATE_dfuERROR;
    DeviceStatus[0] = STATUS_ERRFIRMWARE;
    DeviceStatus[4] = DeviceState;

    usb_cable_reset();

    Set_System();

    matrix_init_all();
    led_init_all();
    matrix_scan_init();

    leds_override = LEDS_OVERRIDE_STARTUP;
    usb_report_sent = 1;
    Set_USBClock();
    USB_Init();

    matrix_scan_start();

    /* Main loop */
    send_report = 0;
    while (1){

	if (unlikely(do_usb_resume)){
	    /* Check if the remote wakeup feature is enabled (it could be disabled
	     * by the host through ClearFeature request)
	     */
	    if (bDeviceState != SUSPENDED) {
		/* do nothing */
		do_usb_resume = 0;
	    } else
	    if (usb_remote_wakeup_enabled()) {
		Resume(RESUME_INTERNAL);
		do_usb_resume = 0;
	    } else {
		/* resume disabled, disable kbd-triggered wakeup and go to the suspend state */
		matrix_idle_wakeup_event_leave();
		/* clear flag before suspend
		 * because the flag can be set again on resume
		 */
		do_usb_resume = 0; 
		Suspend_Low();
	    }
	    continue;
	}

	if (bDeviceState != CONFIGURED){
	    __WFI(); /* Wait for interrupt */
	    continue;
	}

	if (unlikely(leds_override)){
	    handle_leds_override();
	}

	__disable_irq();
	if ((kbd_report_status & REPORT_STATUS_DONE) && usb_report_sent){
	    kbd_report_status &= ~REPORT_STATUS_DONE;
	    send_report = 1;
	    memcpy((void*)kbd_report_loc, (void*)kbd_report_fullscan, KBD_SIZE);
	}
	if (unlikely((usb_report_idle_timer == 0) && (usb_report_idle != 0))){
	    send_report = 1;
	    usb_report_idle_timer = usb_report_idle;
	}
	__enable_irq();

	if (send_report){
	    usb_report_sent = 0;
	    send_report = 0;
	    USB_SIL_Write(EP1_IN, kbd_report_loc, KBD_SIZE);
	    SetEPTxCount(ENDP1, KBD_SIZE);
	    SetEPTxValid(ENDP1);
	}

	__WFI(); /* Wait for interrupt */
    }
}
Exemple #29
0
void usb_SendData(unsigned char *pData, int length)
{
	volatile int i = 0;
        unsigned int	delay_cnt;
        
#if (USB_DEVICE_CONFIG & _USE_USB_VIRTUAL_COMM_DEVICE)        
	int batch = length/VIRTUAL_COM_PORT_DATA_SIZE;
	int res	  = length%VIRTUAL_COM_PORT_DATA_SIZE;
#endif 
	

#if(USB_DEVICE_CONFIG & _USE_USB_KEYBOARD_DEVICE)
	if (g_usb_type == USB_KEYBOARD)	//按键
	{
		count_in = length;
		UserToPMABufferCopy(pData, GetEPTxAddr(ENDP1), count_in);
		SetEPTxCount(ENDP1, count_in);
		/* enable endpoint for transmission */
		SetEPTxValid(ENDP1);
		//StartDelay(600);	//3S的延时
		delay_cnt = 300;
		while (count_in != 0 && delay_cnt != 0 &&(bDeviceState == CONFIGURED))
		{
			delay_cnt--;
			delay_ms(10);
		}
	}
	else 
#elif (USB_DEVICE_CONFIG & _USE_USB_VIRTUAL_COMM_DEVICE)
	if(g_usb_type == USB_VIRTUAL_PORT)
	{
		for (i = 0; i < batch; i++)
		{
			count_in	= VIRTUAL_COM_PORT_DATA_SIZE;
			UserToPMABufferCopy(pData+i*VIRTUAL_COM_PORT_DATA_SIZE, ENDP1_TXADDR, count_in);
			SetEPTxCount(ENDP1, count_in);
			SetEPTxValid(ENDP1);
			//StartDelay(600);
			delay_cnt = 300;
			while (count_in != 0 && delay_cnt != 0 && (bDeviceState == CONFIGURED))
			{
				delay_cnt--;
				delay_ms(10);
			}
		}
		if (res > 0)
		{
			//最后一包
			count_in	= res;
			UserToPMABufferCopy(pData+batch*VIRTUAL_COM_PORT_DATA_SIZE, ENDP1_TXADDR, count_in);
			SetEPTxCount(ENDP1, count_in);
			SetEPTxValid(ENDP1);
			//StartDelay(600);
			delay_cnt = 300;
			while (count_in != 0 && delay_cnt != 0 &&(bDeviceState == CONFIGURED))
			{
				delay_cnt--;
				delay_ms(10);
			}
		}
	}//Virtual port
	else 
#elif (USB_DEVICE_CONFIG & _USE_USB_MASS_STOARGE_DEVICE)
#ifdef DUMMY_FAT_FS
	if((g_usb_type == USB_MASSSTORAGE)&&(g_mass_storage_device_type == MASSTORAGE_DEVICE_TYPE_DUMMY_FAT))
	{
		if (length > G_SEND_BUF_LENGTH)
		{
			length = G_SEND_BUF_LENGTH;
		}
		MEMCPY(g_send_buff,pData,length);
	}//USB_Masstorage
#endif
#endif
        ;
}
Exemple #30
0
void SendData_To_PC(unsigned char *pData, int length)
{
	volatile int i = 0;
	int batch = length/VIRTUAL_COM_PORT_DATA_SIZE;
	int res	  = length%VIRTUAL_COM_PORT_DATA_SIZE;
	unsigned int	delay_cnt;

	if (g_usb_type == USB_KEYBOARD)	//按键
	{
		count_in = length;
		UserToPMABufferCopy(pData, GetEPTxAddr(ENDP1), count_in);
		SetEPTxCount(ENDP1, count_in);
		/* enable endpoint for transmission */
		SetEPTxValid(ENDP1);
		//StartDelay(600);	//3S的延时
		delay_cnt = 300;
		while (count_in != 0 && delay_cnt != 0 &&(bDeviceState == CONFIGURED))
		{
			delay_cnt--;
			Delay(20000);
		}
	}
	else if(g_usb_type == USB_VIRTUAL_PORT)
	{
		for (i = 0; i < batch; i++)
		{
			count_in	= VIRTUAL_COM_PORT_DATA_SIZE;
			UserToPMABufferCopy(pData+i*VIRTUAL_COM_PORT_DATA_SIZE, ENDP1_TXADDR, count_in);
			SetEPTxCount(ENDP1, count_in);
			SetEPTxValid(ENDP1);
			//StartDelay(600);
			delay_cnt = 300;
			while (count_in != 0 && delay_cnt != 0 && (bDeviceState == CONFIGURED))
			{
				delay_cnt--;
				Delay(20000);
			}
		}
		if (res > 0)
		{
			//最后一包
			count_in	= res;
			UserToPMABufferCopy(pData+batch*VIRTUAL_COM_PORT_DATA_SIZE, ENDP1_TXADDR, count_in);
			SetEPTxCount(ENDP1, count_in);
			SetEPTxValid(ENDP1);
			//StartDelay(600);
			delay_cnt = 300;
			while (count_in != 0 && delay_cnt != 0 &&(bDeviceState == CONFIGURED))
			{
				delay_cnt--;
				Delay(20000);
			}
		}
	}//Virtual port
	else
	{
		if (length > G_SEND_BUF_LENGTH)
		{
			length = G_SEND_BUF_LENGTH;
		}
		memcpy(g_send_buff,pData,length);
	}//USB_Masstorage
	
}