Chinaunix首页 | 论坛 | 博客
  • 博客访问: 2139947
  • 博文数量: 391
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 4156
  • 用 户 组: 普通用户
  • 注册时间: 2016-07-04 13:04
文章分类

全部博文(391)

文章存档

2020年(6)

2019年(24)

2018年(135)

2017年(158)

2016年(68)

我的朋友

分类: 嵌入式

2018-08-14 15:14:13

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

主要参考:

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

  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. ret = uart_register_driver(&s3c24xx_uart_drv);
  14. if (ret < 0) {
  15. printk(KERN_ERR "failed to register UART driver\n");
  16. return -1;
  17. }
  18. return 0;
  19. }
    uart_driver 中,我们只是填充了一些名字、设备号等信息,这些都是不涉及底层硬件访问的,那是怎么回事呢?来看一下完整的 uart_driver 结构或许就明白了。

  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. /* 下面这俩,它们应该被初始化为NULL */
  10. struct uart_state *state; "white-space:pre"> /* 下层,串口驱动层 */
  11. struct tty_driver *tty_driver; /* tty相关 */
  12. };
    在我们上边填充的结构体中,有两个成员未被赋值,对于tty_driver 代表的是上层,它会在 register_uart_driver 中的过程中赋值,而uart_state 则代表下层,uart_state 也会在register_uart_driver 的过程中分配空间,但是它里面真正设置硬件相关的东西是 uart_state->uart_port ,这个uart_port 是需要我们从其它地方调用 uart_add_one_port 来添加的。 

1、下层(串口驱动层)

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

  1. struct 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 空间,用来存放驱动所支持的串口(端口)的物理信息。
  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. unsigned int read_status_mask; /* 关心 Rx error status */
  16. unsigned int ignore_status_mask; /* 忽略 Rx error status */
  17. struct uart_state *state; /* pointer to parent state */
  18. struct uart_icount icount; /* 串口信息计数器 */
  19. struct console *cons; /* struct console, if any */
  20. #if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(SUPPORT_SYSRQ)
  21. unsigned long sysrq; /* sysrq timeout */
  22. #endif
  23. upf_t flags;
  24. unsigned int mctrl; /* 当前的Moden 设置 */
  25. unsigned int timeout; /* character-based timeout */
  26. unsigned int type; /* 端口类型 */
  27. const struct uart_ops *ops; /* 串口端口操作函数 */
  28. unsigned int custom_divisor;
  29. unsigned int line; /* 端口索引 */
  30. resource_size_t mapbase; /* io内存物理基地址 */
  31. struct device *dev; /* 父设备 */
  32. unsigned char hub6; /* this should be in the 8250 driver */
  33. unsigned char suspended;
  34. unsigned char unused[2];
  35. void *private_data; /* generic platform data pointer */
  36. };
    这个结构体,是需要我们自己来填充的,比如我们 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 ,这个也是需要我们自己来实现的,一般芯片厂家都写好了吧?或者只需要稍作修改。

  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. * Return a string describing the type of the port
  22. */
  23. const char *(*type)(struct uart_port *);
  24. /*
  25. * Release IO and memory resources used by the port.
  26. * This includes iounmap if necessary.
  27. */
  28. void (*release_port)(struct uart_port *);
  29. /*
  30. * Request IO and memory resources used by the port.
  31. * This includes iomapping the port if necessary.
  32. */
  33. int (*request_port)(struct uart_port *); /* 申请必要的IO端口/IO内存资源,必要时还可以重新映射串口端口 */
  34. void (*config_port)(struct uart_port *, int); /* 执行串口所需的自动配置 */
  35. int (*verify_port)(struct uart_port *, struct serial_struct *); /* 核实新串口的信息 */
  36. int (*ioctl)(struct uart_port *, unsigned int, unsigned long);
  37. #ifdef CONFIG_CONSOLE_POLL
  38. void (*poll_put_char)(struct uart_port *, unsigned char);
  39. int (*poll_get_char)(struct uart_port *);
  40. #endif
  41. };
    实在是太复杂了。。。但这一层就跟裸机程序一样,用来操作硬件寄存器,只不过内核把“格式”给我们规定死了。

2、上层(tty 核心层)

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

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

    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 ,而且这一部分都是内核实现好的,我们不需要修改,了解一下工作原理即可。

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

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

  1. static int tty_open(struct inode *inode, struct file *filp)
  2. {
  3. int ret;
  4. lock_kernel();
  5. ret = __tty_open(inode, filp);
  6. unlock_kernel();
  7. return ret;
  8. }
    为了方便分析,我把看不懂的代码都删掉了- -!!!

  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. tty = tty_init_dev(driver, index, 0); // tty->ops = driver->ops;
  13. filp->private_data = tty;
  14. if (tty->ops->open)
  15. /* 调用tty_driver->tty_foperation->open */
  16. retval = tty->ops->open(tty, filp);
  17. return 0;
  18. }
    从 tty_drivers 全局链表获取到前边我们注册进去的 tty_driver ,然后分配设置一个 struct tty_struct 的东西,最后调用 tty_struct->ops->open 函数,其实 tty_struct->ops == tty_driver->ops

  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. /* 初始化 tty ,设置线路规程 Ops 等 */
  8. initialize_tty_struct(tty, driver, idx);
  9. //tty_ldisc_open(tty, ld)-> return ld->ops->open(tty) -> n_tty_open
  10. retval = tty_ldisc_setup(tty, tty->link);
  11. return tty;
  12. }
  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. /* 设置线路规程为 N_TTY */
  6. tty_ldisc_init(tty);//struct tty_ldisc *ld = tty_ldisc_get(N_TTY);tty_ldisc_assign(tty, ld);
  7. ...
  8. tty_buffer_init(tty);
  9. tty->driver = driver;
  10. /* 初始化等待队列头 */
  11. init_waitqueue_head(&tty->write_wait);
  12. init_waitqueue_head(&tty->read_wait);
  13. /* 将driver->ops 拷贝到 tty->ops */
  14. tty->ops = driver->ops;
  15. tty->index = idx;
  16. }

  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. INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);
  10. }
整个 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 还是有必要贴代码一看的。

  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. state = uart_get(drv, line);
  8. port = &state->port;
  9. tty->driver_data = state;
  10. state->uart_port->state = state;
  11. /* uport->ops->startup(uport) 调用到最底层的ops里的startup 函数*/
  12. retval = uart_startup(state, 0);
  13. }
    根据 tty_struct 获取到 uart_driver ,再由 uart_driver 获取到里面 uart_state->uart_port->ops->startup 调用它。至此,open函数分析完毕,它不是简单的 “打开”,还有大量的初始化工作,最终调用到最底层的 startup 函数。


  3.2 tty_write

  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. tty = (struct tty_struct *)file->private_data;
  8. ld = tty_ldisc_ref_wait(tty);
  9. if (!ld->ops->write)
  10. ret = -EIO;
  11. else
  12. /* 调用 线路规程 n_tty_write 函数 */
  13. ret = do_tty_write(ld->ops->write, tty, file, buf, count);
  14. tty_ldisc_deref(ld);
  15. return ret;
  16. }
  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 .

  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. static void uart_start(struct tty_struct *tty)
  7. {
  8. __uart_start(tty);
  9. }
  10. static void __uart_start(struct tty_struct *tty)
  11. {
  12. struct uart_state *state = tty->driver_data;
  13. struct uart_port *port = state->uart_port;
  14. if (!uart_circ_empty(&state->xmit) && state->xmit.buf &&
  15. !tty->stopped && !tty->hw_stopped)
  16. /* 调用到最底层的 start_tx */
  17. port->ops->start_tx(port);
  18. }
    uart_write 又调用到了最底层的 uart_port->ops->start_tx 函数。

猜测一下,大概“写”的思路:

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

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

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

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

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

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


  3.2 tty_read

  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. tty = (struct tty_struct *)file->private_data;
  9. inode = file->f_path.dentry->d_inode;
  10. /* We want to wait for the line discipline to sort out in this
  11. situation */
  12. ld = tty_ldisc_ref_wait(tty);
  13. /* 调用线路规程 n_tty_read */
  14. if (ld->ops->read)
  15. i = (ld->ops->read)(tty, file, buf, count);
  16. else
  17. i = -EIO;
  18. tty_ldisc_deref(ld);
  19. if (i > 0)
  20. inode->i_atime = current_fs_time(inode->i_sb);
  21. return i;
  22. }
    调用线路规程的 read 函数,对于 N_TTY 来说是 n_tty_read ,删掉了一堆看不懂的代码,还是有很多
  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. do_it_again:
  14. BUG_ON(!tty->read_buf);
  15. c = job_control(tty, file);
  16. minimum = time = 0;
  17. timeout = MAX_SCHEDULE_TIMEOUT;
  18. /* 如果是非标准模式 */
  19. if (!tty->icanon) {
  20. ...
  21. }
  22. packet = tty->packet;
  23. add_wait_queue(&tty->read_wait, &wait);
  24. while (nr) {
  25. /* First test for status change. */
  26. if (packet && tty->link->ctrl_status) {
  27. /* 看不懂的都删掉 */
  28. }
  29. /* This statement must be first before checking for input
  30. so that any interrupt will set the state back to
  31. TASK_RUNNING. */
  32. set_current_state(TASK_INTERRUPTIBLE);
  33. if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
  34. ((minimum - (b - buf)) >= 1))
  35. tty->minimum_to_wake = (minimum - (b - buf));
  36. if (!input_available_p(tty, 0)) {
  37. /* 看不懂的都删掉 */
  38. /* FIXME: does n_tty_set_room need locking ? */
  39. n_tty_set_room(tty);
  40. /* 进程调度 休眠 */
  41. timeout = schedule_timeout(timeout);
  42. continue;
  43. }
  44. __set_current_state(TASK_RUNNING);
  45. /* Deal with packet mode. */
  46. if (packet && b == buf) {
  47. /* 看不懂的都删掉 */
  48. }
  49. /* 如果是标准模式 */
  50. if (tty->icanon) {
  51. /* N.B. avoid overrun if nr == 0 */
  52. while (nr && tty->read_cnt) {
  53. int eol;
  54. eol = test_and_clear_bit(tty->read_tail,
  55. tty->read_flags);
  56. /* 从tty->read_buf 获取数据 */
  57. c = tty->read_buf[tty->read_tail];
  58. spin_lock_irqsave(&tty->read_lock, flags);
  59. tty->read_tail = ((tty->read_tail+1) &
  60. (N_TTY_BUF_SIZE-1));
  61. tty->read_cnt--;
  62. if (eol) {
  63. /* this test should be redundant:
  64. * we shouldn't be reading data if
  65. * canon_data is 0
  66. */
  67. if (--tty->canon_data < 0)
  68. tty->canon_data = 0;
  69. }
  70. spin_unlock_irqrestore(&tty->read_lock, flags);
  71. if (!eol || (c != __DISABLED_CHAR)) {
  72. /* 将数据拷贝到用户空间 */
  73. if (tty_put_user(tty, c, b++)) {
  74. retval = -EFAULT;
  75. b--;
  76. break;
  77. }
  78. nr--;
  79. }
  80. if (eol) {
  81. tty_audit_push(tty);
  82. break;
  83. }
  84. }
  85. if (retval)
  86. break;
  87. } else {
  88. /* 非标准模式不关心删掉 */
  89. }
  90. ....
  91. }
  92. mutex_unlock(&tty->atomic_read_lock);
  93. remove_wait_queue(&tty->read_wait, &wait);
  94. if (!waitqueue_active(&tty->read_wait))
  95. tty->minimum_to_wake = minimum;
  96. __set_current_state(TASK_RUNNING);
  97. ...
  98. n_tty_set_room(tty);
  99. return retval;
  100. }
“读”过程干了哪些事:

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

    2、设置当前进程可中断

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

    4、在某处被唤醒

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


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

  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. if (tty->low_latency)
  9. flush_to_ldisc(&tty->buf.work.work);
  10. else
  11. schedule_delayed_work(&tty->buf.work, 1);
  12. }
    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 结构的~,这些是在移植驱动过程中需要做的工作~

阅读(985) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~