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 *, intint);  
  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 结构的~,这些是在移植驱动过程中需要做的工作~

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值