Function rt_can_write

components/drivers/can/dev_can.c:622–671

* @brief Write data to the CAN device. * * This function serves as the unified entry point for sending CAN messages. * It intelligently routes the request to either a blocking or non-blocking * transmission function based on: * 1. The calling context (thread or ISR). * 2. A user-specified flag (`nonblocking`) in the message structure. * * @param[in] dev A pointer to the device object.

 *         the data was either sent directly or enqueued in the buffer.
 */
static rt_ssize_t rt_can_write(struct rt_device *dev,
                              rt_off_t          pos,
                              const void       *buffer,
                              rt_size_t         size)
{
    struct rt_can_device *can;
    const struct rt_can_msg *pmsg;

    RT_ASSERT(dev != RT_NULL);
    RT_ASSERT(buffer != RT_NULL);

    if (size == 0) return -RT_EINVAL;

    /* Ensure size is a multiple of the message size for buffer operations */
    if (size % sizeof(struct rt_can_msg) != 0)
    {
        return -RT_EINVAL;
    }

    can = (struct rt_can_device *)dev;
    pmsg = (const struct rt_can_msg *)buffer;

    if(dev->ref_count == 0)
    {
        return -RT_ENOSYS;
    }

    /*
     * Routing to the non-blocking send scenario:
     * 1. Called from within an interrupt context.
     * 2. Called from a thread, but the user explicitly set the nonblocking flag on the first message.
     */
    if (rt_interrupt_get_nest() > 0 || pmsg->nonblocking)
    {
        return _can_nonblocking_tx(can, pmsg, size);
    }

    if (dev->open_flag & RT_DEVICE_FLAG_INT_TX)
    {
        if (can->config.privmode)
        {
            return _can_int_tx_priv(can, buffer, size);
        }
        else
        {
            return _can_int_tx(can, buffer, size);
        }
    }
    return -RT_ENOSYS;
}

static rt_err_t rt_can_control(struct rt_device *dev,
                               int              cmd,