Exemplo n.º 1
0
static inline uint8_t usbd_cdc_transfer(void *pdev)
{
	if (sended != 0 || rndis_tx_ptr == NULL || rndis_tx_size <= 0) return USBD_OK;
	if (rndis_first_tx)
	{
		static uint8_t first[RNDIS_DATA_IN_SZ];
		rndis_data_packet_t *hdr;

		hdr = (rndis_data_packet_t *)first;
		memset(hdr, 0, sizeof(rndis_data_packet_t));
		hdr->MessageType = REMOTE_NDIS_PACKET_MSG;
		hdr->MessageLength = sizeof(rndis_data_packet_t) + rndis_tx_size;
		hdr->DataOffset = sizeof(rndis_data_packet_t) - offsetof(rndis_data_packet_t, DataOffset);
		hdr->DataLength = rndis_tx_size;

		sended = RNDIS_DATA_IN_SZ - sizeof(rndis_data_packet_t);
		if (sended > rndis_tx_size) sended = rndis_tx_size;
		memcpy(first + sizeof(rndis_data_packet_t), rndis_tx_ptr, sended);

		DCD_EP_Tx(pdev, RNDIS_DATA_IN_EP, (uint8_t *)&first, sizeof(rndis_data_packet_t) + sended);
	}
	else
	{
		int n = rndis_tx_size;
		if (n > RNDIS_DATA_IN_SZ) n = RNDIS_DATA_IN_SZ;
		DCD_EP_Tx(pdev, RNDIS_DATA_IN_EP, rndis_tx_ptr, n);
		sended = n;
	}
	return USBD_OK;
}
Exemplo n.º 2
0
/**
  * @brief  usbd_audio_DataIn
  *         Data sent on non-control IN endpoint
  * @param  pdev: device instance
  * @param  epnum: endpoint number
  * @retval status
  */
uint8_t  usbd_cdc_DataIn (void *pdev, uint8_t epnum)
{
	(void)pdev;
	(void)epnum;
  uint16_t USB_Tx_ptr;
  uint16_t USB_Tx_length;
  
  if (USB_Tx_State == USB_CDC_BUSY)
  {
    if (APP_Rx_length == 0) 
    {
      USB_Tx_State = USB_CDC_IDLE;
    }
    else 
    {
      if (APP_Rx_length > CDC_DATA_IN_PACKET_SIZE){
        USB_Tx_ptr = APP_Rx_ptr_out;
        USB_Tx_length = CDC_DATA_IN_PACKET_SIZE;
        
        APP_Rx_ptr_out += CDC_DATA_IN_PACKET_SIZE;
        APP_Rx_length -= CDC_DATA_IN_PACKET_SIZE;    
      }
      else 
      {
        USB_Tx_ptr = APP_Rx_ptr_out;
        USB_Tx_length = APP_Rx_length;
        
        APP_Rx_ptr_out += APP_Rx_length;
        APP_Rx_length = 0;
        if(USB_Tx_length == CDC_DATA_IN_PACKET_SIZE)
        {
          USB_Tx_State = USB_CDC_ZLP;
        }
      }
      
      /* Prepare the available data buffer to be sent on IN endpoint */
      DCD_EP_Tx (pdev,
                 CDC_IN_EP,
                 (uint8_t*)&APP_Rx_Buffer[USB_Tx_ptr],
                 USB_Tx_length);
      return USBD_OK;
    }
  }  
  
  /* Avoid any asynchronous transfer during ZLP */
  if (USB_Tx_State == USB_CDC_ZLP)
  {
    /*Send ZLP to indicate the end of the current transfer */
    DCD_EP_Tx (pdev,
               CDC_IN_EP,
               NULL,
               0);
    
    USB_Tx_State = USB_CDC_IDLE;
  }
  return USBD_OK;
}
Exemplo n.º 3
0
/**
  * @brief  usbd_audio_DataIn
  *         Data sent on non-control IN endpoint
  * @param  pdev: device instance
  * @param  epnum: endpoint number
  * @retval status
  */
uint8_t  usbd_cdc_DataIn (void *pdev, uint8_t epnum)
{
  uint16_t USB_Tx_ptr;
  uint16_t USB_Tx_length;
  
  if (USB_Tx_State == 1)
  {
    if (APP_Rx_length == 0) 
    {
      if (last_packet ==1)
      {
        last_packet =0;
        
        /*Send zero-length packet*/
        DCD_EP_Tx (pdev, CDC_IN_EP, 0, 0);
      }
      else
      {
        USB_Tx_State = 0;
      }
    }
    else 
    {
      if (APP_Rx_length > CDC_DATA_IN_PACKET_SIZE){
        USB_Tx_ptr = APP_Rx_ptr_out;
        USB_Tx_length = CDC_DATA_IN_PACKET_SIZE;
        
        APP_Rx_ptr_out += CDC_DATA_IN_PACKET_SIZE;
        APP_Rx_length -= CDC_DATA_IN_PACKET_SIZE;    
      }
      else 
      {
        USB_Tx_ptr = APP_Rx_ptr_out;
        USB_Tx_length = APP_Rx_length;
        
        APP_Rx_ptr_out += APP_Rx_length;
        APP_Rx_length = 0;
        if (APP_Rx_length == CDC_DATA_IN_PACKET_SIZE) last_packet = 1;
      }
      
      /* Prepare the available data buffer to be sent on IN endpoint */
      DCD_EP_Tx (pdev,
                 CDC_IN_EP,
                 (uint8_t*)&APP_Rx_Buffer[USB_Tx_ptr],
                 USB_Tx_length);
    }
  }  
  
  return USBD_OK;
}
Exemplo n.º 4
0
/**
 * @brief  USBD_CDC_DataIn
 *         Data sent on non-control IN endpoint
 * @param  pdev: device instance
 * @param  epnum: endpoint number
 * @retval status
 */
static uint8_t  USBD_CDC_DataIn (void *pdev, uint8_t epnum)
{
	uint16_t i;

	if (USBD_CDC_InFlight != 0) {
		USBD_CDC_InFlight = 0;
	}

	if (ringbuffer_isempty(&USBD_CDC_D2H_FIFO) == 0)
	{
		for (i = 0; i < CDC_DATA_IN_PACKET_SIZE && ringbuffer_isempty(&USBD_CDC_D2H_FIFO) == 0; i++) {
			USBD_CDC_D2H_Buff[i] = ringbuffer_pop(&USBD_CDC_D2H_FIFO);
		}
		dbgwdg_feed();
		DCD_EP_Tx (pdev,
					USBD_Dev_CDC_D2H_EP,
					(uint8_t*)USBD_CDC_D2H_Buff,
					i);
		USBD_CDC_InFlight = 1;
	}

	if (USBD_CDC_InFlight == 0) {
		DCD_EP_Flush(pdev, epnum);
	}

	return USBD_OK;
}
Exemplo n.º 5
0
/**
  * @brief  usbd_audio_DataIn
  *         Data sent on non-control IN endpoint
  * @param  pdev: device instance
  * @param  epnum: endpoint number
  * @retval status
  */
static uint8_t  usbd_cdc_DataIn (void *pdev, uint8_t epnum)
{
  uint32_t USB_Tx_length;

  usbd_cdc_Change_Open_State(1);

  if (!USB_Tx_State)
    return USBD_OK;

  USB_Tx_length = ring_data_contig(USB_TX_BUFFER_SIZE, USB_Tx_Buffer_head, USB_Tx_Buffer_tail);

  if (USB_Tx_length) {
    USB_Tx_length = MIN(USB_Tx_length, CDC_DATA_IN_PACKET_SIZE);
  } else if (usbd_Last_Tx_Packet_size(pdev, epnum) != CDC_DATA_IN_PACKET_SIZE) {
    USB_Tx_State = 0;
    return USBD_OK;
  }

  /* Prepare the available data buffer to be sent on IN endpoint */
  DCD_EP_Tx (pdev,
             CDC_IN_EP,
             (uint8_t*)&USB_Tx_Buffer[USB_Tx_Buffer_tail],
             USB_Tx_length);

  USB_Tx_Buffer_tail = ring_wrap(USB_TX_BUFFER_SIZE, USB_Tx_Buffer_tail + USB_Tx_length);
  return USBD_OK;
}
Exemplo n.º 6
0
/**
  * @brief  usbd_audio_DataIn
  *         Data sent on non-control IN endpoint
  * @param  pdev: device instance
  * @param  epnum: endpoint number
  * @retval status
  */
static uint8_t  usbd_cdc_DataIn (void *pdev, uint8_t epnum)
{
  if (USB_Tx_State == 1)
  {
    unsigned char USB_TX_Buffer[CDC_DATA_IN_PACKET_SIZE];
    int USB_Tx_length = 0;

    // try and fill the buffer
    int c;
    while (USB_Tx_length<CDC_DATA_IN_PACKET_SIZE &&
           ((c = jshGetCharToTransmit(EV_USBSERIAL)) >= 0) ) { // get byte to transmit
      USB_TX_Buffer[USB_Tx_length++] = c;
    }

    // if nothing, set state to 0
    if (USB_Tx_length==0) {
      USB_Tx_State = 0;
      return USBD_OK;
    }
      
    /* Prepare the available data buffer to be sent on IN endpoint */
    DCD_EP_Tx (pdev,
               CDC_IN_EP,
               (uint8_t*)USB_TX_Buffer,
               USB_Tx_length);
  }  
  
  return USBD_OK;
}
Exemplo n.º 7
0
/**
  * @brief  Handle_USBAsynchXfer
  *         Send data to USB
  * @param  pdev: instance
  * @retval None
  */
static void Handle_USBAsynchXfer (void *pdev)
{
  if(USB_Tx_State != 1)
  {
    unsigned char USB_TX_Buffer[CDC_DATA_IN_PACKET_SIZE];
    int USB_Tx_length = 0;

    // try and fill the buffer
    int c;
    while (USB_Tx_length<CDC_DATA_IN_PACKET_SIZE &&
           ((c = jshGetCharToTransmit(EV_USBSERIAL)) >=0) ) { // get byte to transmit
      USB_TX_Buffer[USB_Tx_length++] = c;
    }

    // if nothing, set state to 0
    if (USB_Tx_length==0) {
      USB_Tx_State = 0; 
      return;
    }
    USB_Tx_State = 1; 

    DCD_EP_Tx (pdev,
               CDC_IN_EP,
               (uint8_t*)USB_TX_Buffer,
               USB_Tx_length);
  }  
  
}
Exemplo n.º 8
0
/**
* @brief  SCSI_ProcessRead
*         Handle Read Process
* @param  lun: Logical unit number
* @retval status
*/
static int8_t SCSI_ProcessRead (uint8_t lun)
{
  uint32_t len;
  
  len = MIN(SCSI_blk_len , MSC_MEDIA_PACKET); 
  
  if( USBD_STORAGE_fops->Read(lun ,
                              MSC_BOT_Data, 
                              SCSI_blk_addr / SCSI_blk_size, 
                              len / SCSI_blk_size) < 0)
  {
    
    SCSI_SenseCode(lun, HARDWARE_ERROR, UNRECOVERED_READ_ERROR);
    return -1; 
  }
  
  
  DCD_EP_Tx (cdev, 
             MSC_IN_EP,
             MSC_BOT_Data,
             len);
  
  
  SCSI_blk_addr   += len; 
  SCSI_blk_len    -= len;  
  
  /* case 6 : Hi = Di */
  MSC_BOT_csw.dDataResidue -= len;
  
  if (SCSI_blk_len == 0)
  {
    MSC_BOT_State = BOT_LAST_DATA_IN;
  }
  return 0;
}
/**
  * @brief  Handle_USBAsynchXfer
  *         Send data to USB
  * @param  pdev: instance
  * @retval None
  */
static void Handle_USBAsynchXfer (void *pdev)
{
  if(USB_Tx_State != 1)
  {
    u8_t *data_p;
    u16_t len = ringbuf_available_linear(&usb_vcd_ringbuf_tx, &data_p);

    if (len == 0)
    {
      USB_Tx_State = 0; 
      return;
    }
    
#ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
     APP_Rx_length &= ~0x03;
#endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
    
    if (len > CDC_DATA_IN_PACKET_SIZE)
    {
      len = CDC_DATA_IN_PACKET_SIZE;
    }
    USB_Tx_State = 1; 

    DCD_EP_Tx (pdev,
               CDC_IN_EP,
               data_p,
               len);
    ringbuf_get(&usb_vcd_ringbuf_tx, 0, len);
  }  
  
}
/**
  * @brief  usbd_audio_DataIn
  *         Data sent on non-control IN endpoint
  * @param  pdev: device instance
  * @param  epnum: endpoint number
  * @retval status
  */
static uint8_t  usbd_cdc_DataIn (void *pdev, uint8_t epnum)
{
  if (USB_Tx_State == 1)
  {
    u8_t *data_p;
    u16_t len = ringbuf_available_linear(&usb_vcd_ringbuf_tx, &data_p);
    if (len == 0)
    {
      USB_Tx_State = 0;
    }
    else 
    {
      if (len > CDC_DATA_IN_PACKET_SIZE){
        len = CDC_DATA_IN_PACKET_SIZE;
      }
      /* Prepare the available data buffer to be sent on IN endpoint */
      DCD_EP_Tx (pdev,
                 CDC_IN_EP,
                 data_p,
                 len);
      ringbuf_get(&usb_vcd_ringbuf_tx, 0, len);
    }
  }  

  return USBD_OK;
}
Exemplo n.º 11
0
/**
  * @brief  Handle_USBAsynchXfer
  *         Send data to USB
  * @param  pdev: instance
  * @retval None
  */
static void Handle_USBAsynchXfer (void *pdev)
{
  uint16_t USB_Tx_ptr;
  uint16_t USB_Tx_length;
  
  if(USB_Tx_State != 1)
  {
    if (APP_Rx_ptr_out == APP_RX_DATA_SIZE)
    {
      APP_Rx_ptr_out = 0;
    }
    
    if(APP_Rx_ptr_out == APP_Rx_ptr_in) 
    {
      USB_Tx_State = 0; 
      return;
    }
    
    if(APP_Rx_ptr_out > APP_Rx_ptr_in) /* rollback */
    { 
      APP_Rx_length = APP_RX_DATA_SIZE - APP_Rx_ptr_out;
    
    }
    else 
    {
      APP_Rx_length = APP_Rx_ptr_in - APP_Rx_ptr_out;
     
    }
#ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
     APP_Rx_length &= ~0x03;
#endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
    
    if (APP_Rx_length > CDC_DATA_IN_PACKET_SIZE)
    {
      USB_Tx_ptr = APP_Rx_ptr_out;
      USB_Tx_length = CDC_DATA_IN_PACKET_SIZE;
      
      APP_Rx_ptr_out += CDC_DATA_IN_PACKET_SIZE;	
      APP_Rx_length -= CDC_DATA_IN_PACKET_SIZE;
    }
    else
    {
      USB_Tx_ptr = APP_Rx_ptr_out;
      USB_Tx_length = APP_Rx_length;
      
      APP_Rx_ptr_out += APP_Rx_length;
      APP_Rx_length = 0;
    }
    USB_Tx_State = 1; 

    DCD_EP_Tx (pdev,
               CDC_IN_EP,
               (uint8_t*)&APP_Rx_Buffer[USB_Tx_ptr],
               USB_Tx_length);
  }  
  
}
Exemplo n.º 12
0
//--------------------------------------------------------------
USBD_Status USBD_CtlContinueSendData(USB_OTG_CORE_HANDLE * pdev, uint8_t * pbuf, uint16_t len)
{
    USBD_Status ret = USBD_OK;

    DCD_EP_Tx(pdev, 0, pbuf, len);


    return ret;
}
Exemplo n.º 13
0
/**
  * @brief  Handle_USBAsynchXfer
  *         Send data to USB
  * @param  pdev: instance
  * @retval None
  */
static void Handle_USBAsynchXfer (void *pdev)
{
  uint16_t USB_Tx_ptr;
  uint16_t USB_Tx_length;
  
  if(USB_Tx_State != 1)
  {
    if (APP_Rx_ptr_out == APP_RX_DATA_SIZE)
    {
      APP_Rx_ptr_out = 0;
    }
    
    if(APP_Rx_ptr_out == APP_Rx_ptr_in) 
    {
      USB_Tx_State = 0; 
      return;
    }
    
    if(APP_Rx_ptr_out > APP_Rx_ptr_in) /* rollback */
    { 
      APP_Rx_length = APP_RX_DATA_SIZE - APP_Rx_ptr_out;
      
    }
    else 
    {
      APP_Rx_length = APP_Rx_ptr_in - APP_Rx_ptr_out;
      
    }
    
    if (APP_Rx_length > CDC_DATA_IN_PACKET_SIZE)
    {
      USB_Tx_ptr = APP_Rx_ptr_out;
      USB_Tx_length = CDC_DATA_IN_PACKET_SIZE;
      
      APP_Rx_ptr_out += CDC_DATA_IN_PACKET_SIZE;	
      APP_Rx_length -= CDC_DATA_IN_PACKET_SIZE;
    }
    else
    {
      USB_Tx_ptr = APP_Rx_ptr_out;
      USB_Tx_length = APP_Rx_length;
      
      APP_Rx_ptr_out += APP_Rx_length;
      APP_Rx_length = 0;
      if (USB_Tx_length == CDC_DATA_IN_PACKET_SIZE) last_packet = 1; //IBA
      if (APP_Rx_ptr_in == 64) APP_Rx_ptr_in=0;
    }
    USB_Tx_State = 1; 
    
    DCD_EP_Tx (pdev,
               CDC_IN_EP,
               (uint8_t*)&APP_Rx_Buffer[USB_Tx_ptr],
               USB_Tx_length);
  }  
  
}
Exemplo n.º 14
0
/**********************************************************************************************************
*函 数 名: Usb_Send
*功能说明: USB发送数据
*形    参: 发送数据缓冲区指针 数据长度
*返 回 值: 无
**********************************************************************************************************/
void Usb_Send(uint8_t *dataToSend, uint8_t length)
{
    if(connectFlag)
    {
        DCD_EP_Tx(&USB_OTG_dev, 1, dataToSend, length);
        DCD_SetEPStatus(&USB_OTG_dev,1, USB_OTG_EP_TX_VALID);
    }

    errorCheckCnt = 0;
}
Exemplo n.º 15
0
//--------------------------------------------------------------
USBD_Status USBD_CtlSendStatus(USB_OTG_CORE_HANDLE * pdev)
{
    USBD_Status ret = USBD_OK;
    pdev->dev.device_state = USB_OTG_EP0_STATUS_IN;
    DCD_EP_Tx(pdev, 0, NULL, 0);

    USB_OTG_EP0_OutStart(pdev);

    return ret;
}
void usb_midi_refresh(void){
	uint32_t buf[128];
	uint8_t count=FIFO_COUNT(USB_midi_packets_in);
	if (count && USB_transferPossible){
	    for (uint8_t i=0; i<count; i++){
	    	buf[i]=FIFO_FRONT(USB_midi_packets_in);
	    	FIFO_POP(USB_midi_packets_in);
	    }
		DCD_EP_Tx(&USB_OTG_dev, MIDI_IN_EP, (uint8_t*)buf, count<<2);
	}
}
Exemplo n.º 17
0
static uint8_t  usbd_video_SOF (void *pdev)
{     

  if (play_status == 1)
  {
	  DCD_EP_Flush(pdev,USB_ENDPOINT_IN(1));
	  DCD_EP_Tx (pdev,USB_ENDPOINT_IN(1), (uint8_t*)0x0002, 2);//header
	  play_status = 2;
  }
  return USBD_OK;
}
Exemplo n.º 18
0
uint8_t USBD_SendReport     (USB_OTG_CORE_HANDLE  *pdev, 
                             uint8_t *report,
                             uint16_t len)
{
  if (pdev->dev.device_status == USB_OTG_CONFIGURED )
  {
    DCD_EP_Tx (pdev, HID_IN_EP, report, len);
  }
  
  return USBD_OK;
}
Exemplo n.º 19
0
/**
  * @brief  usbd_audio_DataIn
  *         Data sent on non-control IN endpoint
  * @param  pdev: device instance
  * @param  epnum: endpoint number
  * @retval status
  */
static uint8_t  usbd_cdc_msc_DataIn (void *pdev, uint8_t epnum)
{
  uint16_t USB_Tx_ptr = 0;
  uint16_t USB_Tx_length;

  if (epnum == CDC_IN_EP || epnum == CDC_OUT_EP) {
    if (USB_Tx_State == 1)
    {
	if (APP_Rx_length == 0)
	{
	  if (((USB_OTG_CORE_HANDLE*)pdev)->dev.in_ep[epnum].xfer_len != CDC_DATA_IN_PACKET_SIZE)
	  {
	    USB_Tx_State = 0;
	    return USBD_OK;
	  }
	  /* Transmit zero sized packet in case the last one has maximum allowed size. Otherwise
	   * the recipient may expect more data coming soon and not return buffered data to app.
	   * See section 5.8.3 Bulk Transfer Packet Size Constraints
	   * of the USB Specification document.
	   */
	  USB_Tx_length = 0;
	}
	else
	{
	  if (APP_Rx_length > CDC_DATA_IN_PACKET_SIZE){
	    USB_Tx_ptr = APP_Rx_ptr_out;
	    USB_Tx_length = CDC_DATA_IN_PACKET_SIZE;

	    APP_Rx_ptr_out += CDC_DATA_IN_PACKET_SIZE;
	    APP_Rx_length -= CDC_DATA_IN_PACKET_SIZE;
	  }
	  else
	  {
	    USB_Tx_ptr = APP_Rx_ptr_out;
	    USB_Tx_length = APP_Rx_length;

	    APP_Rx_ptr_out += APP_Rx_length;
	    APP_Rx_length = 0;
	  }
	}

	/* Prepare the available data buffer to be sent on IN endpoint */
	DCD_EP_Tx (pdev,
		 CDC_IN_EP,
		 (uint8_t*)&APP_Rx_Buffer[USB_Tx_ptr],
		 USB_Tx_length);
    }
  }
  else {
      MSC_BOT_DataIn(pdev , epnum);
  }

  return USBD_OK;
}
Exemplo n.º 20
0
/**
* @brief  MSC_BOT_SendData
*         Send the requested data
* @param  pdev: device instance
* @param  buf: pointer to data buffer
* @param  len: Data Length
* @retval None
*/
static void  MSC_BOT_SendData(USB_OTG_CORE_HANDLE  *pdev,
							  uint8_t* buf,
							  uint16_t len) {

	len = MIN (MSC_BOT_cbw.dDataLength, len);
	MSC_BOT_csw.dDataResidue -= len;
	MSC_BOT_csw.bStatus = CSW_CMD_PASSED;
	MSC_BOT_State = BOT_SEND_DATA;

	DCD_EP_Tx (pdev, MSC_IN_EP, buf, len);
}
Exemplo n.º 21
0
void rndis_query_cmplt32(int status, uint32_t data)
{
	rndis_query_cmplt_t *c;
	c = (rndis_query_cmplt_t *)encapsulated_buffer;
	c->MessageType = REMOTE_NDIS_QUERY_CMPLT;
	c->MessageLength = sizeof(rndis_query_cmplt_t) + 4;
	c->InformationBufferLength = 4;
	c->InformationBufferOffset = 16;
	c->Status = status;
	*(uint32_t *)(c + 1) = data;
	DCD_EP_Tx(&USB_OTG_dev, RNDIS_NOTIFICATION_IN_EP, (uint8_t *)"\x01\x00\x00\x00\x00\x00\x00\x00", 8);
}
Exemplo n.º 22
0
//--------------------------------------------------------------
USBD_Status USBD_CtlSendData(USB_OTG_CORE_HANDLE * pdev, uint8_t * pbuf, uint16_t len)
{
    USBD_Status ret = USBD_OK;

    pdev->dev.in_ep[0].total_data_len = len;
    pdev->dev.in_ep[0].rem_data_len = len;
    pdev->dev.device_state = USB_OTG_EP0_DATA_IN;

    DCD_EP_Tx(pdev, 0, pbuf, len);

    return ret;
}
Exemplo n.º 23
0
void rndis_query_cmplt(int status, const void *data, int size)
{
	rndis_query_cmplt_t *c;
	c = (rndis_query_cmplt_t *)encapsulated_buffer;
	c->MessageType = REMOTE_NDIS_QUERY_CMPLT;
	c->MessageLength = sizeof(rndis_query_cmplt_t) + size;
	c->InformationBufferLength = size;
	c->InformationBufferOffset = 16;
	c->Status = status;
	memcpy(c + 1, data, size);
	DCD_EP_Tx(&USB_OTG_dev, RNDIS_NOTIFICATION_IN_EP, (uint8_t *)"\x01\x00\x00\x00\x00\x00\x00\x00", 8);
}
Exemplo n.º 24
0
static uint8_t  usbd_cf_SOF (void *pdev)
{
  portBASE_TYPE xTaskWokenByReceive = pdFALSE;

  if (xQueueReceiveFromISR(usbDataTx, &outPacket, &xTaskWokenByReceive) == pdTRUE)
  {
    DCD_EP_Tx (pdev,
               IN_EP,
               (uint8_t*)outPacket.data,
               outPacket.size);
  }

  return USBD_OK;
}
Exemplo n.º 25
0
/**
  * @brief  CCID_IntMessage
  *         Send the Interrupt-IN data to the host
  * @param  pdev: device instance
  * @retval None
  */
void CCID_IntMessage(USB_CORE_HANDLE  *pdev)
{
  /* Check if there us change in Smartcard Slot status */  
  if ( CCID_IsSlotStatusChange() && CCID_IsIntrTransferComplete() )
  {
    /* Check Slot Status is changed. Card is Removed/ Fitted  */
    RDR_to_PC_NotifySlotChange();
    
    CCID_SetIntrTransferStatus(0);  /* Reset the Status */
    CCID_UpdSlotChange(0);    /* Reset the Status of Slot Change */
    
    DCD_EP_Tx (pdev, CCID_INTR_IN_EP, UsbIntMessageBuffer, 2); 
  }
}  
Exemplo n.º 26
0
static void usbd_cdc_Schedule_In(void *pdev)
{
  uint32_t USB_Tx_length;
  USB_Tx_length = ring_data_contig(USB_TX_BUFFER_SIZE, USB_Tx_Buffer_head, USB_Tx_Buffer_tail);

  if (USB_Tx_State) {
    if (USB_Serial_Open) {
      USB_Tx_failed_counter++;
      if (USB_Tx_failed_counter >= 500) {
        usbd_cdc_Change_Open_State(0);
        // Completely flush TX buffer
        DCD_EP_Flush(pdev, CDC_IN_EP);
        // Send ZLP
        DCD_EP_Tx(pdev, CDC_IN_EP, NULL, 0);
        if (USB_Tx_length)
          USB_Tx_Buffer_tail = ring_wrap(USB_TX_BUFFER_SIZE, USB_Tx_Buffer_tail + USB_Tx_length);

        USB_Tx_State = 0;
      }
    }
    return;
  }

  if (!USB_Tx_length)
    return;

  USB_Tx_State = 1;
  USB_Tx_failed_counter = 0;

  USB_Tx_length = MIN(USB_Tx_length, CDC_DATA_IN_PACKET_SIZE);
  DCD_EP_Tx (pdev,
             CDC_IN_EP,
             (uint8_t*)&USB_Tx_Buffer[USB_Tx_Buffer_tail],
             USB_Tx_length);

  USB_Tx_Buffer_tail = ring_wrap(USB_TX_BUFFER_SIZE, USB_Tx_Buffer_tail + USB_Tx_length);
}
Exemplo n.º 27
0
void SCSI_ProcessReadComplete(uint32_t len) {
	DCD_EP_Tx (cdev,
			   MSC_IN_EP,
			   MSC_BOT_Data,
			   len);


	SCSI_blk_addr   += len;
	SCSI_blk_len    -= len;

	/* case 6 : Hi = Di */
	MSC_BOT_csw.dDataResidue -= len;

	if (SCSI_blk_len == 0) {
		MSC_BOT_State = BOT_LAST_DATA_IN;
	}
}
Exemplo n.º 28
0
/**
* @brief  MSC_BOT_SendCSW
*         Send the Command Status Wrapper
* @param  pdev: device instance
* @param  status : CSW status
* @retval None
*/
void  MSC_BOT_SendCSW (USB_OTG_CORE_HANDLE  *pdev,
					   uint8_t CSW_Status) {
	MSC_BOT_csw.dSignature = BOT_CSW_SIGNATURE;
	MSC_BOT_csw.bStatus = CSW_Status;
	MSC_BOT_State = BOT_IDLE;

	DCD_EP_Tx (pdev,
			   MSC_IN_EP,
			   (uint8_t *)&MSC_BOT_csw,
			   BOT_CSW_LENGTH);

	/* Prapare EP to Receive next Cmd */
	DCD_EP_PrepareRx (pdev,
					  MSC_OUT_EP,
					  (uint8_t *)&MSC_BOT_cbw,
					  BOT_CBW_LENGTH);

}
Exemplo n.º 29
0
/**
  * @brief  usbd_audio_DataIn
  *         Data sent on non-control IN endpoint
  * @param  pdev: device instance
  * @param  epnum: endpoint number
  * @retval status
  */
static uint8_t  usbd_cdc_DataIn (void *pdev, uint8_t epnum)
{
  uint16_t USB_Tx_ptr;
  uint16_t USB_Tx_length;

  if (USB_Tx_State == 1)
  {
    if (APP_Rx_length == 0) 
    {
      USB_Tx_State = 0;
    }
    else 
    {
      if (APP_Rx_length > CDC_DATA_IN_PACKET_SIZE){
        USB_Tx_ptr = APP_Rx_ptr_out;
        USB_Tx_length = CDC_DATA_IN_PACKET_SIZE;
        
        APP_Rx_ptr_out += CDC_DATA_IN_PACKET_SIZE;
        APP_Rx_length -= CDC_DATA_IN_PACKET_SIZE;    
      }
      else 
      {
        USB_Tx_ptr = APP_Rx_ptr_out;
        USB_Tx_length = APP_Rx_length;
        
        APP_Rx_ptr_out += APP_Rx_length;
        APP_Rx_length = 0;

        //ZS - data smaller than 64 bytes - don't increment pointers...
        APP_Rx_ptr_out = 0;
        APP_Rx_ptr_in = 0;
      }
      
      /* Prepare the available data buffer to be sent on IN endpoint */
      DCD_EP_Tx (pdev,
                 CDC_IN_EP,
                 (uint8_t*)&APP_Rx_Buffer[USB_Tx_ptr],
                 USB_Tx_length);
    }
  }  
  
  return USBD_OK;
}
Exemplo n.º 30
0
/**
  * @brief  usbd_audio_DataIn
  *         Data sent on non-control IN endpoint
  * @param  pdev: device instance
  * @param  epnum: endpoint number
  * @retval status
  */
static uint8_t  usbd_cdc_DataIn (void *pdev, uint8_t epnum)
{
  uint16_t USB_Tx_ptr;
  uint16_t USB_Tx_length;

  if (USB_Tx_State == 1)
  {
    if (APP_Rx_length == 0) 
    {
      USB_Tx_State = 0;
    }
    else 
    {
      if (APP_Rx_length > VIRTUAL_COM_PORT_DATA_SIZE){
        USB_Tx_ptr = APP_Rx_ptr_out;
        USB_Tx_length = VIRTUAL_COM_PORT_DATA_SIZE;
        
        APP_Rx_ptr_out += VIRTUAL_COM_PORT_DATA_SIZE;
        APP_Rx_length -= VIRTUAL_COM_PORT_DATA_SIZE;    
      }
      else 
      {
        USB_Tx_ptr = APP_Rx_ptr_out;
        USB_Tx_length = APP_Rx_length;
        
        APP_Rx_ptr_out += APP_Rx_length;
        APP_Rx_length = 0;
      }
      
      /* Prepare the available data buffer to be sent on IN endpoint */
      DCD_EP_Tx (pdev,
                 CDC_IN_EP,
                 (uint8_t*)&APP_Rx_Buffer[USB_Tx_ptr],
                 USB_Tx_length);
    }
  }  
  
  return USBD_OK;
}