tty初探-uart驱动框架分析

最新推荐文章于 2024-04-05 22:01:54 发布
最新推荐文章于 2024-04-05 22:01:54 发布
阅读量412 收藏 1
点赞数
分类专栏： Linux内核与驱动 文章标签： Linux 嵌入式 串口 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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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 结构的~，这些是在移植驱动过程中需要做的工作~

Joern-Lee
关注
专栏目录
linux tty驱动源码分析
09-05
对linux tty驱动源码进行简要分析，明确tty工作流程，及tty线路规程作用。
tty初探—uart驱动框架分析
热门推荐
漫不经心
06-28 2万+
本文参考了大量牛人的博客，对大神的分享表示由衷的感谢。 主要参考：     tty驱动分析 ：http://www.wowotech.net/linux_kenrel/183.html      Linux TTY驱动--Uart_driver底层：http://blog.csdn.net/sharecode/article/details/9196591     Linux TTY驱
tty初探 — uart驱动框架分析
韦东山嵌入式专栏
06-12 1519
写在前面： 我们没有讲UART驱动，不过我们认为，只要系统学习了第2期，应该具备分析UART驱动的能力，小编做答疑几年以来，陆陆续续有不少人问到UART驱动怎么写，所以今天就分享一篇深度长文(17000字，阅读时间43分钟)，作者是我们的答疑助手lizuobin，涉及很多数据结构，为了看懂本文，特意打开source insight 跟踪了代码，你也应该这样，如果你的代码不一样，那或许linux版本...
Linux设备模型之tty驱动架构分析(转)
sunboy1002的专栏
02-23 648
一：前言 TTY这个名称源于电传打字节的简称，在Linux系统表示各种终端。终端通常都跟硬件相对应。比如对应于输入设备的键盘鼠标，或输出设备的显示器和串口终端，也有对应于不存在设备的pty驱动。在如此众多的终端模型之中，Linux系统是怎么将它们统一建模的呢? 这就是我们今天要讨论的问题。 二：tty驱动概貌 Tty架构如下所示： 如上图所示,用户空间主要是通过设备文件同tty_cor
uart驱动与tty驱动
xp_super的专栏
09-23 1148
一:前言 接着前面的终端控制台分析,接下来分析serial的驱动.在linux中,serial也对应着终端,通常被称为串口终端. 在shell上,我们看到的/dev/ttyS*就是串口终端所对应的设备节点.在分析具体的serial驱动之前.有必要先 分析uart驱动架构.uart是Universal Asynchronous Receiver and Transmitter的缩写.翻译成中文
Linux设备模型之tty&&uart驱动架构分析
Clack的专栏
01-18 1484
一：前言 Tty(Teletype)这个名称源于电传打字节的简称。在linux表示各种终端，主要有串行端口终端、伪终端、控制终端。终端通常都跟硬件相对应。比如对应于输入设备键盘鼠标。输出设备显示器的控制终端和串口终端.也有对应于不存在设备的pty驱动。在如此众多的终端模型之中，linux是怎么将它们统一建模的呢?这就是我们今天要讨论的问题. 二：tty驱动概貌 Tty架构如下所示：
【linux kernel】linux 的uart驱动框架分析
iriczhao的博客
11-13 1204
本文分析linux的uart框架
Linux tty驱动学习 - UART驱动的write操作流程
sbctsp的博客
01-06 8207
从tty核心层到最后把数据写入到硬件，整个操作流程如下：tty_write() -> do_tty_write() -> n_tty_write() -> uart_write() -> serial8250_start_tx() -> serial_out()。也就是从tty核心层到线路规程，然后到tty驱动层，再到UART驱动层，最后到UART端口的输出寄存器中。 首先看tty核心的写操作t
Linux tty驱动学习 - UART驱动的read操作流程
sbctsp的博客
01-12 7916
在用户空间对tty设备进行读操作，经过系统调用进入到tty核心层执行的第一个函数是tty_read()。在tty_read()函数中，从文件描述符file的私有数据结构中获得tty_struct，然后再从tty_struct中获取线路规程描述符。取得线路规程描述符后，直接调用线路规程的read()函数。 static ssize_t tty_read(struct file *file, cha
Linux tty驱动学习 - UART驱动的open操作
sbctsp的博客
01-02 3814
/dev/ttyS*属于字符设备，所以在用户空间调用open系统调用打开该类设备，进入到tty核心层后调用的第一个函数是tty_fops中的tty_oepn。tty_open的前面三个判断是根据设备主次设备号来判断设备的类型，分别为/dev/tty(5,0)，/dev/tty0(4.0)，/dev/console(5,1)，分别表示当前控制终端，当前虚拟终端，当前控制台终端。而uart设备对应的设
Linux中tty框架与uart框架
01-27
描述了Linux中tty和uart的架构关系
UART子系统(三) UART属于TTY体系之一
da.的博客
04-26 1125
文章目录TTY体系中设备节点的差别1. 傻傻分不清2. 要讲历史了2.1 电传机teletype2.2 计算机需要控制2.2.1 使用teletype2.2.2 teletype被淘汰了2.2.3 个人电脑和虚拟终端3. 在Ubuntu上演示3.1 各类设备节点的差别3.2 /dev/ttyN(N=1,2,3,...)3.3 /dev/tty03.4 /dev/tty3.5 Terminal和Console的差别3.6 /dev/console UART属于TTY体系的一部分，所以介绍一下TTY。 TTY
10.tty驱动程序框架
ashe9657的博客
02-14 142
Tty驱动程序框架 在Linux系统中，终端是一类字符型设备，它包括多种类型，通常使用tty来简称各种类型的终端设备。 1• 串口终端（/dev/ttyS*） 串口终端是使用计算机串口连接的终端设备。Linux把每个串行端口都看作是一个字符设备。这些串行端口所对应的设备名称是/dev/ttySAC0;/dev/ttySAC1…… 2控制台终端（/dev/console...
[uart]3.tty驱动分析
anxuan3201的博客
06-25 131
转自：http://www.wowotech.net/linux_kenrel/183.html 目录： 1首先分析设备驱动的注册 1.1 uart_register_driver分析 1.2tty_register_driver分析 1.3 serial8250_register_ports()函数分析 1.4serial8250_probe()函数分析 2然后，...
Linux内核（一） [ IMX RK ] TTY-UART驱动框架解析
weixin_43564241的博客
01-18 1816
平台：NXP imx6ull 内核版本：4.1.15 文章目录一、Linux TTY驱动框架二、Linux Uart驱动框架三、UART相关结构体uart_driver(UART驱动结构体) 、uart_port（UART端口） 、uart_ops（UART操作函数集）四、设备树配置五、串口驱动分析 一、Linux TTY驱动框架 Linux TTY驱动程序代码位于/drivers/tty下面。TTY整体框架大致分为TTY应用层、TTY文件层、TTY线路规程层、TTY驱动层、TTY设备驱动层。 TTY应
TTY驱动框架
stone322的博客
08-04 146
转自韦东山嵌入式教程。
RK3568平台（UART篇）Uart驱动框架
最新发布
weixin_49303682的博客
04-05 1431
在Linux kernel中，tty驱动不像于spi，iic等那么架构简单，它是一个庞大的系统，它的框架大体如下图一。我们作为普通的驱动开发移植人员，不会从零写tty驱动，一般都是厂家根据现有的tty驱动和自家芯片修改，拿到板子按照厂家的配置，串口应该使能直接使用的。但是开发的过程中也有可能需要用到串口，一般会修改serial驱动，这样我们不会动tty_core层。
Linux的TTY驱动分析
ahskx的博客
02-01 993
本文针对的内核为友善提供的linux-3.0.31版本，从linux驱动模型的角度分析了uart驱动。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值