串口控制器

串口控制器 的协作图:

结构体
struct	xwds_uart_cfg
	UART配置 更多...
struct	xwds_uartc_driver
	BSP中需要提供的UART控制器驱动函数表 更多...
struct	xwds_uartc
	UART控制器 更多...

宏定义
#define	XWDS_UART_RXQ_SIZE   XWCDCFG_ds_UART_RXQ_SIZE

类型定义
typedef void(*	xwds_uartc_eqcb_f) (struct xwds_uartc *, xwer_t)
	异步发送的回调函数类型

枚举
enum	xwds_uart_bits_em {   XWDS_UART_BITS_5 = 0U , XWDS_UART_BITS_6 , XWDS_UART_BITS_7 , XWDS_UART_BITS_8 ,   XWDS_UART_BITS_9 }
	UART字长枚举 更多...
enum	xwds_uart_stopbits_em { XWDS_UART_STOPBITS_0_5 = 0U , XWDS_UART_STOPBITS_1_0 , XWDS_UART_STOPBITS_1_5 , XWDS_UART_STOPBITS_2_0 }
	UART停止位枚举 更多...
enum	xwds_uart_parity_em { XWDS_UART_PARITY_NONE = 0U , XWDS_UART_PARITY_EVEN , XWDS_UART_PARITY_ODD }
	UART奇偶校验枚举 更多...
enum	xwds_uart_hardwareflowcontrol_em { XWDS_UART_HFC_NONE = 0U , XWDS_UART_HFC_RTS = ((xwbmp_t)1 << ( 0 )) , XWDS_UART_HFC_CTS = ((xwbmp_t)1 << ( 1 )) }
	UART硬件流控枚举 更多...
enum	xwds_uart_mode_em { XWDS_UART_MODE_CLOSE = 0U , XWDS_UART_MODE_TX = ((xwbmp_t)1 << ( 0 )) , XWDS_UART_MODE_RX = ((xwbmp_t)1 << ( 1 )) }
	UART模式枚举 更多...

函数
void	xwds_uartc_construct (struct xwds_uartc *uartc)
	XWDS API：UART控制器的构造函数
void	xwds_uartc_destruct (struct xwds_uartc *uartc)
	XWDS API：UART控制器对象的析构函数
xwer_t	xwds_uartc_grab (struct xwds_uartc *uartc)
	增加对象的引用计数
xwer_t	xwds_uartc_put (struct xwds_uartc *uartc)
	减少对象的引用计数
xwer_t	xwds_uartc_rx (struct xwds_uartc *uartc, xwu8_t *buf, xwsz_t *size, xwtm_t to)
	XWDS API：从接收队列中获取数据
xwer_t	xwds_uartc_try_rx (struct xwds_uartc *uartc, xwu8_t *buf, xwsz_t *size)
	XWDS API：尝试从接收队列中获取数据
xwer_t	xwds_uartc_tx (struct xwds_uartc *uartc, const xwu8_t *data, xwsz_t *size, xwtm_t to)
	XWDS API：同步发送
xwer_t	xwds_uartc_eq (struct xwds_uartc *uartc, const xwu8_t *data, xwsz_t *size, xwds_uartc_eqcb_f cb)
	XWDS API：异步发送
xwer_t	xwds_uartc_putc (struct xwds_uartc *uartc, const xwu8_t byte, xwtm_t to)
	XWDS API：直接发送一个字节（非DMA模式）
xwer_t	xwds_uartc_cfg (struct xwds_uartc *uartc, const struct xwds_uart_cfg *cfg)
	XWDS API：配置UART
static bool	xwds_uart_tst_baudrate (xwu32_t baudrate)
	测试UART波特率是否合法
void	xwds_uartc_drvcb_rxq_flush (struct xwds_uartc *uartc)
	XWDS Driver Callback：清空接收队列
xwsq_t	xwds_uartc_drvcb_rxq_fill (struct xwds_uartc *uartc, xwu8_t bytes[], xwsz_t size)
	XWDS Driver Callback：从UART硬件接收数据到缓冲区
void	xwds_uartc_drvcb_rxq_pub (struct xwds_uartc *uartc, xwsq_t tail)
	XWDS Driver Callback：发布数据到接收队列

详细描述

接收

XWDS串口控制器框架内定义了大小为 XWCDCFG_ds_UART_RXQ_SIZE 的 接收缓冲区 ， CAPI xwds_uartc_rx() 与 xwds_uartc_try_rx() 用于从 接收缓冲区 获取数据。

异步发送

异步发送 xwds_uartc_eq() 只会将数据拷贝到发送缓冲区， 不会等待发送结果，可在中断中使用。

同步发送

同步发送 xwds_uartc_tx() 会阻塞调用者，等待发送结果，因此只能在线程中使用。

<strong>BSP驱动层</strong> 的适配工作

适配接收缓冲区

接收缓冲区 是一个循环队列，当 overflow 时，最新的数据会将最旧的数据覆盖掉。

rxq.idx 用于向 接收缓冲区 内填充数据， rxq.pos 和 rxq.tail 用于向 接收缓冲区 获取数据。

<strong>中断模式</strong> 中使用接收缓冲区

当使用 中断模式 的UART硬件控制器时，需在中断函数内 调用 xwds_uartc_drvcb_rxq_fill() 填充 接收缓冲区 ， 然后调用 xwds_uartc_drvcb_rxq_pub() 发布数据。

如果UART硬件控制器支持FIFO，需要使用一个 接收超时定时器 定期将FIFO内数据填充至 接收缓冲区 并发布数据。

出现错误时，需要使用 xwds_uartc_drvcb_rxq_flush() 重置 接收缓冲区 。

<strong>DMA模式</strong> 中使用接收缓冲区

当使用 DMA模式 的UART硬件控制器时，需将DMA的接收地址 设置为 接收缓冲区 的首地址，DMA引擎会自动填充 接收缓冲区 ， DMA完成中断触发时，需要调用 xwds_uartc_drvcb_rxq_pub() 发布数据。

此外需要使用一个 接收超时定时器 定期发布数据。

出现错误时，需要使用 xwds_uartc_drvcb_rxq_flush() 重置 接收缓冲区 。

适配 <tt>xwds_uartc_tx()</tt>

同步发送 xwds_uartc_tx() 需要 BSP驱动层 实现 xwds_uartc_driver.tx 函数。

适配 <tt>xwds_uartc_eq()</tt>

异步发送 xwds_uartc_eq() 需要 BSP驱动层 实现 xwds_uartc_driver.eq 函数。 BSP驱动层 可根据需要实现 发送缓冲区 ，有些SOC提供很大的 TX FIFO ， 可替代发送缓冲区。

DMA模式的发送则必须提供 发送缓冲区 作为DMA的内存。

BSP驱动层 还需要实现一个 BUSY 标志，此CAPI不阻塞，当检测到BUSY标志时 需要立即返回 -EBUSY 。

宏定义说明

XWDS_UART_RXQ_SIZE

#define XWDS_UART_RXQ_SIZE   XWCDCFG_ds_UART_RXQ_SIZE

在文件 controller.h 第 101 行定义.

类型定义说明

xwds_uartc_eqcb_f

typedef void(* xwds_uartc_eqcb_f) (struct xwds_uartc *, xwer_t)

异步发送的回调函数类型

在文件 controller.h 第 171 行定义.

枚举类型说明

xwds_uart_bits_em

enum xwds_uart_bits_em

UART字长枚举

枚举值
XWDS_UART_BITS_5
XWDS_UART_BITS_6
XWDS_UART_BITS_7
XWDS_UART_BITS_8
XWDS_UART_BITS_9

在文件 controller.h 第 106 行定义.

                       {
        XWDS_UART_BITS_5 = 0U,
        XWDS_UART_BITS_6,
        XWDS_UART_BITS_7,
        XWDS_UART_BITS_8,
        XWDS_UART_BITS_9,
};

xwds_uart_hardwareflowcontrol_em

enum xwds_uart_hardwareflowcontrol_em

UART硬件流控枚举

枚举值
XWDS_UART_HFC_NONE
XWDS_UART_HFC_RTS
XWDS_UART_HFC_CTS

在文件 controller.h 第 136 行定义.

                                      {
        XWDS_UART_HFC_NONE = 0U,
        XWDS_UART_HFC_RTS = XWBOP_BIT(0),
        XWDS_UART_HFC_CTS = XWBOP_BIT(1),
};

xwds_uart_mode_em

enum xwds_uart_mode_em

UART模式枚举

枚举值
XWDS_UART_MODE_CLOSE
XWDS_UART_MODE_TX
XWDS_UART_MODE_RX

在文件 controller.h 第 145 行定义.

                       {
        XWDS_UART_MODE_CLOSE = 0U,
        XWDS_UART_MODE_TX = XWBOP_BIT(0),
        XWDS_UART_MODE_RX = XWBOP_BIT(1),
};

xwds_uart_parity_em

enum xwds_uart_parity_em

UART奇偶校验枚举

枚举值
XWDS_UART_PARITY_NONE
XWDS_UART_PARITY_EVEN
XWDS_UART_PARITY_ODD

在文件 controller.h 第 127 行定义.

                         {
        XWDS_UART_PARITY_NONE = 0U,
        XWDS_UART_PARITY_EVEN,
        XWDS_UART_PARITY_ODD,
};

xwds_uart_stopbits_em

enum xwds_uart_stopbits_em

UART停止位枚举

枚举值
XWDS_UART_STOPBITS_0_5
XWDS_UART_STOPBITS_1_0
XWDS_UART_STOPBITS_1_5
XWDS_UART_STOPBITS_2_0

在文件 controller.h 第 117 行定义.

                           {
        XWDS_UART_STOPBITS_0_5 = 0U,
        XWDS_UART_STOPBITS_1_0,
        XWDS_UART_STOPBITS_1_5,
        XWDS_UART_STOPBITS_2_0,
};

函数说明

xwds_uart_tst_baudrate()

static bool xwds_uart_tst_baudrate ( xwu32_t  baudrate )

inlinestatic

测试UART波特率是否合法

参数

[in]

baudrate

波特率

在文件 controller.h 第 353 行定义.

{
        return ((50U == baudrate) || (75U == baudrate) || (110U == baudrate) ||
                (134U == baudrate) || (150U == baudrate) || (200U == baudrate) ||
                (300U == baudrate) || (600U == baudrate) || (1200U == baudrate) ||
                (1800U == baudrate) || (2400U == baudrate) || (4800U == baudrate) ||
                (9600U == baudrate) || (19200U == baudrate) || (38400U == baudrate) ||
                (57600U == baudrate) || (115200U == baudrate) ||
                (230400U == baudrate) || (460800U == baudrate) ||
                (576000U == baudrate) || (921600U == baudrate) ||
                (1000000U == baudrate) || (1152000U == baudrate) ||
                (1500000U == baudrate) || (2000000U == baudrate) ||
                (2500000U == baudrate) || (3000000U == baudrate) ||
                (3500000U == baudrate) || (4000000U == baudrate));
}

xwds_uartc_cfg()

xwer_t xwds_uartc_cfg	(	struct xwds_uartc *	uartc,
		const struct xwds_uart_cfg *	cfg
	)

XWDS API：配置UART

参数

[in]	uartc	UART控制器对象指针
[in]	cfg	新的配置

返回

错误码

返回值

XWOK	没有错误
-EFAULT	无效指针
-ENOSYS	不支持此操作

注解

• 上下文：中断、中断底半部、线程

<No error

在文件 controller.c 第 462 行定义.

{
        const struct xwds_uartc_driver * drv;
        xwer_t rc;
 
        XWDS_VALIDATE(uartc, "nullptr", -EFAULT);
        XWDS_VALIDATE(cfg, "nullptr", -EFAULT);
 
        rc = xwds_uartc_grab(uartc);
        if (rc < 0) {
                goto err_uartc_grab;
        }
        drv = xwds_cast(const struct xwds_uartc_driver *, uartc->dev.drv);
        if ((drv) && (drv->cfg)) {
                rc = drv->cfg(uartc, cfg);
        } else {
                rc = -ENOSYS;
        }
        if (rc < 0) {
                goto err_drv_cfg;
        }
        xwds_uartc_put(uartc);
        return XWOK;
 
err_drv_cfg:
        xwds_uartc_put(uartc);
err_uartc_grab:
        return rc;
}

函数调用图:

xwds_uartc_construct()

void xwds_uartc_construct

(

struct xwds_uartc *

uartc

)

XWDS API：UART控制器的构造函数

参数

[in]

uartc

UART控制器对象指针

在文件 controller.c 第 73 行定义.

{
        xwds_device_construct(&uartc->dev);
        uartc->dev.vop = &xwds_uartc_vop;
}

函数调用图:

xwds_uartc_destruct()

void xwds_uartc_destruct

(

struct xwds_uartc *

uartc

)

XWDS API：UART控制器对象的析构函数

参数

[in]

uartc

UART控制器对象指针

在文件 controller.c 第 84 行定义.

{
        xwds_device_destruct(&uartc->dev);
}

函数调用图:

xwds_uartc_drvcb_rxq_fill()

xwsq_t xwds_uartc_drvcb_rxq_fill	(	struct xwds_uartc *	uartc,
		xwu8_t	bytes[],
		xwsz_t	size
	)

XWDS Driver Callback：从UART硬件接收数据到缓冲区

参数

[in]

uartc

UART控制器对象指针

返回

下一次接收数据的位置

如果使用 uartc->rxq.mem 作为DMA内存，缓冲区将自动被填充，不需要使用此函数。 此函数仅当DMA内存与缓冲区不一致时，或使用中断模式时使用。

在文件 controller.c 第 508 行定义.

{
        for (xwsz_t i = 0; i < size; i++) {
                uartc->rxq.mem[uartc->rxq.idx] = bytes[i];
                uartc->rxq.idx++;
                if (sizeof(uartc->rxq.mem) == uartc->rxq.idx) {
                        uartc->rxq.idx = 0;
                }
        }
        return uartc->rxq.idx;
}

xwds_uartc_drvcb_rxq_flush()

void xwds_uartc_drvcb_rxq_flush

(

struct xwds_uartc *

uartc

)

XWDS Driver Callback：清空接收队列

参数

[in]

uartc

UART控制器对象指针

在文件 controller.c 第 495 行定义.

{
        xwreg_t cpuirq;
 
        xwos_sem_trywait(&uartc->rxq.sem);
        xwos_splk_lock_cpuirqsv(&uartc->rxq.lock, &cpuirq);
        uartc->rxq.pos = 0;
        uartc->rxq.tail = 0;
        uartc->rxq.idx = 0;
        xwos_splk_unlock_cpuirqrs(&uartc->rxq.lock, cpuirq);
}

函数调用图:

xwds_uartc_drvcb_rxq_pub()

void xwds_uartc_drvcb_rxq_pub	(	struct xwds_uartc *	uartc,
		xwsq_t	tail
	)

XWDS Driver Callback：发布数据到接收队列

参数

[in]	uartc	UART控制器对象指针
[in]	pub	新的数据接收位置（有效数据结尾 + 1）

在文件 controller.c 第 522 行定义.

{
        xwsz_t pubsz;
        xwreg_t cpuirq;
 
        if (sizeof(uartc->rxq.mem) == pub) {
                pub = 0;
        }
        xwos_splk_lock_cpuirqsv(&uartc->rxq.lock, &cpuirq);
        if (pub == uartc->rxq.tail) {
                pubsz = 0;
        } else if (pub > uartc->rxq.tail) {
                pubsz = pub - uartc->rxq.tail;
                if (uartc->rxq.pos <= uartc->rxq.tail) {
                } else if (uartc->rxq.pos <= pub) {
                        /* Overflow! Discard the oldest data. */
                        uartc->rxq.pos = pub + 1;
                        if (sizeof(uartc->rxq.mem) == uartc->rxq.pos) {
                                uartc->rxq.pos = 0;
                        }
                } else {
                }
                uartc->rxq.tail = pub;
        } else {
                pubsz = sizeof(uartc->rxq.mem) - uartc->rxq.tail + pub;
                if (uartc->rxq.pos <= pub) {
                        /* Overflow! Discard the oldest data. */
                        uartc->rxq.pos = pub + 1;
                        /* `uartc->rxq.pos < sizeof(uartc->rxq.mem)` is always true. */
                } else if (uartc->rxq.pos <= uartc->rxq.tail) {
                } else {
                        /* Overflow! Discard the oldest data. */
                        uartc->rxq.pos = pub + 1;
                        /* `uartc->rxq.pos < sizeof(uartc->rxq.mem)` is always true. */
                }
                uartc->rxq.tail = pub;
        }
        xwos_splk_unlock_cpuirqrs(&uartc->rxq.lock, cpuirq);
        if (pubsz > 0) {
                xwos_sem_post(&uartc->rxq.sem);
        }
}

函数调用图:

xwds_uartc_eq()

xwer_t xwds_uartc_eq	(	struct xwds_uartc *	uartc,
		const xwu8_t *	data,
		xwsz_t *	size,
		xwds_uartc_eqcb_f	cb
	)

XWDS API：异步发送

参数

[in]	uartc	UART控制器对象指针
[in]	data	待发送的数据的缓冲区
[in,out]	size	指向缓冲区的指针，此缓冲区： (I) 作为输入时，表示期望发送的数据的大小（单位：字节） (O) 作为输出时，返回实际拷贝到缓冲区的数据大小
[in]	cb	发送结束后的回调函数，可为 NULL

返回

错误码

返回值

XWOK	没有错误
-EFAULT	无效指针
-ENOSYS	不支持此操作
-EBUSY	端口繁忙

注解

• 上下文：任意

• 此CAPI仅将待发送的数据拷贝到发送缓冲区就返回，不会等待发送结果。 如果设备正在发送其他数据，就以 -EBUSY 返回。 此CAPI可在中断中使用。
• 如果发送数据超过缓冲区大小，返回时， *size 会返回实际拷贝到缓冲区的数据大小。

<No error

在文件 controller.c 第 389 行定义.

{
        const struct xwds_uartc_driver * drv;
        xwer_t rc;
 
        XWDS_VALIDATE(uartc, "nullptr", -EFAULT);
        XWDS_VALIDATE(data, "nullptr", -EFAULT);
        XWDS_VALIDATE(size, "nullptr", -EFAULT);
 
        rc = xwds_uartc_grab(uartc);
        if (rc < 0) {
                goto err_uartc_grab;
        }
        drv = xwds_cast(const struct xwds_uartc_driver *, uartc->dev.drv);
        if ((drv) && (drv->eq)) {
                rc = drv->eq(uartc, data, size, cb);
        } else {
                rc = -ENOSYS;
        }
        if (rc < 0) {
                goto err_eq;
        }
        xwds_uartc_put(uartc);
        return XWOK;
 
err_eq:
        xwds_uartc_put(uartc);
err_uartc_grab:
        return rc;
}

函数调用图:

xwds_uartc_grab()

xwer_t xwds_uartc_grab

(

struct xwds_uartc *

uartc

)

增加对象的引用计数

参数

[in]

uartc

UART控制器对象指针

在文件 controller.c 第 94 行定义.

{
        return xwds_device_grab(&uartc->dev);
}

函数调用图:

这是这个函数的调用关系图:

xwds_uartc_put()

xwer_t xwds_uartc_put

(

struct xwds_uartc *

uartc

)

减少对象的引用计数

参数

[in]

uartc

UART控制器对象指针

在文件 controller.c 第 104 行定义.

{
        return xwds_device_put(&uartc->dev);
}

函数调用图:

这是这个函数的调用关系图:

xwds_uartc_putc()

xwer_t xwds_uartc_putc	(	struct xwds_uartc *	uartc,
		const xwu8_t	byte,
		xwtm_t	to
	)

XWDS API：直接发送一个字节（非DMA模式）

参数

[in]	uartc	UART控制器对象指针
[in]	byte	待发送的字节
[in]	to	期望唤醒的时间点

返回

错误码

返回值

XWOK	没有错误
-EFAULT	无效指针
-ENOSYS	不支持此操作

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 controller.c 第 423 行定义.

{
        xwer_t rc;
        const struct xwds_uartc_driver * drv;
 
        XWDS_VALIDATE(uartc, "nullptr", -EFAULT);
 
        rc = xwds_uartc_grab(uartc);
        if (rc < 0) {
                goto err_uartc_grab;
        }
        rc = xwos_mtx_lock_to(&uartc->txmtx, to);
        if (rc < 0) {
                goto err_uartc_lock;
        }
        drv = xwds_cast(const struct xwds_uartc_driver *, uartc->dev.drv);
        if ((drv) && (drv->putc)) {
                rc = drv->putc(uartc, byte);
        } else {
                rc = -ENOSYS;
        }
        if (rc < 0) {
                goto err_putc;
        }
        xwos_mtx_unlock(&uartc->txmtx);
        xwds_uartc_put(uartc);
        return XWOK;
 
err_putc:
        xwos_mtx_unlock(&uartc->txmtx);
err_uartc_lock:
        xwds_uartc_put(uartc);
err_uartc_grab:
        return rc;
}

函数调用图:

xwds_uartc_rx()

xwer_t xwds_uartc_rx	(	struct xwds_uartc *	uartc,
		xwu8_t *	buf,
		xwsz_t *	size,
		xwtm_t	to
	)

XWDS API：从接收队列中获取数据

参数

[in]	uartc	UART控制器对象指针
[out]	buf	指向缓冲区的指针，通过此缓冲区返回数据
[in,out]	size	指向缓冲区的指针，此缓冲区： (I) 作为输入时，表示缓冲区大小（单位：字节） (O) 作为输出时，返回实际读取的数据大小
[in]	to	期望唤醒的时间点

返回

错误码

返回值

XWOK	没有错误
-EFAULT	无效指针
-ETIMEDOUT	超时

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 controller.c 第 229 行定义.

{
        xwsz_t available, real, cp, rest_buffer_size;
        xwsq_t pos;
        xwreg_t cpuirq;
        xwer_t rc;
 
        XWDS_VALIDATE(uartc, "nullptr", -EFAULT);
        XWDS_VALIDATE(buf, "nullptr", -EFAULT);
        XWDS_VALIDATE(size, "nullptr", -EFAULT);
 
        pos = 0;
        rc = xwds_uartc_grab(uartc);
        if (rc < 0) {
                goto err_uartc_grab;
        }
        rest_buffer_size = *size;
        while (rest_buffer_size) {
                rc = xwos_sem_wait_to(&uartc->rxq.sem, to);
                if (rc < 0) {
                        goto err_sem_wait_to;
                }
                xwos_splk_lock_cpuirqsv(&uartc->rxq.lock, &cpuirq);
                if (uartc->rxq.tail >= uartc->rxq.pos) {
                        available = uartc->rxq.tail - uartc->rxq.pos;
                } else {
                        available = sizeof(uartc->rxq.mem) - uartc->rxq.pos;
                        available += uartc->rxq.tail;
                }
                real = available > rest_buffer_size ? rest_buffer_size : available;
                if ((real + uartc->rxq.pos) >= sizeof(uartc->rxq.mem)) {
                        cp = sizeof(uartc->rxq.mem) - uartc->rxq.pos;
                        memcpy(&buf[pos], &uartc->rxq.mem[uartc->rxq.pos], cp);
                        memcpy(&buf[cp + pos], &uartc->rxq.mem[0], real - cp);
                        uartc->rxq.pos = real - cp;
                } else {
                        memcpy(&buf[pos], &uartc->rxq.mem[uartc->rxq.pos], real);
                        uartc->rxq.pos += real;
                }
                xwos_splk_unlock_cpuirqrs(&uartc->rxq.lock, cpuirq);
                pos += real;
                rest_buffer_size -= real;
                if (available > real) {
                        xwos_sem_post(&uartc->rxq.sem);
                }
        }
        xwds_uartc_put(uartc);
        *size = pos;
        return XWOK;
 
err_sem_wait_to:
        xwds_uartc_put(uartc);
err_uartc_grab:
        *size = pos;
        return rc;
}

函数调用图:

xwds_uartc_try_rx()

xwer_t xwds_uartc_try_rx	(	struct xwds_uartc *	uartc,
		xwu8_t *	buf,
		xwsz_t *	size
	)

XWDS API：尝试从接收队列中获取数据

参数

[in]	uartc	UART控制器对象指针
[out]	buf	指向缓冲区的指针，通过此缓冲区返回数据
[in,out]	size	指向缓冲区的指针，此缓冲区： (I) 作为输入时，表示缓冲区大小（单位：字节） (O) 作为输出时，返回实际读取的数据大小

返回

错误码

返回值

XWOK	没有错误
-EFAULT	无效指针
-ENODATA	没有数据

注解

• 上下文：中断、中断底半部、线程

<No error

在文件 controller.c 第 289 行定义.

{
        xwsz_t available, real, cp, rest_buffer_size;
        xwsq_t pos;
        xwreg_t cpuirq;
        xwer_t rc;
 
        XWDS_VALIDATE(uartc, "nullptr", -EFAULT);
        XWDS_VALIDATE(buf, "nullptr", -EFAULT);
        XWDS_VALIDATE(size, "nullptr", -EFAULT);
 
        pos = 0;
        rc = xwds_uartc_grab(uartc);
        if (rc < 0) {
                goto err_uartc_grab;
        }
        rest_buffer_size = *size;
        while (rest_buffer_size) {
                rc = xwos_sem_trywait(&uartc->rxq.sem);
                if (rc < 0) {
                        goto err_sem_trywait;
                }
                xwos_splk_lock_cpuirqsv(&uartc->rxq.lock, &cpuirq);
                if (uartc->rxq.tail >= uartc->rxq.pos) {
                        available = uartc->rxq.tail - uartc->rxq.pos;
                } else {
                        available = sizeof(uartc->rxq.mem) - uartc->rxq.pos;
                        available += uartc->rxq.tail;
                }
                real = available > rest_buffer_size ? rest_buffer_size : available;
                if ((real + uartc->rxq.pos) >= sizeof(uartc->rxq.mem)) {
                        cp = sizeof(uartc->rxq.mem) - uartc->rxq.pos;
                        memcpy(&buf[pos], &uartc->rxq.mem[uartc->rxq.pos], cp);
                        memcpy(&buf[cp + pos], &uartc->rxq.mem[0], real - cp);
                        uartc->rxq.pos = real - cp;
                } else {
                        memcpy(&buf[pos], &uartc->rxq.mem[uartc->rxq.pos], real);
                        uartc->rxq.pos += real;
                }
                xwos_splk_unlock_cpuirqrs(&uartc->rxq.lock, cpuirq);
                pos += real;
                rest_buffer_size -= real;
                if (available > real) {
                        xwos_sem_post(&uartc->rxq.sem);
                }
        }
        xwds_uartc_put(uartc);
        *size = pos;
        return XWOK;
 
err_sem_trywait:
        xwds_uartc_put(uartc);
err_uartc_grab:
        *size = pos;
        return rc;
}

函数调用图:

xwds_uartc_tx()

xwer_t xwds_uartc_tx	(	struct xwds_uartc *	uartc,
		const xwu8_t *	data,
		xwsz_t *	size,
		xwtm_t	to
	)

XWDS API：同步发送

参数

[in]	uartc	UART控制器对象指针
[in]	data	待发送的数据的缓冲区
[in,out]	size	指向缓冲区的指针，此缓冲区： (I) 作为输入时，表示期望发送的数据的大小（单位：字节） (O) 作为输出时，返回实际发送的数据大小
[in]	to	期望唤醒的时间点

返回

错误码

返回值

XWOK	没有错误
-EFAULT	无效指针
-ENOSYS	不支持此操作
-ECANCELED	发送被取消
-ETIMEDOUT	超时

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 controller.c 第 348 行定义.

{
        const struct xwds_uartc_driver * drv;
        xwer_t rc;
 
        XWDS_VALIDATE(uartc, "nullptr", -EFAULT);
        XWDS_VALIDATE(data, "nullptr", -EFAULT);
        XWDS_VALIDATE(size, "nullptr", -EFAULT);
 
        rc = xwds_uartc_grab(uartc);
        if (rc < 0) {
                goto err_uartc_grab;
        }
        rc = xwos_mtx_lock_to(&uartc->txmtx, to);
        if (rc < 0) {
                goto err_uartc_lock;
        }
        drv = xwds_cast(const struct xwds_uartc_driver *, uartc->dev.drv);
        if ((drv) && (drv->tx)) {
                rc = drv->tx(uartc, data, size, to);
        } else {
                rc = -ENOSYS;
        }
        if (rc < 0) {
                goto err_tx;
        }
        xwos_mtx_unlock(&uartc->txmtx);
        xwds_uartc_put(uartc);
        return XWOK;
 
err_tx:
        xwos_mtx_unlock(&uartc->txmtx);
err_uartc_lock:
        xwds_uartc_put(uartc);
err_uartc_grab:
        return rc;
}

函数调用图: