tty初探 — uart驱动框架分析

写在前面： 我们没有讲UART驱动，不过我们认为，只要系统学习了第2期，应该具备分析UART驱动的能力，小编做答疑几年以来，陆陆续续有不少人问到UART驱动怎么写，所以今天就分享一篇深度长文(17000字，阅读时间43分钟)，作者是我们的答疑助手lizuobin，涉及很多数据结构，为了看懂本文，特意打开source insight 跟踪了代码，你也应该这样，如果你的代码不一样，那或许linux版本不一样。

作者：lizuobin 原文(有些许修正)： https://blog.csdn.net/lizuobin2/article/details/51773305

本文参考了大量牛人的博客，对大神的分享表示由衷的感谢。主要参考： Linux TTY驱动--Uart_driver底层： http://blog.csdn.net/sharecode/article/details/9196591 Linux TTY驱动--Serial Core层： http://blog.csdn.net/sharecode/article/details/9197567

前面学习过了 i2c、spi，这俩都是基于设备总线驱动模型，分析起来相对比较简单，今天打算迎难而上学习一下 Uart 驱动，因为它涉及了tty 、线路规程，确实有些难度，幸好有万能的互联网让我可以学习大神们的博客。一天下来总算有些收获，下面总结一下（主要是框架）。

整个uart 框架大概如上图所示，简单来分的话可以说成两层，一层是下层我们的串口驱动层，它直接与硬件接触，我们需要填充一个 struct uart_ops 的结构体，另一层是上层 tty 层，包括 tty 核心以及线路规程，它们各自都有一个 Ops 结构，用户空间通过 tty 注册的字符设备节点来访问，这么说来如上图所示涉及到了4个 ops 结构了，层层跳转。下面，就来分析分析它们的层次结构。

在 s3c2440平台，它是这样来注册串口驱动的：分配一个struct uart_driver 简单填充，并调用uart_register_driver 注册到内核中去。

1static struct uart_driver s3c24xx_uart_drv = {
2  .owner    = THIS_MODULE,
3  .dev_name  = "s3c2410_serial",
4  .nr    = CONFIG_SERIAL_SAMSUNG_UARTS,
5  .cons    = S3C24XX_SERIAL_CONSOLE,
6  .driver_name  = S3C24XX_SERIAL_NAME,
7  .major    = S3C24XX_SERIAL_MAJOR,
8  .minor    = S3C24XX_SERIAL_MINOR,
9};
10static int __init s3c24xx_serial_modinit(void)
11{
12  int ret;
13 
14  ret = uart_register_driver(&s3c24xx_uart_drv);
15  if (ret < 0) {
16    printk(KERN_ERR "failed to register UART driver\n");
17    return -1;
18  }
19 
20  return 0;
21}

uart_driver 中，我们只是填充了一些名字、设备号等信息，这些都是不涉及底层硬件访问的，到底怎么回事呢？来看一下完整的 uart_driver 结构或许就明白了。

1struct uart_driver {
2  struct module    *owner;  /* 拥有该uart_driver的模块,一般为THIS_MODULE */
3  const char    *driver_name;  /* 串口驱动名，串口设备文件名以驱动名为基础 */
4  const char    *dev_name;  /* 串口设备名 */
5  int       major;      /* 主设备号 */
6  int       minor;      /* 次设备号 */
7  int       nr;      /* 该uart_driver支持的串口个数(最大) */
8  struct console    *cons;  /* 其对应的console.若该uart_driver支持serial console,否则为NULL */
9 
10  /* 下面这俩，它们应该被初始化为NULL */
11  struct uart_state  *state;  <span style="white-space:pre">  </span>/* 下层，串口驱动层 */
12  struct tty_driver  *tty_driver;  /* tty相关 */
13};

在我们上边填充的结构体中，有两个成员未被赋值，对于tty_driver 代表的是上层，它会在 uart_register_driver中的过程中赋值，而uart_state 则代表下层，uart_state 也会在uart_register_driver的过程中分配空间，但是它里面真正设置硬件相关的东西是 uart_state->uart_port ，这个uart_port 是需要我们从其它地方调用 uart_add_one_port 来添加的。

1、下层（串口驱动层）

首先，我们需要认识这几个结构体

1struct uart_state {
2  struct tty_port    port;
3  int      pm_state;
4  struct circ_buf    xmit;
5  struct tasklet_struct  tlet;
6  struct uart_port  *uart_port;  // 对应于一个串口设备
7};

在注册 driver 时，会根据 uart_driver->nr 来申请 nr 个 uart_state 空间，用来存放驱动所支持的串口（端口）的物理信息。

1struct uart_port {
2  spinlock_t    lock;      /* port lock */
3  unsigned long    iobase;      /* io端口基地址（物理） */
4  unsigned char __iomem  *membase;    /* io内存基地址（虚拟） */
5  unsigned int    (*serial_in)(struct uart_port *, int);
6  void      (*serial_out)(struct uart_port *, int, int);
7  unsigned int    irq;      /* 中断号 */
8  unsigned long    irqflags;    /* 中断标志  */
9  unsigned int    uartclk;    /* 串口时钟 */
10  unsigned int    fifosize;    /* 串口缓冲区大小 */
11  unsigned char    x_char;      /* xon/xoff char */
12  unsigned char    regshift;    /* 寄存器位移 */
13  unsigned char    iotype;      /* IO访问方式 */
14  unsigned char    unused1;
15 
16  unsigned int    read_status_mask;  /* 关心 Rx error status */
17  unsigned int    ignore_status_mask;  /* 忽略 Rx error status */
18  struct uart_state  *state;      /* pointer to parent state */
19  struct uart_icount  icount;      /* 串口信息计数器 */
20 
21  struct console    *cons;      /* struct console, if any */
22#if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(SUPPORT_SYSRQ)
23  unsigned long    sysrq;      /* sysrq timeout */
24#endif
25 
26  upf_t      flags;
27 
28  unsigned int    mctrl;      /* 当前的Moden 设置 */
29  unsigned int    timeout;    /* character-based timeout */
30  unsigned int    type;      /* 端口类型 */
31  const struct uart_ops  *ops;    /* 串口端口操作函数 */
32  unsigned int    custom_divisor;
33  unsigned int    line;      /* 端口索引 */
34  resource_size_t    mapbase;    /* io内存物理基地址 */
35  struct device    *dev;      /* 父设备 */
36  unsigned char    hub6;      /* this should be in the 8250 driver */
37  unsigned char    suspended;
38  unsigned char    unused[2];
39  void      *private_data;    /* generic platform data pointer */
40};

这个结构体，是需要我们自己来填充的，比如s3c2440 有3个串口，那么就需要填充3个 uart_port ，并且通过 uart_add_one_port 添加到 uart_driver->uart_state->uart_port 中去。当然 uart_driver 有多个 uart_state ，每个 uart_state 有一个 uart_port 。

在 uart_port 里还有一个非常重要的成员 struct uart_ops *ops ，这个也是需要我们自己来实现的，一般芯片厂家都写好了或者只需要稍作修改。

1struct uart_ops {
2  unsigned int  (*tx_empty)(struct uart_port *);   /* 串口的Tx FIFO缓存是否为空 */
3  void    (*set_mctrl)(struct uart_port *, unsigned int mctrl);  /* 设置串口modem控制 */
4  unsigned int  (*get_mctrl)(struct uart_port *);  /* 获取串口modem控制 */
5  void    (*stop_tx)(struct uart_port *);    /* 禁止串口发送数据 */
6  void    (*start_tx)(struct uart_port *);  /* 使能串口发送数据 */  
7  void    (*send_xchar)(struct uart_port *, char ch);  /* 发送xChar */
8  void    (*stop_rx)(struct uart_port *);    /* 禁止串口接收数据 */
9  void    (*enable_ms)(struct uart_port *);  /* 使能modem的状态信号 */
10  void    (*break_ctl)(struct uart_port *, int ctl);  /* 设置break信号 */
11  int      (*startup)(struct uart_port *);    /* 启动串口,应用程序打开串口设备文件时,该函数会被调用 */
12  void    (*shutdown)(struct uart_port *);/* 关闭串口,应用程序关闭串口设备文件时,该函数会被调用 */
13  void    (*flush_buffer)(struct uart_port *);
14  void    (*set_termios)(struct uart_port *, struct ktermios *new,
15               struct ktermios *old);  /* 设置串口参数 */
16  void    (*set_ldisc)(struct uart_port *);/* 设置线路规程 */
17  void    (*pm)(struct uart_port *, unsigned int state,
18            unsigned int oldstate);  /* 串口电源管理 */
19  int    (*set_wake)(struct uart_port *, unsigned int state);
20 
21  /*
22   * Return a string describing the type of the port
23   */
24  const char *(*type)(struct uart_port *);
25 
26  /*
27   * Release IO and memory resources used by the port.
28   * This includes iounmap if necessary.
29   */
30  void    (*release_port)(struct uart_port *);
31 
32  /*
33   * Request IO and memory resources used by the port.
34   * This includes iomapping the port if necessary.
35   */
36  int    (*request_port)(struct uart_port *);  /* 申请必要的IO端口/IO内存资源,必要时还可以重新映射串口端口 */
37  void    (*config_port)(struct uart_port *, int); /* 执行串口所需的自动配置 */
38  int    (*verify_port)(struct uart_port *, struct serial_struct *); /* 核实新串口的信息 */
39  int    (*ioctl)(struct uart_port *, unsigned int, unsigned long);
40#ifdef CONFIG_CONSOLE_POLL
41  void  (*poll_put_char)(struct uart_port *, unsigned char);
42  int    (*poll_get_char)(struct uart_port *);
43#endif
44};

实在是太复杂了。但这一层就跟裸机程序一样，用来操作硬件寄存器，只不过内核把“格式”给我们规定死了。

2、上层（tty 核心层）

tty 层要从 uart_register_driver来看起了，因为tty_driver是在注册过程中构建的，我们也顺便了解注册过程。

1int uart_register_driver(struct uart_driver *drv)
2{
3  struct tty_driver *normal = NULL;
4  int i, retval;
5 
6 
7  /* 根据driver支持的最大设备数，申请n个 uart_state 空间，每一个 uart_state 都有一个uart_port */
8  drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
9  
10  /* tty层：分配一个 tty_driver ，并将drv->tty_driver 指向它 */
11  normal  = alloc_tty_driver(drv->nr);
12  drv->tty_driver = normal;
13  
14  /* 对 tty_driver 进行设置 */
15  normal->owner    = drv->owner;
16  normal->driver_name  = drv->driver_name;
17  normal->name    = drv->dev_name;
18  normal->major    = drv->major;
19  normal->minor_start  = drv->minor;
20  normal->type    = TTY_DRIVER_TYPE_SERIAL;
21  normal->subtype    = SERIAL_TYPE_NORMAL;
22  normal->init_termios  = tty_std_termios;
23  normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
24  normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;
25  normal->flags    = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
26  normal->driver_state    = drv;
27    
28  tty_set_operations(normal, &uart_ops);
29 
30  /*
31   * Initialise the UART state(s).
32   */
33  for (i = 0; i < drv->nr; i++) {
34    struct uart_state *state = drv->state + i;
35    struct tty_port *port = &state->port;  /* driver->state->tty_port */
36 
37    tty_port_init(port);
38    port->close_delay     = 500;  /* .5 seconds */
39    port->closing_wait    = 30000;  /* 30 seconds */
40    /* 初始化 tasklet */
41    tasklet_init(&state->tlet, uart_tasklet_action,
42           (unsigned long)state);
43  }
44  
45  /* tty层：注册 driver->tty_driver */
46  retval = tty_register_driver(normal);
47 
48}

注册过程干了哪些事： 1、根据driver支持的最大设备数，申请n个 uart_state 空间，每一个 uart_state 都有一个 uart_port 。

2、分配一个 tty_driver ，并将drv->tty_driver 指向它。

3、对 tty_driver 进行设置，其中包括默认波特率、校验方式等，还有一个重要的 Ops ，uart_ops ，它是tty核心与我们串口驱动通信的接口。

4、初始化每一个 uart_state 的 tasklet 。

5、注册 tty_driver 。

1static const struct tty_operations uart_ops = {
2  .open    = uart_open,
3  .close    = uart_close,
4  .write    = uart_write,
5  .put_char  = uart_put_char,    // 单字节写函数
6  .flush_chars  = uart_flush_chars,  // 刷新数据到硬件函数
7  .write_room  = uart_write_room,    // 指示多少缓冲空闲的函数
8  .chars_in_buffer= uart_chars_in_buffer,  // 只是多少缓冲满的函数
9  .flush_buffer  = uart_flush_buffer,  // 刷新数据到硬件
10  .ioctl    = uart_ioctl,
11  .throttle  = uart_throttle,
12  .unthrottle  = uart_unthrottle,
13  .send_xchar  = uart_send_xchar,
14  .set_termios  = uart_set_termios,  // 当termios设置被改变时又tty核心调用
15  .set_ldisc  = uart_set_ldisc,    // 设置线路规程函数
16  .stop    = uart_stop,  
17  .start    = uart_start,
18  .hangup    = uart_hangup,    // 挂起函数，当驱动挂起tty设备时调用
19  .break_ctl  = uart_break_ctl,  // 线路中断控制函数
20  .wait_until_sent= uart_wait_until_sent,
21#ifdef CONFIG_PROC_FS
22  .proc_fops  = &uart_proc_fops,
23#endif
24  .tiocmget  = uart_tiocmget,  // 获得当前tty的线路规程的设置
25  .tiocmset  = uart_tiocmset,  // 设置当前tty线路规程的设置
26#ifdef CONFIG_CONSOLE_POLL
27  .poll_init  = uart_poll_init,
28  .poll_get_char  = uart_poll_get_char,
29  .poll_put_char  = uart_poll_put_char,
30#endif
31};

这个是 tty 核心的 Ops ，简单看看，等后面分析调用关系时，在来细看，下面来看 tty_driver 的注册。

1int tty_register_driver(struct tty_driver *driver)
2{
3  int error;
4  int i;
5  dev_t dev;
6  void **p = NULL;
7 
8  if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
9    p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
10  }
11  
12  /* 如果没有主设备号则申请 */
13  if (!driver->major) {
14    error = alloc_chrdev_region(&dev, driver->minor_start,
15            driver->num, driver->name);
16  } else {
17    dev = MKDEV(driver->major, driver->minor_start);
18    error = register_chrdev_region(dev, driver->num, driver->name);
19  }
20 
21  if (p) { /* 为线路规程和termios分配空间 */
22    driver->ttys = (struct tty_struct **)p;
23    driver->termios = (struct ktermios **)(p + driver->num);
24  } else {
25    driver->ttys = NULL;
26    driver->termios = NULL;
27  }
28 
29  /* 创建字符设备，使用 tty_fops */
30  cdev_init(&driver->cdev, &tty_fops);
31  driver->cdev.owner = driver->owner;
32  error = cdev_add(&driver->cdev, dev, driver->num);
33 
34  mutex_lock(&tty_mutex);
35  
36  /* 将该 driver->tty_drivers 添加到全局链表 tty_drivers */
37  list_add(&driver->tty_drivers, &tty_drivers);
38  mutex_unlock(&tty_mutex);
39 
40  if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
41    for (i = 0; i < driver->num; i++)
42        tty_register_device(driver, i, NULL);
43  }
44  
45  /* proc 文件系统注册driver */
46  proc_tty_register_driver(driver);
47  driver->flags |= TTY_DRIVER_INSTALLED;
48  return 0;
49}

tty_driver 注册过程干了哪些事： 1、为线路规程和termios分配空间，并使 tty_driver 相应的成员指向它们。

2、注册字符设备，名字是 uart_driver->name 我们这里是“ttySAC”,文件操作函数集是 tty_fops。

3、将该 uart_driver->tty_drivers 添加到全局链表 tty_drivers 。

4、向 proc 文件系统添加 driver ，这个暂时不了解。

至此，文章起初的结构图中的4个ops已经出现了3个，另一个关于线路规程的在哪？继续往下看。

3、调用关系分析

tty_driver 不是注册了一个字符设备么，那我们就以它的 tty_fops 入手，以 open、read、write 为例，看看用户空间是如何访问到最底层的硬件操作函数的。

3.1 tty_open

1static int tty_open(struct inode *inode, struct file *filp)
2{
3  int ret;
4 
5  lock_kernel();
6  ret = __tty_open(inode, filp);
7  unlock_kernel();
8  return ret;
9}
10
11为了方便分析，我把看不懂的代码都删掉了。
12
13static int __tty_open(struct inode *inode, struct file *filp)
14{
15  struct tty_struct *tty = NULL;
16  int noctty, retval;
17  struct tty_driver *driver;
18  int index;
19  dev_t device = inode->i_rdev;
20  unsigned saved_flags = filp->f_flags;
21  ...  
22  //在全局tty_drivers链表中获取Core注册的tty_driver
23  driver = get_tty_driver(device, &index);
24  
25  tty = tty_init_dev(driver, index, 0);  // tty->ops = driver->ops;
26 
27  filp->private_data = tty;
28 
29  if (tty->ops->open)
30    /* 调用tty_driver->tty_foperation->open */
31    retval = tty->ops->open(tty, filp);
32  
33  return 0;
34}
35
36从 tty_drivers 全局链表获取到前边我们注册进去的 tty_driver ，然后分配设置一个 struct tty_struct 的东西，最后调用 tty_struct->ops->open 函数，其实 tty_struct->ops == tty_driver->ops 。
37
38struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx, int first_ok)
39{
40  struct tty_struct *tty;
41  int retval;
42  /* 分配一个 tty_struct */
43  tty = alloc_tty_struct();
44  
45  /* 初始化 tty ，设置线路规程 Ops 等 */
46  initialize_tty_struct(tty, driver, idx);
47  
48  //tty_ldisc_open(tty, ld)-> return ld->ops->open(tty) -> n_tty_open
49  retval = tty_ldisc_setup(tty, tty->link);  
50  
51  return tty;
52}
53
54void initialize_tty_struct(struct tty_struct *tty,
55    struct tty_driver *driver, int idx)
56{
57  memset(tty, 0, sizeof(struct tty_struct));
58 
59  /* 设置线路规程为 N_TTY */
60  tty_ldisc_init(tty);//struct tty_ldisc *ld = tty_ldisc_get(N_TTY);tty_ldisc_assign(tty, ld);
61 
62  ...
63  tty_buffer_init(tty);
64  tty->driver = driver;
65  
66  /* 初始化等待队列头 */
67  init_waitqueue_head(&tty->write_wait);
68  init_waitqueue_head(&tty->read_wait);
69  
70  /* 将driver->ops 拷贝到 tty->ops  */
71  tty->ops = driver->ops;
72  tty->index = idx;
73}
74
75
76void tty_buffer_init(struct tty_struct *tty)
77{
78  spin_lock_init(&tty->buf.lock);
79  tty->buf.head = NULL;
80  tty->buf.tail = NULL;
81  tty->buf.free = NULL;
82  tty->buf.memory_used = 0;
83  
84  /* 初始化延时工作队列 */
85  INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);
86}

整个 tty_open 的工作： 1、获取 tty_driver

2、根据 tty_driver 初始化一个 tty_struct

2.1 设置 tty_struct 的线路规程为 N_TTY (不同类型的线路规程有不同的 ops)

2.2 初始化一个延时工作队列，唤醒时调用flush_to_ldisc ，读函数时我们需要分析它。

2.3 初始化 tty_struct 里的两个等待队列头。

2.4 设置 tty_struct->ops == tty_driver->ops 。

3、在 tty_ldisc_setup 函数中调用到线路规程的open函数，对于 N_TTY 来说是 n_tty_open 。

4、如果 tty_struct->ops 也就是 tty_driver->ops 定义了 open 函数则调用，显然是有的 uart_open 。

对于 n_tty_open ，它应该是对线路规程如何“格式化数据”进行设置，太复杂了，忽略掉吧，跟我们没多大关系。对于 uart_open 还是有必要贴下代码。

1static int uart_open(struct tty_struct *tty, struct file *filp)
2{
3  struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state;
4  struct uart_state *state;
5  struct tty_port *port;
6  int retval, line = tty->index;
7 
8  state = uart_get(drv, line);
9  port = &state->port;  
10  tty->driver_data = state;  
11  state->uart_port->state = state;
12  
13  /* uport->ops->startup(uport) 调用到最底层的ops里的startup 函数*/
14  retval = uart_startup(state, 0);
15 
16}

根据 tty_struct 获取到 uart_driver ，再由 uart_driver 获取到里面的uart_state->uart_port->ops->startup 并调用它。至此，open函数分析完毕，它不是简单的 “打开”，还有大量的初始化工作，最终调用到最底层的 startup 函数。

3.2 tty_write

1static ssize_t tty_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
2{
3  struct tty_struct *tty;
4  struct inode *inode = file->f_path.dentry->d_inode;
5  ssize_t ret;
6  struct tty_ldisc *ld;
7 
8  tty = (struct tty_struct *)file->private_data;
9 
10  ld = tty_ldisc_ref_wait(tty);
11  if (!ld->ops->write)
12    ret = -EIO;
13  else
14    /* 调用 线路规程 n_tty_write 函数 */
15    ret = do_tty_write(ld->ops->write, tty, file, buf, count);
16  tty_ldisc_deref(ld);
17  return ret;
18}
19static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
20         const unsigned char *buf, size_t nr)
21{
22  const unsigned char *b = buf;
23  DECLARE_WAITQUEUE(wait, current);
24  int c;
25  ssize_t retval = 0;
26  // 将当前进程添加到等待队列
27  add_wait_queue(&tty->write_wait, &wait);
28  while (1) {
29    // 设置当前进程为可中断的
30    set_current_state(TASK_INTERRUPTIBLE);
31    if (signal_pending(current)) {
32      retval = -ERESTARTSYS;
33      break;
34    }
35    if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
36      retval = -EIO;
37      break;
38    }
39    /* 自行定义了输出方式 */
40    if (O_OPOST(tty) && !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
41      ....
42    } else {
43      while (nr > 0) {
44        /* 调用到 uart_write */
45        c = tty->ops->write(tty, b, nr);
46        if (c < 0) {
47          retval = c;
48          goto break_out;
49        }
50        if (!c)
51          break;
52        b += c;
53        nr -= c;
54      }
55    }
56    if (!nr)
57      break;
58    if (file->f_flags & O_NONBLOCK) {
59      retval = -EAGAIN;
60      break;
61    }
62    // 进程调度 开始休眠
63    schedule();
64  }
65}

n_tty_write 调用 tty->ops->write 也就是 uart_write。

1static int uart_write(struct tty_struct *tty, const unsigned char *buf, int count)
2{
3  uart_start(tty);
4  return ret;
5}
6 
7static void uart_start(struct tty_struct *tty)
8{
9  __uart_start(tty);  
10}
11 
12static void __uart_start(struct tty_struct *tty)
13{
14  struct uart_state *state = tty->driver_data;
15  struct uart_port *port = state->uart_port;
16 
17  if (!uart_circ_empty(&state->xmit) && state->xmit.buf &&
18      !tty->stopped && !tty->hw_stopped)
19    /* 调用到最底层的 start_tx */
20    port->ops->start_tx(port);
21}

uart_write 又调用到了最底层的 uart_port->ops->start_tx 函数。猜测一下，大概“写”的思路：

1、将当前进程加入到等待队列

2、设置当前进程为可打断的

3、层层调用最终调用到底层的 start_tx 函数，将要发送的数据存入 DATA 寄存器，由硬件自动发送。

4、进程调度，当前进程进入休眠。

5、硬件发送完成，进入中断处理函数，唤醒对面队列。

当然这只是我自己的猜测，到底是不是这样，具体分析底层操作函数的时候应该会明白。

3.3 tty_read

1static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
2      loff_t *ppos)
3{
4  int i;
5  struct tty_struct *tty;
6  struct inode *inode;
7  struct tty_ldisc *ld;
8 
9  tty = (struct tty_struct *)file->private_data;
10  inode = file->f_path.dentry->d_inode;
11 
12  
13  ld = tty_ldisc_ref_wait(tty);
14  /* 调用线路规程 n_tty_read */
15  if (ld->ops->read)
16    i = (ld->ops->read)(tty, file, buf, count);
17  else
18    i = -EIO;
19  tty_ldisc_deref(ld);
20  if (i > 0)
21    inode->i_atime = current_fs_time(inode->i_sb);
22  return i;
23}

调用线路规程的 read 函数，对于 N_TTY 来说是 n_tty_read (删掉了一堆看不懂的代码，还是有很多)

1static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
2       unsigned char __user *buf, size_t nr)
3{
4  unsigned char __user *b = buf;
5  DECLARE_WAITQUEUE(wait, current);
6  int c;
7  int minimum, time;
8  ssize_t retval = 0;
9  ssize_t size;
10  long timeout;
11  unsigned long flags;
12  int packet;
13 
14do_it_again:
15 
16  BUG_ON(!tty->read_buf);
17 
18  c = job_control(tty, file);
19 
20  minimum = time = 0;
21  timeout = MAX_SCHEDULE_TIMEOUT;
22  /* 如果是非标准模式 */
23  if (!tty->icanon) {
24    ...
25  }
26 
27  packet = tty->packet;
28 
29  add_wait_queue(&tty->read_wait, &wait);
30  while (nr) {
31    /* First test for status change. */
32    if (packet && tty->link->ctrl_status) {
33      /* 看不懂的都删掉 */
34    }
35    /* This statement must be first before checking for input
36       so that any interrupt will set the state back to
37       TASK_RUNNING. */
38    set_current_state(TASK_INTERRUPTIBLE);
39 
40    if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
41        ((minimum - (b - buf)) >= 1))
42      tty->minimum_to_wake = (minimum - (b - buf));
43 
44    if (!input_available_p(tty, 0)) {
45      /* 看不懂的都删掉 */
46      
47      /* FIXME: does n_tty_set_room need locking ? */
48      n_tty_set_room(tty);
49      /* 进程调度 休眠 */
50      timeout = schedule_timeout(timeout);
51      continue;
52    }
53    __set_current_state(TASK_RUNNING);
54 
55    /* Deal with packet mode. */
56    if (packet && b == buf) {
57      /* 看不懂的都删掉 */
58    }
59    
60    /* 如果是标准模式 */
61    if (tty->icanon) {
62      /* N.B. avoid overrun if nr == 0 */
63      while (nr && tty->read_cnt) {
64        int eol;
65 
66        eol = test_and_clear_bit(tty->read_tail,
67            tty->read_flags);
68        
69        /* 从tty->read_buf 获取数据 */
70        c = tty->read_buf[tty->read_tail];
71        spin_lock_irqsave(&tty->read_lock, flags);
72        tty->read_tail = ((tty->read_tail+1) &
73              (N_TTY_BUF_SIZE-1));
74        tty->read_cnt--;
75        if (eol) {
76          /* this test should be redundant:
77           * we shouldn't be reading data if
78           * canon_data is 0
79           */
80          if (--tty->canon_data < 0)
81            tty->canon_data = 0;
82        }
83        spin_unlock_irqrestore(&tty->read_lock, flags);
84 
85        if (!eol || (c != __DISABLED_CHAR)) {
86          /* 将数据拷贝到用户空间 */
87          if (tty_put_user(tty, c, b++)) {
88            retval = -EFAULT;
89            b--;
90            break;
91          }
92          nr--;
93        }
94        if (eol) {
95          tty_audit_push(tty);
96          break;
97        }
98      }
99      if (retval)
100        break;
101    } else {
102      /* 非标准模式不关心删掉 */
103    }
104    ....
105  }
106  mutex_unlock(&tty->atomic_read_lock);
107  remove_wait_queue(&tty->read_wait, &wait);
108 
109  if (!waitqueue_active(&tty->read_wait))
110    tty->minimum_to_wake = minimum;
111 
112  __set_current_state(TASK_RUNNING);
113  ...
114  n_tty_set_room(tty);
115  return retval;
116}

“读”过程干了哪些事： 1、将当前进程加入等待队列

2、设置当前进程可中断

3、进程调度，当前进程进入休眠

4、在某处被唤醒

5、从 tty->read_buf 取出数据，通过 tty_put_user 拷贝到用户空间。

那么，在何处唤醒，猜测应该是在中断处理函数中，当DATA寄存器满，触发中断，中断处理函数中调用 tty_flip_buffer_push 。

1void tty_flip_buffer_push(struct tty_struct *tty)
2{
3  unsigned long flags;
4  spin_lock_irqsave(&tty->buf.lock, flags);
5  if (tty->buf.tail != NULL)
6    tty->buf.tail->commit = tty->buf.tail->used;
7  spin_unlock_irqrestore(&tty->buf.lock, flags);
8 
9  if (tty->low_latency)
10    flush_to_ldisc(&tty->buf.work.work);
11  else
12    schedule_delayed_work(&tty->buf.work, 1);
13}

tty_flip_buffer_push 有两种方式调用到 flush_to_ldisc ，一种直接调用，另一种使用延时工作队列，在很久很久以前，我们初始化了这么一个工作队列~（tty_open 初始化 tty_struct 时前面有提到）。

在flush_to_ldisc 会调用到 disc->ops->receive_buf ，对于 N_TTY 来说是 n_tty_receive_buf ，在 n_tty_receive_buf 中，将数据拷贝到 tty->read_buf ,然后 wake_up_interruptible(&tty->read_wait) 唤醒休眠队列。

然后就是前面提到的，在n_tty_read 函数中从 tty->read_buf 里取出数据拷贝到用户空间了。

至此，关于 uart 的框架分析基本就结束了, 对于 tty 以及线路规程是什么东西，大概了解是个什么东西。虽然大部分东西都不需要我们自己实现，但是了解它们有益无害。

下一篇文章--以 s3c2440 为例，分析底层的操作函数，以及 s3c2440 是如何初始化 uart_port 结构的，，这些是在移植驱动过程中需要做的工作~

                                                                  --END--

关注公众号百问科技(ID：baiwenkeji）第一时间学习嵌入式干货。

技术交流加个人威信13266630429，验证: 博客园

tty初探 — uart驱动框架分析

评论区

相关推荐