Linux串口驱动分析write

1. 文章来自：http://blog.csdn.net/longwang155069/article/details/42780331
2. 
   
3. /*和read的分析过程一样， 我们首先分析tty_write*/  
4.   
5. /*最重要的就是do_tty_write函数。 前面都是一些合法性判断*/  
6. static ssize_t tty_write(struct file *file, const char __user *buf,size_t count, loff_t *ppos)  
7. {  
8.     struct inode *inode = file->f_path.dentry->d_inode;  
9.     struct tty_struct *tty = file_tty(file);  
10.     struct tty_ldisc *ld;  
11.     ssize_t ret;  
12.   
13.     if (tty_paranoia_check(tty, inode, "tty_write"))  
14.         return -EIO;  
15.     if (!tty || !tty->ops->write ||  
16.         (test_bit(TTY_IO_ERROR, &tty->flags)))  
17.             return -EIO;  
18.     /* Short term debug to catch buggy drivers */  
19.     if (tty->ops->write_room == NULL)  
20.         printk(KERN_ERR "tty driver %s lacks a write_room method.\n",  
21.             tty->driver->name);  
22.     ld = tty_ldisc_ref_wait(tty);  
23.     if (!ld->ops->write)  
24.         ret = -EIO;  
25.     else  
26.         /*调用tty_ldisc_N_TTY中的write函数*/  
27.         ret = do_tty_write(ld->ops->write, tty, file, buf, count);  
28.     tty_ldisc_deref(ld);  
29.     return ret;  
30. }  
31.   
32. /*调用uart_ops中的write函数*/  
33. static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,const unsigned char *buf, size_t nr)  
34. {  
35.     c = tty->ops->write(tty, b, nr);  
36. }  
37.   
38. static int uart_write(struct tty_struct *tty,const unsigned char *buf, int count)  
39. {  
40.     struct uart_state *state = tty->driver_data;  
41.     struct uart_port *port;  
42.     struct circ_buf *circ;  
43.     unsigned long flags;  
44.     int c, ret = 0;  
45.   
46.     /* 
47.      * This means you called this function _after_ the port was 
48.      * closed.  No cookie for you. 
49.      */  
50.     if (!state) {  
51.         WARN_ON(1);  
52.         return -EL3HLT;  
53.     }  
54.   
55.   /*取出所对应的port和循环缓冲buf*/  
56.     port = state->uart_port;  
57.     circ = &state->xmit;  
58.   
59.     if (!circ->buf)  
60.         return 0;  
61.   
62.     spin_lock_irqsave(&port->lock, flags);  
63.     while (1) {  
64.         /*计算循环缓冲的剩余空间 */  
65.         c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);  
66.         if (count < c)  
67.             c = count;  
68.         if (c <= 0)  
69.             break;  
70.         /*拷贝数据到循环缓冲区*/  
71.         memcpy(circ->buf + circ->head, buf, c);  
72.         /*调正循环缓冲head的位置*/  
73.         circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);  
74.         /*挪动buf当前的指针位置*/  
75.         buf += c;  
76.         count -= c;  
77.         ret += c;  
78.     }  
79.     spin_unlock_irqrestore(&port->lock, flags);  
80.   
81.     uart_start(tty);  
82.     return ret;  
83. }  
84.   
85. /*判断循环缓冲是否为空等。 然后调用注册驱动时的ops。 也就是s3c24xx_serial_ops*/  
86. static void __uart_start(struct tty_struct *tty)  
87. {  
88.     struct uart_state *state = tty->driver_data;  
89.     struct uart_port *port = state->uart_port;  
90.   
91.     if (!uart_circ_empty(&state->xmit) && state->xmit.buf &&  
92.         !tty->stopped && !tty->hw_stopped)  
93.         port->ops->start_tx(port);  
94. }  
95.   
96. /*判断端口是否使能，如果没使能则使能端口。 然后使能tx中断 
97. * 使能tx中断，则当有数据来时，则会触发tx中断，调用中断函数 
98. */  
99. static void s3c24xx_serial_start_tx(struct uart_port *port)  
100. {  
101.     struct s3c24xx_uart_port *ourport = to_ourport(port);  
102.     static int a =1;//temp  
103.     if (port->line == 3) {  
104. //      printk("485_start_tx\n");  
105.   
106.         if(a){  
107.             s3c_gpio_cfgpin(S3C64XX_GPK(5), S3C_GPIO_SFN(1));  
108.             a=0;  
109.         }  
110.         gpio_set_value(S3C64XX_GPK(5), 1);  
111.     }  
112.     if (!tx_enabled(port)) {  
113.         if (port->flags & UPF_CONS_FLOW)  
114.             s3c24xx_serial_rx_disable(port);  
115.   
116.         enable_irq(ourport->tx_irq);  
117.         tx_enabled(port) = 1;  
118.     }  
119. }  
120.   
121. /*tx中断触发函数*/  
122. static irqreturn_t s3c24xx_serial_tx_chars(int irq, void *id)  
123. {  
124.     struct s3c24xx_uart_port *ourport = id;  
125.     struct uart_port *port = &ourport->port;  
126.     struct circ_buf *xmit = &port->state->xmit;  
127.     int count = 256;  
128.   
129.     /*判断x_char是否存在，如果存在则写进UTXH寄存器。清空x_char*/  
130.     if (port->x_char) {  
131.         wr_regb(port, S3C2410_UTXH, port->x_char);  
132.         port->icount.tx++;  
133.         port->x_char = 0;  
134.         goto out;  
135.     }  
136.   
137.     /* if there isn't anything more to transmit, or the uart is now 
138.      * stopped, disable the uart and exit 
139.     */  
140.   
141.     /*判断循环缓冲是否为空，或者tx是否为停止状态。 如果是则停止发送*/  
142.     if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {  
143.         s3c24xx_serial_stop_tx(port);  
144.         goto out;  
145.     }  
146.   
147.     /* try and drain the buffer... */  
148.   
149.     /*当循环缓冲buff不为空，而且count是大于0的。则进入while循环*/  
150.     while (!uart_circ_empty(xmit) && count-- > 0) {  
151.           
152.         /*首先读取UFSTAT寄存器，然后判断tx_fifo是否为0.是则退出*/  
153.         if (rd_regl(port, S3C2410_UFSTAT) & ourport->info->tx_fifofull)  
154.             break;  
155.   
156.         /*然后将循环buff中的数据读出到UTXH寄存器。然后设置tail的指针位置*/  
157.         wr_regb(port, S3C2410_UTXH, xmit->buf[xmit->tail]);  
158.         xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);  
159.         port->icount.tx++;  
160.     }  
161.   
162.     /*判断循环缓冲中的数据是否小于WAKEUP_CHARS, 小于则启动接受*/  
163.     if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)  
164.         uart_write_wakeup(port);  
165.           
166.     /*如果循环buff为空，则停止发送，退出*/  
167.     if (uart_circ_empty(xmit))  
168.         s3c24xx_serial_stop_tx(port);  
169. }