参考资料：

《LINUX设备驱动程序第三版》
linux-5.4.9

0.前言

在今天终于离职了，办完了所有的手续，感觉一身轻松，在上一家公司，作为一名程序员，已经在偏离写代码开发的歪门邪道上越走越远了，现在疫情比较严重，非常时间，大家还是要少出门，注意安全，所以就趁这段时间总结一下之前工作中的问题和经验吧。

1.tty与串口驱动

tty设备的名称是从过去的电传打字机缩写而来，最初是指连接到Unix系统上的物理或者虚拟终端。随着时间的推移，当通过串行口能够建立起终端连接后，这个名字也用来指任何的串口设备。有三种类型的tty'驱动程序：控制台、串口和pty。控制台和pty驱动程序已经被编写好饿了，而且可能也不必为这两类tty驱动程序编写其他的驱动程序。这使得任何使用tty核心与用户和系统交互的新驱动程序都可被看成是串口驱动程序。

2.关于tty

Linux tty驱动程序的核心紧挨着标准字符设备驱动层之下，并提供了一系列的功能，作为接口被终端类型设备使用。内核负责控制通过tty设备的数据流，并且格式化这些数据。这使得tty驱动程序把重点放在处理流向或者流出硬件的数据上，而不必重点考虑使用常规方法与用户空间的交互。为了控制数据流，有许多不同的线路规程（line discipline）可虚拟地“插入”任何的tty设备上，这由不同的tty线路规程驱动程序实现。

在这里插入图片描述

tty核心从用户那里得到将被发往tty设备的数据，然后把数据发送给tty线路规程驱动程序，该驱动程序负责把数据传递给tty驱动程序。tty驱动程序对数据进行格式化，然后才能发送给硬件。从tty硬件那里接收到的数据将回溯到tty驱动程序，然后流入tty线路规程驱动程序，接着是tty核心，最后用户从tty核心哪里得到数据。有时tty驱动程序直接与tty核心通信，tty核心将数据直接发送给tty驱动程序，但通常是tty线路规程驱动程序修改在二者之间流动的数据。

3.添加Device

在arch/arm/boot/dts下的.dtsi文件下添加串口相关的device信息

在这里插入图片描述

在imx.c下会通过MODULE_DEVICE_TABLE()去匹配一个device 在这里插入图片描述

4.添加Driver

串口设备驱动核心结构体为uart_driver，在文件linux/drivers/serial/imx.c

static struct uart_driver imx_uart_uart_driver = {
	.owner          = THIS_MODULE,
	.driver_name    = DRIVER_NAME,                 //driver name
	.dev_name       = DEV_NAME,                    //device name
	.major          = SERIAL_IMX_MAJOR,            //主设备号
	.minor          = MINOR_START,                 //次设备号
	.nr             = ARRAY_SIZE(imx_uart_ports),
	.cons           = IMX_CONSOLE,
};

串口驱动注册

static int __init imx_uart_init(void)
{
	int ret = uart_register_driver(&imx_uart_uart_driver);         //用uart核心层注册一个驱动程序

	if (ret)
		return ret;

	ret = platform_driver_register(&imx_uart_platform_driver);    //调用platform_driver_register向内核注册
	if (ret != 0)
		uart_unregister_driver(&imx_uart_uart_driver);

	return ret;
}

uart_register_driver()函数，在drivers/tty/serial/serial_core.c中。任何tty驱动程序的主要数据结构是结构tty_driver，被用来向tty核心注册和注销驱动程序

int uart_register_driver(struct uart_driver *drv)
{
	struct tty_driver *normal;
	int i, retval = -ENOMEM;

	...
	//每个端口对应一个state
	drv->state = kzalloc(sizeof(struct uart_state)* drv->nr, GFP_KERNEL);
	...
	//分配该串口驱动对应的tty_drvier，tty_driver结构将根据tty驱动程序的需求，用正确的信息初始化
	normal = alloc_tty_driver(drv->nr);
	...
	//让drv->tty_driver字段指向这个tty_driver
	drv->tty_driver = normal;
	...
	//使用tty_set_operation函数拷贝在驱动程序定义的一系列操作函数
	tty_set_operation(normal, &uart_ops);
	...
	//注册tty驱动程序
	retval = tty_register_driver(normal);

}

为了向tty核心注册这个驱动程序，必须将tty_driver结构传递给tty_register_driver函数。在注册自身后，驱动程序使用tty_register_device函数注册它所控制的设备，该函数有三个参数：

属于该设备的tty_driver结构指针
设备的次设备号
指向该tty设备所绑定的device结构指针，如果tty设备没有绑定任何device结构，该参数为NULL

 int tty_register_driver(struct tty_driver *driver)
 {
 	...
 	for (i = 0; i < driver->num; i++) {
			d = tty_register_device(driver, i, NULL);
			...
	}
	...
 }

5.platform机制

在driver和device匹配成功之后，会调用probe函数

在这里插入图片描述

static int imx_uart_probe(struct platform_device *pdev)
{
	struct imx_port *sport;
	void __iomem *base;
	int ret = 0;
	u32 ucr1;
	struct resource *res;
	int txirq, rxirq, rtsirq;

	...
	
	sport = devm_kzalloc(&pdev->dev, sizeof(*sport), GFP_KERNEL);
	
	...
	
	//添加一个端口结构
	return uart_add_one_port(&imx_uart_uart_driver, &sport->port);
}

int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
{
	struct uart_state *state;
	struct tty_port *port;
	int ret = 0;
	struct device *tty_dev;
	int num_groups;

	...
	
	//注册tty设备
	tty_dev = tty_port_register_device_attr_serdev(port, drv->tty_driver,
			uport->line, uport->dev, port, uport->tty_groups);
	if (!IS_ERR(tty_dev)) {
		device_set_wakeup_capable(tty_dev, 1);
	} else {
		dev_err(uport->dev, "Cannot register tty device on line %d\n",
		       uport->line);
	}

	...

	return ret;
}

6.串口数据流

在这里插入图片描述

open函数

static int tty_open(struct inode *inode, struct file *filp)
{
	struct tty_struct *tty;
	int noctty, retval;
	dev_t device = inode->i_rdev;              //表示设备文件的结点，这个域实际上包含了设备号
	unsigned saved_flags = filp->f_flags;

	...

	if (tty->ops->open)
		retval = tty->ops->open(tty, filp);    //调用uart_open函数
	else
		retval = -ENODEV;
	filp->f_flags = saved_flags;

	...
	
	return 0;
}

static int uart_open(struct tty_struct *tty, struct file *filp)
{
	struct uart_state *state = tty->driver_data;
	int retval;

	retval = tty_port_open(&state->port, tty, filp);
	if (retval > 0)
		retval = 0;

	return retval;
}

当用户使用open打开由驱动程序分配的设备节点时，tty核心将调用open函数。tty核心使用分配给该设备tty_struct结构的指针，以及一个文件描述符作为参数调用该函数。

release函数

int tty_release(struct inode *inode, struct file *filp)
{
	struct tty_struct *tty = file_tty(filp);
	struct tty_struct *o_tty = NULL;
	int	do_sleep, final;
	int	idx;
	long	timeout = 0;
	int	once = 1;

	...
	
	tty_debug_hangup(tty, "releasing (count=%d)\n", tty->count);

	if (tty->ops->close)
		tty->ops->close(tty, filp);   //调用uart_close函数

	/* If tty is pty master, lock the slave pty (stable lock order) */
	tty_lock_slave(o_tty);
	
	...

	tty_release_struct(tty, idx);
	return 0;
}

static void uart_close(struct tty_struct *tty, struct file *filp)
{
	struct uart_state *state = tty->driver_data;

	if (!state) {
		struct uart_driver *drv = tty->driver->driver_state;
		struct tty_port *port;

		state = drv->state + tty->index;
		port = &state->port;
		spin_lock_irq(&port->lock);
		--port->count;
		spin_unlock_irq(&port->lock);
		return;
	}

	pr_debug("uart_close(%d) called\n", tty->index);

	tty_port_close(tty->port, tty, filp);
}

当用户使用先前由open函数创建的文件句柄作为参数调用close时，tty核心调用close函数指针，此时该设备将被关闭。

write函数

static ssize_t tty_write(struct file *file, const char __user *buf,
						size_t count, loff_t *ppos)
{
	struct tty_struct *tty = file_tty(file);
 	struct tty_ldisc *ld;
	ssize_t ret;

	if (tty_paranoia_check(tty, file_inode(file), "tty_write"))
		return -EIO;
	if (!tty || !tty->ops->write ||	tty_io_error(tty))
			return -EIO;
	/* Short term debug to catch buggy drivers */
	if (tty->ops->write_room == NULL)
		tty_err(tty, "missing write_room method\n");
	ld = tty_ldisc_ref_wait(tty); 
	if (!ld)
		return hung_up_tty_write(file, buf, count, ppos);
	/*调用线路规程操作函数集中的n_tty_write()函数*/
	if (!ld->ops->write)
		ret = -EIO;
	else
		ret = do_tty_write(ld->ops->write, tty, file, buf, count);
	tty_ldisc_deref(ld);
	return ret;
}

static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
			   const unsigned char *buf, size_t nr)
{
	const unsigned char *b = buf;
	DEFINE_WAIT_FUNC(wait, woken_wake_function);
	int c;
	ssize_t retval = 0;

	/* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
	if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
		retval = tty_check_change(tty);
		if (retval)
			return retval;
	}

	down_read(&tty->termios_rwsem);

	/* Write out any echoed characters that are still pending */
	process_echoes(tty);

	add_wait_queue(&tty->write_wait, &wait);
	while (1) {
	
			...
			/*调用uart_flush_chars向硬件发送数据*/
			if (tty->ops->flush_chars)
				tty->ops->flush_chars(tty);
		} else {
			struct n_tty_data *ldata = tty->disc_data;

			while (nr > 0) {
				mutex_lock(&ldata->output_lock);
				c = tty->ops->write(tty, b, nr);   //或者调用uart_write函数
				mutex_unlock(&ldata->output_lock);
				if (c < 0) {
					retval = c;
					goto break_out;
				}
				if (!c)
					break;
				b += c;
				nr -= c;
			}
		}
		
		...
		
	}
break_out:
	remove_wait_queue(&tty->write_wait, &wait);
	if (nr && tty->fasync)
		set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
	up_read(&tty->termios_rwsem);
	return (b - buf) ? b - buf : retval;
}

static void uart_flush_chars(struct tty_struct *tty)
{
	uart_start(tty);
}

static int uart_write(struct tty_struct *tty,
					const unsigned char *buf, int count)
{
	struct uart_state *state = tty->driver_data;
	struct uart_port *port;
	struct circ_buf *circ;
	unsigned long flags;
	int c, ret = 0;

	/*
	 * This means you called this function _after_ the port was
	 * closed.  No cookie for you.
	 */
	if (!state) {
		WARN_ON(1);
		return -EL3HLT;
	}

	port = uart_port_lock(state, flags);
	circ = &state->xmit;
	if (!circ->buf) {
		uart_port_unlock(port, flags);
		return 0;
	}

	while (port) {
		c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
		if (count < c)
			c = count;
		if (c <= 0)
			break;
		memcpy(circ->buf + circ->head, buf, c);
		circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
		buf += c;
		count -= c;
		ret += c;
	}

	__uart_start(tty);
	uart_port_unlock(port, flags);
	return ret;
}

static void uart_start(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
	struct uart_port *port;
	unsigned long flags;

	port = uart_port_lock(state, flags);
	__uart_start(tty);
	uart_port_unlock(port, flags);
}

static void __uart_start(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
	struct uart_port *port = state->uart_port;

	if (port && !uart_tx_stopped(port))
		port->ops->start_tx(port);   //调用imx.c中的imx_uart_start_tx函数发送数据
}

当数据要被发送给硬件时，用户调用write函数，首先tty核心接收到了该调用，然后内核将数据发送给tty驱动程序的write函数。tty核心同时也告诉tty驱动程序发功数据的大小。

read函数

static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
			loff_t *ppos)
{
	int i;
	struct inode *inode = file_inode(file);
	struct tty_struct *tty = file_tty(file);
	struct tty_ldisc *ld;

	if (tty_paranoia_check(tty, inode, "tty_read"))
		return -EIO;
	if (!tty || tty_io_error(tty))
		return -EIO;

	/* We want to wait for the line discipline to sort out in this
	   situation */
	ld = tty_ldisc_ref_wait(tty);
	if (!ld)
		return hung_up_tty_read(file, buf, count, ppos);
	/*调用线路规程操作函数集中的n_tty_read()函数*/
	if (ld->ops->read)
		i = ld->ops->read(tty, file, buf, count);
	else
		i = -EIO;
	tty_ldisc_deref(ld);

	if (i > 0)
		tty_update_time(&inode->i_atime);

	return i;
}

static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
			 unsigned char __user *buf, size_t nr)
{
	struct n_tty_data *ldata = tty->disc_data;
	unsigned char __user *b = buf;
	DEFINE_WAIT_FUNC(wait, woken_wake_function);
	int c;
	int minimum, time;
	ssize_t retval = 0;
	long timeout;
	int packet;
	size_t tail;

	...
	
	while (nr) {
		
		...
		/*如果配置了icanon，那么就按canonical模式拷贝读取的数据*/
		if (ldata->icanon && !L_EXTPROC(tty)) {
			retval = canon_copy_from_read_buf(tty, &b, &nr);
			if (retval)
				break;
		} else {
			int uncopied;

			/* Deal with packet mode. */
			if (packet && b == buf) {
				if (put_user(TIOCPKT_DATA, b)) {
					retval = -EFAULT;
					break;
				}
				b++;
				nr--;
			}

			uncopied = copy_from_read_buf(tty, &b, &nr);
			uncopied += copy_from_read_buf(tty, &b, &nr);
			if (uncopied) {
				retval = -EFAULT;
				break;
			}
		}

		n_tty_check_unthrottle(tty);

		if (b - buf >= minimum)
			break;
		if (time)
			timeout = time;
	}
	
	...

	return retval;
}

如果配置了串口中断，串口在接收到数据后，触发中断

static irqreturn_t imx_uart_rxint(int irq, void *dev_id)
{
	struct imx_port *sport = dev_id;
	unsigned int rx, flg, ignored = 0;
	struct tty_port *port = &sport->port.state->port;

	spin_lock(&sport->port.lock);

	while (imx_uart_readl(sport, USR2) & USR2_RDR) {
		
		...

		if (uart_handle_sysrq_char(&sport->port, (unsigned char)rx))
			continue;

		if (unlikely(rx & URXD_ERR)) {
			
			...
			/*读取寄存器的数据*/
			rx &= (sport->port.read_status_mask | 0xFF);

			if (rx & URXD_BRK)
				flg = TTY_BREAK;
			else if (rx & URXD_PRERR)
				flg = TTY_PARITY;
			else if (rx & URXD_FRMERR)
				flg = TTY_FRAME;
			if (rx & URXD_OVRRUN)
				flg = TTY_OVERRUN;

#ifdef SUPPORT_SYSRQ
			sport->port.sysrq = 0;
#endif
		}

		if (sport->port.ignore_status_mask & URXD_DUMMY_READ)
			goto out;

		if (tty_insert_flip_char(port, rx, flg) == 0)
			sport->port.icount.buf_overrun++;
	}

out:
	spin_unlock(&sport->port.lock);
	tty_flip_buffer_push(port);
	return IRQ_HANDLED;
}

调用tty_insert_flip_char将把tty驱动程序获得的、准备发给用户的字符添加到交替缓冲区中。第一个参数是保存数据的tty_struct结构，第二个参数是需要保存的数据，第三个参数是为此字符设置的标志位。如果接收到的字符是常规字符，标志位应该被设置为TTY_NORMAL。

如果配置了DMA模式，从DMA拷贝数据

static int imx_uart_start_rx_dma(struct imx_port *sport)
{
	struct scatterlist *sgl = &sport->rx_sgl;
	struct dma_chan	*chan = sport->dma_chan_rx;
	struct device *dev = sport->port.dev;
	struct dma_async_tx_descriptor *desc;
	int ret;

	sport->rx_ring.head = 0;
	sport->rx_ring.tail = 0;
	sport->rx_periods = RX_DMA_PERIODS;

	sg_init_one(sgl, sport->rx_buf, RX_BUF_SIZE);
	
	...
	
	desc->callback = imx_uart_dma_rx_callback;
	desc->callback_param = sport;

	dev_dbg(dev, "RX: prepare for the DMA.\n");
	sport->dma_is_rxing = 1;
	sport->rx_cookie = dmaengine_submit(desc);
	dma_async_issue_pending(chan);
	return 0;
}

tty核心和tty_driver结构并未提供read函数，当tty驱动程序接收到数据后，它将负责把从硬件获取到的任何数据传递给tty核心，而不是使用传统的read函数。tty核心将缓冲数据直到接到来自用户的请求。由于tty核心已提供了缓冲逻辑，因此没有必要为每个tty驱动程序实现它们自己的缓冲区逻辑。当用户要求驱动程序开始或者停止传输数据时，tty核心将通知tty驱动程序。

7.DMA和中断的配置

static int imx_uart_startup(struct uart_port *port)
{
	struct imx_port *sport = (struct imx_port *)port;
	int retval, i;
	unsigned long flags;
	int dma_is_inited = 0;
	u32 ucr1, ucr2, ucr4;

	...
	/*如果dma_is_inited为真，则配置DMA模式，否则使能串口中断*/
	if (dma_is_inited) {
		imx_uart_enable_dma(sport);
		imx_uart_start_rx_dma(sport);
	} else {
		ucr1 = imx_uart_readl(sport, UCR1);
		ucr1 |= UCR1_RRDYEN;
		imx_uart_writel(sport, ucr1, UCR1);

		ucr2 = imx_uart_readl(sport, UCR2);
		ucr2 |= UCR2_ATEN;
		imx_uart_writel(sport, ucr2, UCR2);
	}

	spin_unlock_irqrestore(&sport->port.lock, flags);

	return 0;
}

来源：oschina

链接：https://my.oschina.net/u/4060728/blog/3178406

标签

串口

Linux驱动开发-串口驱动

0.前言

1.tty与串口驱动

2.关于tty

3.添加Device

4.添加Driver

5.platform机制

6.串口数据流

7.DMA和中断的配置