tty初探-uart驱动框架分析

本文参考了大量牛人的博客，对大神的分享表示由衷的感谢。

主要参考：

    tty驱动分析 ：http://www.wowotech.net/linux_kenrel/183.html 

    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 注册到内核中去。

[cpp]  view plain  copy

 print ?

1. static 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. };  
10. static 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 结构或许就明白了。

[cpp]  view plain  copy

 print ?

1. struct 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 代表的是上层，它会在 register_uart_driver 中的过程中赋值，而uart_state 则代表下层，uart_state 也会在register_uart_driver 的过程中分配空间，但是它里面真正设置硬件相关的东西是 uart_state->uart_port ，这个uart_port 是需要我们从其它地方调用 uart_add_one_port 来添加的。 

1、下层（串口驱动层）

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

[cpp]  view plain  copy

 print ?

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

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

[cpp]  view plain  copy

 print ?

1. struct 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 ，这个也是需要我们自己来实现的，一般芯片厂家都写好了吧？或者只需要稍作修改。

[cpp]  view plain  copy

 print ?

1. struct 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 层要从 register_uart_driver 来看起了，因为 tty_driver 是在注册过程中构建的，我们也就顺便了解了注册过程~。

[cpp]  view plain  copy

 print ?

1. int 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 。

    注册 uart_driver 实际上是注册 tty_driver，因此与用户空间打交道的工作完全交给了 tty_driver ，而且这一部分都是内核实现好的，我们不需要修改，了解一下工作原理即可。

[cpp]  view plain  copy

 print ?

1. static 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 的注册。

[cpp]  view plain  copy

 print ?

1. int 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

[cpp]  view plain  copy

 print ?

1. static 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. }  

    为了方便分析，我把看不懂的代码都删掉了- -！！！

[cpp]  view plain  copy

 print ?

1. static int __tty_open(struct inode *inode, struct file *filp)  
2. {  
3.     struct tty_struct *tty = NULL;  
4.     int noctty, retval;  
5.     struct tty_driver *driver;  
6.     int index;  
7.     dev_t device = inode->i_rdev;  
8.     unsigned saved_flags = filp->f_flags;  
9.     ...   
10.     //在全局tty_drivers链表中获取Core注册的tty_driver  
11.     driver = get_tty_driver(device, &index);  
12.       
13.     tty = tty_init_dev(driver, index, 0);   // tty->ops = driver->ops;  
14.   
15.     filp->private_data = tty;  
16.   
17.     if (tty->ops->open)  
18.         /* 调用tty_driver->tty_foperation->open */  
19.         retval = tty->ops->open(tty, filp);  
20.       
21.     return 0;  
22. }  

    从 tty_drivers 全局链表获取到前边我们注册进去的 tty_driver ，然后分配设置一个 struct tty_struct 的东西，最后调用 tty_struct->ops->open 函数，其实 tty_struct->ops == tty_driver->ops 。

[cpp]  view plain  copy

 print ?

1. struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx, int first_ok)  
2. {  
3.     struct tty_struct *tty;  
4.     int retval;  
5.     /* 分配一个 tty_struct */  
6.     tty = alloc_tty_struct();  
7.       
8.     /* 初始化 tty ，设置线路规程 Ops 等 */  
9.     initialize_tty_struct(tty, driver, idx);  
10.       
11.     //tty_ldisc_open(tty, ld)-> return ld->ops->open(tty) -> n_tty_open  
12.     retval = tty_ldisc_setup(tty, tty->link);      
13.       
14.     return tty;  
15. }  

[cpp]  view plain  copy

 print ?

1. void initialize_tty_struct(struct tty_struct *tty,  
2.         struct tty_driver *driver, int idx)  
3. {  
4.     memset(tty, 0, sizeof(struct tty_struct));  
5.   
6.     /* 设置线路规程为 N_TTY */  
7.     tty_ldisc_init(tty);//struct tty_ldisc *ld = tty_ldisc_get(N_TTY);tty_ldisc_assign(tty, ld);  
8.   
9.     ...  
10.     tty_buffer_init(tty);  
11.     tty->driver = driver;  
12.       
13.     /* 初始化等待队列头 */  
14.     init_waitqueue_head(&tty->write_wait);  
15.     init_waitqueue_head(&tty->read_wait);  
16.       
17.     /* 将driver->ops 拷贝到 tty->ops  */  
18.     tty->ops = driver->ops;  
19.     tty->index = idx;  
20. }  

[cpp]  view plain  copy

 print ?

1. void tty_buffer_init(struct tty_struct *tty)  
2. {  
3.     spin_lock_init(&tty->buf.lock);  
4.     tty->buf.head = NULL;  
5.     tty->buf.tail = NULL;  
6.     tty->buf.free = NULL;  
7.     tty->buf.memory_used = 0;  
8.       
9.     /* 初始化延时工作队列 */  
10.     INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);  
11. }  

整个 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 还是有必要贴代码一看的。

[cpp]  view plain  copy

 print ?

1. static 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

[cpp]  view plain  copy

 print ?

1. static 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. }  

[cpp]  view plain  copy

 print ?

1. static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,  
2.                const unsigned char *buf, size_t nr)  
3. {  
4.     const unsigned char *b = buf;  
5.     DECLARE_WAITQUEUE(wait, current);  
6.     int c;  
7.     ssize_t retval = 0;  
8.     // 将当前进程添加到等待队列  
9.     add_wait_queue(&tty->write_wait, &wait);  
10.     while (1) {  
11.         // 设置当前进程为可中断的  
12.         set_current_state(TASK_INTERRUPTIBLE);  
13.         if (signal_pending(current)) {  
14.             retval = -ERESTARTSYS;  
15.             break;  
16.         }  
17.         if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {  
18.             retval = -EIO;  
19.             break;  
20.         }  
21.         /* 自行定义了输出方式 */  
22.         if (O_OPOST(tty) && !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {  
23.             ....  
24.         } else {  
25.             while (nr > 0) {  
26.                 /* 调用到 uart_write */  
27.                 c = tty->ops->write(tty, b, nr);  
28.                 if (c < 0) {  
29.                     retval = c;  
30.                     goto break_out;  
31.                 }  
32.                 if (!c)  
33.                     break;  
34.                 b += c;  
35.                 nr -= c;  
36.             }  
37.         }  
38.         if (!nr)  
39.             break;  
40.         if (file->f_flags & O_NONBLOCK) {  
41.             retval = -EAGAIN;  
42.             break;  
43.         }  
44.         // 进程调度 开始休眠  
45.         schedule();  
46.     }  
47. }  

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

[cpp]  view plain  copy

 print ?

1. static int uart_write(struct tty_struct *tty, const unsigned char *buf, int count)  
2. {  
3.     uart_start(tty);  
4.     return ret;  
5. }  
6.   
7. static void uart_start(struct tty_struct *tty)  
8. {  
9.     __uart_start(tty);    
10. }  
11.   
12. static 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.2 tty_read

[cpp]  view plain  copy

 print ?

1. static 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.     /* We want to wait for the line discipline to sort out in this 
13.        situation */  
14.     ld = tty_ldisc_ref_wait(tty);  
15.     /* 调用线路规程 n_tty_read */  
16.     if (ld->ops->read)  
17.         i = (ld->ops->read)(tty, file, buf, count);  
18.     else  
19.         i = -EIO;  
20.     tty_ldisc_deref(ld);  
21.     if (i > 0)  
22.         inode->i_atime = current_fs_time(inode->i_sb);  
23.     return i;  
24. }  

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

[cpp]  view plain  copy

 print ?

1. static 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.   
14. do_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 。

[cpp]  view plain  copy

 print ?

1. void 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 结构的~，这些是在移植驱动过程中需要做的工作~