Function _serial_fifo_rx

components/drivers/serial/dev_serial_v2.c:474–554

* @brief Serial receive data routines, This function will receive * data by using fifo * * @note In blocking mode, the function will wait until the specified amount of data is received or until a timeout occurs. * In non-blocking mode, the function will immediately attempt to retrieve as much data as possible from the ring buffer and return. * * @param dev The pointer of d

  * @return Returns the actual length of data received.
  */
static rt_ssize_t _serial_fifo_rx(struct rt_device *dev,
                                  rt_off_t          pos,
                                  void             *buffer,
                                  rt_size_t         size)
{
    struct rt_serial_device  *serial;
    struct rt_serial_rx_fifo *rx_fifo;
    rt_base_t                 level;
    rt_size_t                 recv_size = 0;

    if (size == 0) return 0;
    RT_ASSERT(dev != RT_NULL && buffer != RT_NULL);

    serial  = (struct rt_serial_device *)dev;
    rx_fifo = (struct rt_serial_rx_fifo *)serial->serial_rx;

    if (dev->open_flag & RT_SERIAL_RX_BLOCKING)
    {
        rt_size_t  data_len;
        rt_tick_t  delta_tick;
        rt_size_t  rx_bufsz_third  = serial->config.rx_bufsz / 2;
        rt_int32_t base_rx_timeout = rt_atomic_load(&rx_fifo->rx_timeout);
        rt_int32_t rx_timeout_left = base_rx_timeout;
        rt_tick_t  begin_tick      = rt_tick_get();

        while (1)
        {
            if (rx_timeout_left != RT_WAITING_NO)
            {
                level    = rt_spin_lock_irqsave(&serial->spinlock);
                data_len = rt_ringbuffer_data_len(&rx_fifo->rb);
                if (data_len < size - recv_size)
                {
                    if (size - (recv_size + data_len) >= rx_bufsz_third)
                    {
                        rx_fifo->rx_cpt_index = rx_bufsz_third;
                    }
                    else
                    {
                        rx_fifo->rx_cpt_index = size - (recv_size + data_len);
                    }
                    rt_completion_wait(&rx_fifo->rx_cpt, 0);
                }
                rt_spin_unlock_irqrestore(&serial->spinlock, level);
            }

            level      = RT_SERIAL_FIFO_LOCK(&serial->spinlock);
            recv_size += rt_ringbuffer_get(&rx_fifo->rb, (rt_uint8_t *)buffer + recv_size, size - recv_size);
            RT_SERIAL_FIFO_UNLOCK(&serial->spinlock, level);
            if (recv_size == size || rx_timeout_left == RT_WAITING_NO)
            {
                break;
            }

            rt_completion_wait(&rx_fifo->rx_cpt, rx_timeout_left);
            if (rx_timeout_left != RT_WAITING_FOREVER)
            {
                delta_tick = rt_tick_get_delta(begin_tick);