usb serial port 驅動_tty初探 — uart驅動框架分析

寫在前面：

我們沒有講UART驅動，不過我們認為，只要系統學習了第2期，應該具備分析UART驅動的能力，小編做答疑幾年以來，陸陸續續有不少人問到UART驅動怎么寫，所以今天就分享一篇深度長文(17000字，閱讀時間43分鐘)，作者是我們的答疑助手lizuobin，涉及很多數據結構，為了看懂本文，特意打開source insight 跟蹤了代碼，你也應該這樣，如果你的代碼不一樣，那或許linux版本不一樣。

作者：lizuobin

原文(有些許修正)：

https://blog.csdn.net/lizuobin2/article/details/51773305

本文參考了大量牛人的博客，對大神的分享表示由衷的感謝。

主要參考：

Linux TTY驅動--Uart_driver底層：

http://blog.csdn.net/sharecode/article/details/9196591

Linux TTY驅動--Serial Core層：

http://blog.csdn.net/sharecode/article/details/9197567

前面學習過了 i2c、spi，這倆都是基于設備總線驅動模型，分析起來相對比較簡單，今天打算迎難而上學習一下 Uart 驅動，因為它涉及了tty 、線路規程，確實有些難度，幸好有萬能的互聯網讓我可以學習大神們的博客。一天下來總算有些收獲，下面總結一下（主要是框架）。

整個uart 框架大概如上圖所示，簡單來分的話可以說成兩層，一層是下層我們的串口驅動層，它直接與硬件接觸，我們需要填充一個 struct uart_ops 的結構體，另一層是上層 tty 層，包括 tty 核心以及線路規程，它們各自都有一個 Ops 結構，用戶空間通過 tty 注冊的字符設備節點來訪問，這么說來如上圖所示涉及到了4個 ops 結構了，層層跳轉。下面，就來分析分析它們的層次結構。

在 s3c2440平臺，它是這樣來注冊串口驅動的：分配一個struct uart_driver 簡單填充，并調用uart_register_driver 注冊到內核中去。

static struct uart_driver s3c24xx_uart_drv = {.owner = THIS_MODULE,.dev_name = "s3c2410_serial",.nr = CONFIG_SERIAL_SAMSUNG_UARTS,.cons = S3C24XX_SERIAL_CONSOLE,.driver_name = S3C24XX_SERIAL_NAME,.major = S3C24XX_SERIAL_MAJOR,.minor = S3C24XX_SERIAL_MINOR,
};
static int __init s3c24xx_serial_modinit(void)
{int ret;ret = uart_register_driver(&s3c24xx_uart_drv);if (ret < 0) {printk(KERN_ERR "failed to register UART drivern");return -1;}return 0;
}

uart_driver 中，我們只是填充了一些名字、設備號等信息，這些都是不涉及底層硬件訪問的，到底怎么回事呢？來看一下完整的 uart_driver 結構或許就明白了。

struct uart_driver {struct module *owner; /* 擁有該uart_driver的模塊,一般為THIS_MODULE */const char *driver_name; /* 串口驅動名，串口設備文件名以驅動名為基礎 */const char *dev_name; /* 串口設備名 */int major; /* 主設備號 */int minor; /* 次設備號 */int nr; /* 該uart_driver支持的串口個數(最大) */struct console *cons; /* 其對應的console.若該uart_driver支持serial console,否則為NULL *//* 下面這倆，它們應該被初始化為NULL */struct uart_state *state; <span style="white-space:pre"> </span>/* 下層，串口驅動層 */struct tty_driver *tty_driver; /* tty相關 */
};

在我們上邊填充的結構體中，有兩個成員未被賦值，對于tty_driver 代表的是上層，它會在 uart_register_driver中的過程中賦值，而uart_state 則代表下層，uart_state 也會在uart_register_driver的過程中分配空間，但是它里面真正設置硬件相關的東西是 uart_state->uart_port ，這個uart_port 是需要我們從其它地方調用 uart_add_one_port 來添加的。

1、下層（串口驅動層）

首先，我們需要認識這幾個結構體

struct uart_state {struct tty_port port;int pm_state;struct circ_buf xmit;struct tasklet_struct tlet;struct uart_port *uart_port; // 對應于一個串口設備
};

在注冊 driver 時，會根據 uart_driver->nr 來申請 nr 個 uart_state 空間，用來存放驅動所支持的串口（端口）的物理信息。

 struct uart_port {spinlock_t lock; /* port lock */unsigned long iobase; /* io端口基地址（物理） */unsigned char __iomem *membase; /* io內存基地址（虛擬） */unsigned int (*serial_in)(struct uart_port *, int);void (*serial_out)(struct uart_port *, int, int);unsigned int irq; /* 中斷號 */unsigned long irqflags; /* 中斷標志 */unsigned int uartclk; /* 串口時鐘 */unsigned int fifosize; /* 串口緩沖區大小 */unsigned char x_char; /* xon/xoff char */unsigned char regshift; /* 寄存器位移 */unsigned char iotype; /* IO訪問方式 */unsigned char unused1;unsigned int read_status_mask; /* 關心 Rx error status */unsigned int ignore_status_mask; /* 忽略 Rx error status */struct uart_state *state; /* pointer to parent state */struct uart_icount icount; /* 串口信息計數器 */struct console *cons; /* struct console, if any */
#if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(SUPPORT_SYSRQ)unsigned long sysrq; /* sysrq timeout */
#endifupf_t flags;unsigned int mctrl; /* 當前的Moden 設置 */unsigned int timeout; /* character-based timeout */unsigned int type; /* 端口類型 */const struct uart_ops *ops; /* 串口端口操作函數 */unsigned int custom_divisor;unsigned int line; /* 端口索引 */resource_size_t mapbase; /* io內存物理基地址 */struct device *dev; /* 父設備 */unsigned char hub6; /* this should be in the 8250 driver */unsigned char suspended;unsigned char unused[2];void *private_data; /* generic platform data pointer */
};

這個結構體，是需要我們自己來填充的，比如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 ，這個也是需要我們自己來實現的，一般芯片廠家都寫好了或者只需要稍作修改。

 struct uart_ops {unsigned int (*tx_empty)(struct uart_port *); /* 串口的Tx FIFO緩存是否為空 */void (*set_mctrl)(struct uart_port *, unsigned int mctrl); /* 設置串口modem控制 */unsigned int (*get_mctrl)(struct uart_port *); /* 獲取串口modem控制 */void (*stop_tx)(struct uart_port *); /* 禁止串口發送數據 */void (*start_tx)(struct uart_port *); /* 使能串口發送數據 */ void (*send_xchar)(struct uart_port *, char ch); /* 發送xChar */void (*stop_rx)(struct uart_port *); /* 禁止串口接收數據 */void (*enable_ms)(struct uart_port *); /* 使能modem的狀態信號 */void (*break_ctl)(struct uart_port *, int ctl); /* 設置break信號 */int  (*startup)(struct uart_port *); /* 啟動串口,應用程序打開串口設備文件時,該函數會被調用 */void (*shutdown)(struct uart_port *);/* 關閉串口,應用程序關閉串口設備文件時,該函數會被調用 */void (*flush_buffer)(struct uart_port *);void (*set_termios)(struct uart_port *, struct ktermios *new,struct ktermios *old); /* 設置串口參數 */void (*set_ldisc)(struct uart_port *);/* 設置線路規程 */void (*pm)(struct uart_port *, unsigned int state,unsigned int oldstate); /* 串口電源管理 */int (*set_wake)(struct uart_port *, unsigned int state);/** Return a string describing the type of the port*/const char *(*type)(struct uart_port *);/** Release IO and memory resources used by the port.* This includes iounmap if necessary.*/void (*release_port)(struct uart_port *);/** Request IO and memory resources used by the port.* This includes iomapping the port if necessary.*/int (*request_port)(struct uart_port *); /* 申請必要的IO端口/IO內存資源,必要時還可以重新映射串口端口 */void (*config_port)(struct uart_port *, int); /* 執行串口所需的自動配置 */int (*verify_port)(struct uart_port *, struct serial_struct *); /* 核實新串口的信息 */int (*ioctl)(struct uart_port *, unsigned int, unsigned long);
#ifdef CONFIG_CONSOLE_POLLvoid (*poll_put_char)(struct uart_port *, unsigned char);int (*poll_get_char)(struct uart_port *);
#endif
};

實在是太復雜了。但這一層就跟裸機程序一樣，用來操作硬件寄存器，只不過內核把“格式”給我們規定死了。

2、上層（tty 核心層）

tty 層要從 uart_register_driver來看起了，因為tty_driver是在注冊過程中構建的，我們也順便了解注冊過程。

int uart_register_driver(struct uart_driver *drv)
{struct tty_driver *normal = NULL;int i, retval;/* 根據driver支持的最大設備數，申請n個 uart_state 空間，每一個 uart_state 都有一個uart_port */drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);/* tty層：分配一個 tty_driver ，并將drv->tty_driver 指向它 */normal = alloc_tty_driver(drv->nr);drv->tty_driver = normal;/* 對 tty_driver 進行設置 */normal->owner = drv->owner;normal->driver_name = drv->driver_name;normal->name = drv->dev_name;normal->major = drv->major;normal->minor_start = drv->minor;normal->type = TTY_DRIVER_TYPE_SERIAL;normal->subtype = SERIAL_TYPE_NORMAL;normal->init_termios = tty_std_termios;normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;normal->driver_state = drv;tty_set_operations(normal, &uart_ops);/** Initialise the UART state(s).*/for (i = 0; i < drv->nr; i++) {struct uart_state *state = drv->state + i;struct tty_port *port = &state->port; /* driver->state->tty_port */tty_port_init(port);port->close_delay = 500; /* .5 seconds */port->closing_wait = 30000; /* 30 seconds *//* 初始化 tasklet */tasklet_init(&state->tlet, uart_tasklet_action,(unsigned long)state);}/* tty層：注冊 driver->tty_driver */retval = tty_register_driver(normal);}

注冊過程干了哪些事：

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 ，而且這一部分都是內核實現好的，我們不需要修改，了解一下工作原理即可。

 static const struct tty_operations uart_ops = {.open = uart_open,.close = uart_close,.write = uart_write,.put_char = uart_put_char, // 單字節寫函數.flush_chars = uart_flush_chars, // 刷新數據到硬件函數.write_room = uart_write_room, // 指示多少緩沖空閑的函數.chars_in_buffer= uart_chars_in_buffer, // 只是多少緩沖滿的函數.flush_buffer = uart_flush_buffer, // 刷新數據到硬件.ioctl = uart_ioctl,.throttle = uart_throttle,.unthrottle = uart_unthrottle,.send_xchar = uart_send_xchar,.set_termios = uart_set_termios, // 當termios設置被改變時又tty核心調用.set_ldisc = uart_set_ldisc, // 設置線路規程函數.stop = uart_stop, .start = uart_start,.hangup = uart_hangup, // 掛起函數，當驅動掛起tty設備時調用.break_ctl = uart_break_ctl, // 線路中斷控制函數.wait_until_sent= uart_wait_until_sent,
#ifdef CONFIG_PROC_FS.proc_fops = &uart_proc_fops,
#endif.tiocmget = uart_tiocmget, // 獲得當前tty的線路規程的設置.tiocmset = uart_tiocmset, // 設置當前tty線路規程的設置
#ifdef CONFIG_CONSOLE_POLL.poll_init = uart_poll_init,.poll_get_char = uart_poll_get_char,.poll_put_char = uart_poll_put_char,
#endif
};

這個是 tty 核心的 Ops ，簡單看看，等后面分析調用關系時，在來細看，下面來看 tty_driver 的注冊。


int tty_register_driver(struct tty_driver *driver)
{int error;int i;dev_t dev;void **p = NULL;if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);}/* 如果沒有主設備號則申請 */if (!driver->major) {error = alloc_chrdev_region(&dev, driver->minor_start,driver->num, driver->name);} else {dev = MKDEV(driver->major, driver->minor_start);error = register_chrdev_region(dev, driver->num, driver->name);}if (p) { /* 為線路規程和termios分配空間 */driver->ttys = (struct tty_struct **)p;driver->termios = (struct ktermios **)(p + driver->num);} else {driver->ttys = NULL;driver->termios = NULL;}/* 創建字符設備，使用 tty_fops */cdev_init(&driver->cdev, &tty_fops);driver->cdev.owner = driver->owner;error = cdev_add(&driver->cdev, dev, driver->num);mutex_lock(&tty_mutex);/* 將該 driver->tty_drivers 添加到全局鏈表 tty_drivers */list_add(&driver->tty_drivers, &tty_drivers);mutex_unlock(&tty_mutex);if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {for (i = 0; i < driver->num; i++)tty_register_device(driver, i, NULL);}/* proc 文件系統注冊driver */proc_tty_register_driver(driver);driver->flags |= TTY_DRIVER_INSTALLED;return 0;
}

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

static int tty_open(struct inode *inode, struct file *filp)
{int ret;lock_kernel();ret = __tty_open(inode, filp);unlock_kernel();return ret;
}

為了方便分析，我把看不懂的代碼都刪掉了。

 
static int __tty_open(struct inode *inode, struct file *filp)
{struct tty_struct *tty = NULL;int noctty, retval;struct tty_driver *driver;int index;dev_t device = inode->i_rdev;unsigned saved_flags = filp->f_flags; 
//在全局tty_drivers鏈表中獲取Core注冊的tty_driverdriver = get_tty_driver(device, &index);tty = tty_init_dev(driver, index, 0); // tty->ops = driver->ops;filp->private_data = tty;if (tty->ops->open)/* 調用tty_driver->tty_foperation->open */retval = tty->ops->open(tty, filp);return 0;
}

從 tty_drivers 全局鏈表獲取到前邊我們注冊進去的 tty_driver ，然后分配設置一個 struct tty_struct 的東西，最后調用 tty_struct->ops->open 函數，其實 tty_struct->ops == tty_driver->ops 。

struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx, int first_ok)
{struct tty_struct *tty;int retval;/* 分配一個 tty_struct */tty = alloc_tty_struct();/* 初始化 tty ，設置線路規程 Ops 等 */initialize_tty_struct(tty, driver, idx);//tty_ldisc_open(tty, ld)-> return ld->ops->open(tty) -> n_tty_openretval = tty_ldisc_setup(tty, tty->link); return tty;
}void initialize_tty_struct(struct tty_struct *tty,struct tty_driver *driver, int idx)
{memset(tty, 0, sizeof(struct tty_struct));/* 設置線路規程為 N_TTY */tty_ldisc_init(tty);//struct tty_ldisc *ld = tty_ldisc_get(N_TTY);tty_ldisc_assign(tty, ld);...tty_buffer_init(tty);tty->driver = driver;/* 初始化等待隊列頭 */init_waitqueue_head(&tty->write_wait);init_waitqueue_head(&tty->read_wait);/* 將driver->ops 拷貝到 tty->ops */tty->ops = driver->ops;tty->index = idx;
}void tty_buffer_init(struct tty_struct *tty)
{spin_lock_init(&tty->buf.lock);tty->buf.head = NULL;tty->buf.tail = NULL;tty->buf.free = NULL;tty->buf.memory_used = 0;/* 初始化延時工作隊列 */INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);
}
```

整個 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 還是有必要貼下代碼。

static int uart_open(struct tty_struct *tty, struct file *filp)
{struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state;struct uart_state *state;struct tty_port *port;int retval, line = tty->index;state = uart_get(drv, line);port = &state->port; tty->driver_data = state; state->uart_port->state = state;/* uport->ops->startup(uport) 調用到最底層的ops里的startup 函數*/retval = uart_startup(state, 0);}

根據 tty_struct 獲取到 uart_driver ，再由 uart_driver 獲取到里面的uart_state->uart_port->ops->startup 并調用它。至此，open函數分析完畢，它不是簡單的 “打開”，還有大量的初始化工作，最終調用到最底層的 startup 函數。

3.2 tty_write

static ssize_t tty_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{struct tty_struct *tty;struct inode *inode = file->f_path.dentry->d_inode;ssize_t ret;struct tty_ldisc *ld;tty = (struct tty_struct *)file->private_data;ld = tty_ldisc_ref_wait(tty);if (!ld->ops->write)ret = -EIO;else/* 調用 線路規程 n_tty_write 函數 */ret = do_tty_write(ld->ops->write, tty, file, buf, count);tty_ldisc_deref(ld);return ret;
}
static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,const unsigned char *buf, size_t nr)
{const unsigned char *b = buf;DECLARE_WAITQUEUE(wait, current);int c;ssize_t retval = 0;// 將當前進程添加到等待隊列add_wait_queue(&tty->write_wait, &wait);while (1) {// 設置當前進程為可中斷的set_current_state(TASK_INTERRUPTIBLE);if (signal_pending(current)) {retval = -ERESTARTSYS;break;}if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {retval = -EIO;break;}/* 自行定義了輸出方式 */if (O_OPOST(tty) && !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {....} else {while (nr > 0) {/* 調用到 uart_write */c = tty->ops->write(tty, b, nr);if (c < 0) {retval = c;goto break_out;}if (!c)break;b += c;nr -= c;}}if (!nr)break;if (file->f_flags & O_NONBLOCK) {retval = -EAGAIN;break;}// 進程調度 開始休眠schedule();}
}

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

static int uart_write(struct tty_struct *tty, const unsigned char *buf, int count)
{uart_start(tty);return ret;
}static void uart_start(struct tty_struct *tty)
{__uart_start(tty); 
}static void __uart_start(struct tty_struct *tty)
{struct uart_state *state = tty->driver_data;struct uart_port *port = state->uart_port;if (!uart_circ_empty(&state->xmit) && state->xmit.buf &&!tty->stopped && !tty->hw_stopped)/* 調用到最底層的 start_tx */port->ops->start_tx(port);
}

uart_write 又調用到了最底層的 uart_port->ops->start_tx 函數。

猜測一下，大概“寫”的思路：

1、將當前進程加入到等待隊列

2、設置當前進程為可打斷的

3、層層調用最終調用到底層的 start_tx 函數，將要發送的數據存入 DATA 寄存器，由硬件自動發送。

4、進程調度，當前進程進入休眠。

5、硬件發送完成，進入中斷處理函數，喚醒對面隊列。

當然這只是我自己的猜測，到底是不是這樣，具體分析底層操作函數的時候應該會明白。

3.3 tty_read

static ssize_t tty_read(struct file *file, char __user *buf, size_t count,loff_t *ppos)
{int i;struct tty_struct *tty;struct inode *inode;struct tty_ldisc *ld;tty = (struct tty_struct *)file->private_data;inode = file->f_path.dentry->d_inode;ld = tty_ldisc_ref_wait(tty);/* 調用線路規程 n_tty_read */if (ld->ops->read)i = (ld->ops->read)(tty, file, buf, count);elsei = -EIO;tty_ldisc_deref(ld);if (i > 0)inode->i_atime = current_fs_time(inode->i_sb);return i;
}

調用線路規程的 read 函數，對于 N_TTY 來說是 n_tty_read (刪掉了一堆看不懂的代碼，還是有很多)

static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,unsigned char __user *buf, size_t nr)
{unsigned char __user *b = buf;DECLARE_WAITQUEUE(wait, current);int c;int minimum, time;ssize_t retval = 0;ssize_t size;long timeout;unsigned long flags;int packet;do_it_again:BUG_ON(!tty->read_buf);c = job_control(tty, file);minimum = time = 0;timeout = MAX_SCHEDULE_TIMEOUT;/* 如果是非標準模式 */if (!tty->icanon) {...}packet = tty->packet;add_wait_queue(&tty->read_wait, &wait);while (nr) {/* First test for status change. */if (packet && tty->link->ctrl_status) {/* 看不懂的都刪掉 */}/* This statement must be first before checking for inputso that any interrupt will set the state back toTASK_RUNNING. */set_current_state(TASK_INTERRUPTIBLE);if (((minimum - (b - buf)) < tty->minimum_to_wake) &&((minimum - (b - buf)) >= 1))tty->minimum_to_wake = (minimum - (b - buf));if (!input_available_p(tty, 0)) {/* 看不懂的都刪掉 *//* FIXME: does n_tty_set_room need locking ? */n_tty_set_room(tty);/* 進程調度 休眠 */timeout = schedule_timeout(timeout);continue;}__set_current_state(TASK_RUNNING);/* Deal with packet mode. */if (packet && b == buf) {/* 看不懂的都刪掉 */}/* 如果是標準模式 */if (tty->icanon) {/* N.B. avoid overrun if nr == 0 */while (nr && tty->read_cnt) {int eol;eol = test_and_clear_bit(tty->read_tail,tty->read_flags);/* 從tty->read_buf 獲取數據 */c = tty->read_buf[tty->read_tail];spin_lock_irqsave(&tty->read_lock, flags);tty->read_tail = ((tty->read_tail+1) &(N_TTY_BUF_SIZE-1));tty->read_cnt--;if (eol) {/* this test should be redundant:* we shouldn't be reading data if* canon_data is 0*/if (--tty->canon_data < 0)tty->canon_data = 0;}spin_unlock_irqrestore(&tty->read_lock, flags);if (!eol || (c != __DISABLED_CHAR)) {/* 將數據拷貝到用戶空間 */if (tty_put_user(tty, c, b++)) {retval = -EFAULT;b--;break;}nr--;}if (eol) {tty_audit_push(tty);break;}}if (retval)break;} else {/* 非標準模式不關心刪掉 */}....}mutex_unlock(&tty->atomic_read_lock);remove_wait_queue(&tty->read_wait, &wait);if (!waitqueue_active(&tty->read_wait))tty->minimum_to_wake = minimum;__set_current_state(TASK_RUNNING);...n_tty_set_room(tty);return retval;
}

“讀”過程干了哪些事：

1、將當前進程加入等待隊列

2、設置當前進程可中斷

3、進程調度，當前進程進入休眠

4、在某處被喚醒

5、從 tty->read_buf 取出數據，通過 tty_put_user 拷貝到用戶空間。

那么，在何處喚醒，猜測應該是在中斷處理函數中，當DATA寄存器滿，觸發中斷，中斷處理函數中調用 tty_flip_buffer_push 。

void tty_flip_buffer_push(struct tty_struct *tty)
{unsigned long flags;spin_lock_irqsave(&tty->buf.lock, flags);if (tty->buf.tail != NULL)tty->buf.tail->commit = tty->buf.tail->used;spin_unlock_irqrestore(&tty->buf.lock, flags);if (tty->low_latency)flush_to_ldisc(&tty->buf.work.work);elseschedule_delayed_work(&tty->buf.work, 1);
}

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 里取出數據拷貝到用戶空間了。