tty初探—uart驅(qū)動框架分析
來源：程序員人生 發(fā)布時間：2016-07-01 15:45:11 閱讀次數(shù)：6080次
本文參考了大量牛人的博客，對大神的分享表示由衷的感謝。
主要參考：
tty驅(qū)動分析 ：http://www.wowotech.net/linux_kenrel/183.html
Linux TTY驅(qū)動--Uart_driver底層：http://blog.csdn.net/sharecode/article/details/9196591
Linux TTY驅(qū)動--Serial Core層 ：http://blog.csdn.net/sharecode/article/details/9197567
前面學(xué)習(xí)過了 i2c、spi，這倆都是基于裝備總線驅(qū)動模型，分析起來相對照較簡單，今天打算迎難而上學(xué)習(xí)1下 Uart 驅(qū)動程序，由于它觸及到 tty 、線路規(guī)程，確切有些難度，幸虧有萬能的互聯(lián)網(wǎng)讓我可以學(xué)習(xí)大神們的博客。1天下來總算有些收獲，下面總結(jié)1下（主要是框架）。
全部 uart 框架大概的模樣如上圖所示，簡單來分的話可以說成兩層，1層是下層我們的串口驅(qū)動層，它直接與硬件相接觸，我們需要填充1個 struct uart_ops 的結(jié)構(gòu)體，另外一層是上層 tty 層，包括 tty 核心和線路規(guī)程，它們各自都有1個 Ops 結(jié)構(gòu)，用戶空通過間是 tty 注冊的字符裝備節(jié)點來訪問，這么說來如上圖所示觸及到了4個 ops 結(jié)構(gòu)了，層層跳轉(zhuǎn)。下面，就來分析分析它們的層次結(jié)構(gòu)。
在 s3c2440 平臺，它是這樣來注冊串口驅(qū)動的，分配1個struct uart_driver 簡單填充，并調(diào)用uart_register_driver 注冊到內(nèi)核中去。
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 driver\n");
return ⑴;
}
return 0;
}
uart_driver 中，我們只是填充了1些名字、裝備號等信息，這些都是不觸及底層硬件訪問的，那是怎樣回事呢？來看1下完全的 uart_driver 結(jié)構(gòu)也許就明白了。
struct uart_driver {
struct module *owner; /* 具有該uart_driver的模塊,1般為THIS_MODULE */
const char *driver_name; /* 串口驅(qū)動名，串口裝備文件名以驅(qū)動名為基礎(chǔ) */
const char *dev_name; /* 串口裝備名 */
int major; /* 主裝備號 */
int minor; /* 次裝備號 */
int nr; /* 該uart_driver支持的串口個數(shù)(最大) */
struct console *cons; /* 其對應(yīng)的console.若該uart_driver支持serial console,否則為NULL */
/* 下面這倆，它們應(yīng)當(dāng)被初始化為NULL */
struct uart_state *state; <span style="white-space:pre"> </span>/* 下層，串口驅(qū)動層 */
struct tty_driver *tty_driver; /* tty相干 */
};
在我們上邊填充的結(jié)構(gòu)體中，有兩個成員未被賦值，對tty_driver 代表的是上層，它會在 register_uart_driver 中的進程中賦值，而uart_state 則代表下層，uart_state
也會在register_uart_driver 的進程中分配空間，但是它里面真正設(shè)置硬件相干的東西是 uart_state->uart_port ，這個uart_port 是需要我們從其它地方調(diào)用 uart_add_one_port 來添加的。
1、下層（串口驅(qū)動層）
首先，我們需要認識這幾個結(jié)構(gòu)體
struct uart_state {
struct tty_port port;
int pm_state;
struct circ_buf xmit;
struct tasklet_struct tlet;
struct uart_port *uart_port; // 對應(yīng)于1個串口裝備
};
在注冊 driver 時，會根據(jù) uart_driver->nr 來申請 nr 個 uart_state 空間，用來寄存驅(qū)動所支持的串口（端口）的物理信息。
struct uart_port {
spinlock_t lock; /* port lock */
unsigned long iobase; /* io端口基地址（物理） */
unsigned char __iomem *membase; /* io內(nèi)存基地址（虛擬） */
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; /* 串口緩沖區(qū)大小 */
unsigned char x_char; /* xon/xoff char */
unsigned char regshift; /* 寄存器位移 */
unsigned char iotype; /* IO訪問方式 */
unsigned char unused1;
unsigned int read_status_mask; /* 關(guān)心 Rx error status */
unsigned int ignore_status_mask; /* 疏忽 Rx error status */
struct uart_state *state; /* pointer to parent state */
struct uart_icount icount; /* 串口信息計數(shù)器 */
struct console *cons; /* struct console, if any */
#if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(SUPPORT_SYSRQ)
unsigned long sysrq; /* sysrq timeout */
#endif
upf_t flags;
unsigned int mctrl; /* 當(dāng)前的Moden 設(shè)置 */
unsigned int timeout; /* character-based timeout */
unsigned int type; /* 端口類型 */
const struct uart_ops *ops; /* 串口端口操作函數(shù) */
unsigned int custom_divisor;
unsigned int line; /* 端口索引 */
resource_size_t mapbase; /* io內(nèi)存物理基地址 */
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 */
};
這個結(jié)構(gòu)體，是需要我們自己來填充的，比如我們 s3c2440 有3個串口，那末就需要填充3個 uart_port ，并且通過 uart_add_one_port 添加到 uart_driver->uart_state->uart_port 中去。固然 uart_driver 有多個 uart_state ，每一個 uart_state 有1個 uart_port
。在 uart_port 里還有1個非常重要的成員 struct uart_ops *ops ，這個也是需要我們自己來實現(xiàn)的，1般芯片廠家都寫好了吧？或只需要稍作修改。
struct uart_ops {
unsigned int (*tx_empty)(struct uart_port *); /* 串口的Tx FIFO緩存是不是為空 */
void (*set_mctrl)(struct uart_port *, unsigned int mctrl); /* 設(shè)置串口modem控制 */
unsigned int (*get_mctrl)(struct uart_port *); /* 獲得串口modem控制 */
void (*stop_tx)(struct uart_port *); /* 制止串口發(fā)送數(shù)據(jù) */
void (*start_tx)(struct uart_port *); /* 使能串口發(fā)送數(shù)據(jù) */
void (*send_xchar)(struct uart_port *, char ch); /* 發(fā)送xChar */
void (*stop_rx)(struct uart_port *); /* 制止串口接收數(shù)據(jù) */
void (*enable_ms)(struct uart_port *); /* 使能modem的狀態(tài)信號 */
void (*break_ctl)(struct uart_port *, int ctl); /* 設(shè)置break信號 */
int (*startup)(struct uart_port *); /* 啟動串口,利用程序打開串口裝備文件時,該函數(shù)會被調(diào)用 */
void (*shutdown)(struct uart_port *);/* 關(guān)閉串口,利用程序關(guān)閉串口裝備文件時,該函數(shù)會被調(diào)用 */
void (*flush_buffer)(struct uart_port *);
void (*set_termios)(struct uart_port *, struct ktermios *new,
struct ktermios *old); /* 設(shè)置串口參數(shù) */
void (*set_ldisc)(struct uart_port *);/* 設(shè)置線路規(guī)程 */
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內(nèi)存資源,必要時還可以重新映照串口端口 */
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_POLL
void (*poll_put_char)(struct uart_port *, unsigned char);
int (*poll_get_char)(struct uart_port *);
#endif
};
實在是太復(fù)雜了。。。但這1層就跟裸機程序1樣，用來操作硬件寄存器，只不過內(nèi)核把“格式”給我們規(guī)定死了。
2、上層（tty 核心層）
tty 層要從 register_uart_driver 來看起了，由于 tty_driver 是在注冊進程中構(gòu)建的，我們也就順便了解了注冊進程~。
int uart_register_driver(struct uart_driver *drv)
{
struct tty_driver *normal = NULL;
int i, retval;
/* 根據(jù)driver支持的最大裝備數(shù)，申請n個 uart_state 空間，每個 uart_state 都有1個uart_port */
drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
/* tty層：分配1個 tty_driver ，并將drv->tty_driver 指向它 */
normal = alloc_tty_driver(drv->nr);
drv->tty_driver = normal;
/* 對 tty_driver 進行設(shè)置 */
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、根據(jù)driver支持的最大裝備數(shù)，申請n個 uart_state 空間，每個 uart_state 都有1個 uart_port 。
2、分配1個 tty_driver ，并將drv->tty_driver 指向它。
3、對 tty_driver 進行設(shè)置，其中包括默許波特率、校驗方式等，還有1個重要的 Ops ，uart_ops ，它是tty核心與我們串口驅(qū)動通訊的接口。
4、初始化每個 uart_state 的 tasklet 。
5、注冊 tty_driver 。
注冊 uart_driver 實際上是注冊 tty_driver，因此與用戶空間打交道的工作完全交給了 tty_driver ，而且這1部份都是內(nèi)核實現(xiàn)好的，我們不需要修改，了解1下工作原理便可。
static const struct tty_operations uart_ops = {
.open = uart_open,
.close = uart_close,
.write = uart_write,
.put_char = uart_put_char, // 單字節(jié)寫函數(shù)
.flush_chars = uart_flush_chars, // 刷新數(shù)據(jù)到硬件函數(shù)
.write_room = uart_write_room, // 唆使多少緩沖空閑的函數(shù)
.chars_in_buffer= uart_chars_in_buffer, // 只是多少緩沖滿的函數(shù)
.flush_buffer = uart_flush_buffer, // 刷新數(shù)據(jù)到硬件
.ioctl = uart_ioctl,
.throttle = uart_throttle,
.unthrottle = uart_unthrottle,
.send_xchar = uart_send_xchar,
.set_termios = uart_set_termios, // 當(dāng)termios設(shè)置被改變時又tty核心調(diào)用
.set_ldisc = uart_set_ldisc, // 設(shè)置線路規(guī)程函數(shù)
.stop = uart_stop,
.start = uart_start,
.hangup = uart_hangup, // 掛起函數(shù)，當(dāng)驅(qū)動掛起tty裝備時調(diào)用
.break_ctl = uart_break_ctl, // 線路中斷控制函數(shù)
.wait_until_sent= uart_wait_until_sent,
#ifdef CONFIG_PROC_FS
.proc_fops = &uart_proc_fops,
#endif
.tiocmget = uart_tiocmget, // 取得當(dāng)前tty的線路規(guī)程的設(shè)置
.tiocmset = uart_tiocmset, // 設(shè)置當(dāng)前tty線路規(guī)程的設(shè)置
#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 ，簡單1看，后面分析調(diào)用關(guān)系時，我們在來看具體的里邊的函數(shù)，下面來看 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) { /* 為線路規(guī)程和termios分配空間 */
driver->ttys = (struct tty_struct **)p;
driver->termios = (struct ktermios **)(p + driver->num);
} else {
driver->ttys = NULL;
driver->termios = NULL;
}
/* 創(chuàng)建字符裝備，使用 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 文件系統(tǒng)注冊driver */
proc_tty_register_driver(driver);
driver->flags |= TTY_DRIVER_INSTALLED;
return 0;
}
tty_driver 注冊進程干了哪些事：
1、為線路規(guī)程和termios分配空間，并使 tty_driver 相應(yīng)的成員指向它們。
2、注冊字符裝備，名字是 uart_driver->name 我們這里是“ttySAC”,文件操作函數(shù)集是 tty_fops。
3、將該 uart_driver->tty_drivers 添加到全局鏈表 tty_drivers 。
4、向 proc 文件系統(tǒng)添加 driver ，這個暫時不了解。
至此，文章起初的結(jié)構(gòu)圖中的4個ops已出現(xiàn)了3個，另外一個關(guān)于線路規(guī)程的在哪？繼續(xù)看吧。
3、調(diào)用關(guān)系分析
tty_driver 不是注冊了1個字符裝備么，那我們就以它的 tty_fops 入手，以 open、read、write 為例，看看用戶空間是如何訪問到最底層的硬件操作函數(shù)的。
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;
}
為了方便分析，我把看不懂的代碼都刪掉了- -！?。?/span>
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_driver
driver = get_tty_driver(device, &index);
tty = tty_init_dev(driver, index, 0); // tty->ops = driver->ops;
filp->private_data = tty;
if (tty->ops->open)
/* 調(diào)用tty_driver->tty_foperation->open */
retval = tty->ops->open(tty, filp);
return 0;
}
從 tty_drivers 全局鏈表獲得到前邊我們注冊進去的 tty_driver ，然后分配設(shè)置1個 struct tty_struct 的東西，最后調(diào)用 tty_struct->ops->open 函數(shù)，其實 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;
/* 分配1個 tty_struct */
tty = alloc_tty_struct();
/* 初始化 tty ，設(shè)置線路規(guī)程 Ops 等 */
initialize_tty_struct(tty, driver, idx);
//tty_ldisc_open(tty, ld)-> return ld->ops->open(tty) -> n_tty_open
retval = 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));
/* 設(shè)置線路規(guī)程為 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、根據(jù) tty_driver 初始化1個 tty_struct
2.1 設(shè)置 tty_struct 的線路規(guī)程為 N_TTY (不同類型的線路規(guī)程有不同的 ops)
2.2 初始化1個延時工作隊列，喚醒時調(diào)用flush_to_ldisc ，讀函數(shù)時我們需要分析它。
2.3 初始化 tty_struct 里的兩個等待隊列頭。
2.4 設(shè)置 tty_struct->ops == tty_driver->ops 。
3、在 tty_ldisc_setup 函數(shù)中調(diào)用到線路規(guī)程的open函數(shù)，對 N_TTY 來講是 n_tty_open 。
4、如果 tty_struct->ops 也就是 tty_driver->ops 定義了 open 函數(shù)則調(diào)用，明顯是有的 uart_open 。
對 n_tty_open ，它應(yīng)當(dāng)是對線路規(guī)程如何“格式化數(shù)據(jù)”進行設(shè)置，太復(fù)雜了，疏忽掉吧，跟我們沒多大關(guān)系了。對 uart_open 還是有必要貼代碼1看的。
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) 調(diào)用到最底層的ops里的startup 函數(shù)*/
retval = uart_startup(state, 0);
}
根據(jù) tty_struct 獲得到 uart_driver ，再由 uart_driver 獲得到里面 uart_state->uart_port->ops->startup 調(diào)用它。至此，open函數(shù)分析終了，它不是簡單的 “打開”，還有大量的初始化工作，終究調(diào)用到最底層的 startup 函數(shù)。
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
/* 調(diào)用 線路規(guī)程 n_tty_write 函數(shù) */
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;
// 將當(dāng)前進程添加到等待隊列
add_wait_queue(&tty->write_wait, &wait);
while (1) {
// 設(shè)置當(dāng)前進程為可中斷的
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) {
/* 調(diào)用到 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;
}
// 進程調(diào)度 開始休眠
schedule();
}
}
n_tty_write 調(diào)用 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)
/* 調(diào)用到最底層的 start_tx */
port->ops->start_tx(port);
}
uart_write 又調(diào)用到了最底層的 uart_port->ops->start_tx 函數(shù)。
猜想1下，大概“寫”的思路：
1、將當(dāng)前進程加入到等待隊列
2、設(shè)置當(dāng)前進程為可打斷的
3、層層調(diào)用終究調(diào)用到底層的 start_tx 函數(shù)，將要發(fā)送的數(shù)據(jù)存入 DATA 寄存器，由硬件自動發(fā)送。
4、進程調(diào)度，當(dāng)前進程進入休眠。
5、硬件發(fā)送完成，進入中斷處理函數(shù)，喚醒對面隊列。
固然這只是我自己意淫的，究竟是不是這樣，具體分析底層操作函數(shù)的時候應(yīng)當(dāng)會明白。
3.2 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;
/* We want to wait for the line discipline to sort out in this
situation */
ld = tty_ldisc_ref_wait(tty);
/* 調(diào)用線路規(guī)程 n_tty_read */
if (ld->ops->read)
i = (ld->ops->read)(tty, file, buf, count);
else
i = -EIO;
tty_ldisc_deref(ld);
if (i > 0)
inode->i_atime = current_fs_time(inode->i_sb);
return i;
}
調(diào)用線路規(guī)程的 read 函數(shù)，對 N_TTY 來講是 n_tty_read ,刪掉了1堆看不懂的代碼，還是有很多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 input
so that any interrupt will set the state back to
TASK_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);
/* 進程調(diào)度 休眠 */
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 獲得數(shù)據(jù) */
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⑴));
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)) {
/* 將數(shù)據(jù)拷貝到用戶空間 */
if (tty_put_user(tty, c, b++)) {
retval = -EFAULT;
b--;
break;
}
nr--;
}
if (eol) {
tty_audit_push(tty);
break;
}
}
if (retval)
break;
} else {
/* 非標準模式不關(guān)心刪掉 */
}
....
}
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、將當(dāng)前進程加入等待隊列
2、設(shè)置當(dāng)前進程可中斷
3、進程調(diào)度，當(dāng)前進程進入休眠
4、在某處被喚醒
5、從 tty->read_buf 取出數(shù)據(jù)，通過 tty_put_user 拷貝到用戶空間。
那末，在何處喚醒，猜想應(yīng)當(dāng)是在中斷處理函數(shù)中，當(dāng)DATA寄存器滿，觸發(fā)中斷，中斷處理函數(shù)中調(diào)用 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);
else
schedule_delayed_work(&tty->buf.work, 1);
}
tty_flip_buffer_push 有兩種方式調(diào)用到 flush_to_ldisc ，1種直接調(diào)用，另外一種使用延時工作隊列，在很久很久之前，我們初始化了這么1個工作隊列~（tty_open 初始化 tty_struct 時前面有提到）。
在 flush_to_ldisc 會調(diào)用到 disc->ops->receive_buf ，對 N_TTY 來講是 n_tty_receive_buf
，在 n_tty_receive_buf 中，將數(shù)據(jù)拷貝到 tty->read_buf ,然后 wake_up_interruptible(&tty->read_wait) 喚醒休眠隊列。然后就是前面提到的，在n_tty_read
函數(shù)中 從 tty->read_buf 里取出數(shù)據(jù) 拷貝到用戶空間了。
至此，關(guān)于 uart 的框架分析基本就結(jié)束了~對 tty 和線路規(guī)程是甚么東西，大概了解是個甚么東西。雖然大部份東西都不需要我們自己實現(xiàn)，但是了解它們有益無害~
下1篇文章，以 s3c2440 為例，分析底層的操作函數(shù)，和 s3c2440 是如何初始化 uart_port 結(jié)構(gòu)的~，這些是在移植驅(qū)動進程中需要做的工作~
生活不易，碼農(nóng)辛苦
如果您覺得本網(wǎng)站對您的學(xué)習(xí)有所幫助,可以手機掃描二維碼進行捐贈
