Linux串口驱动分析read

</pre><pre name="code" class="cpp">

1. 文章出自：http://blog.youkuaiyun.com/longwang155069/article/details/42776059
2. 
   
3. /*串口read函数分析 
4. * 当应用程序调用read系统调用时，会调用tty_fops中的tty_read 
5. * 接下来分析tty_read函数 
6. * 
7. * 其中最重要的就是ld->ops->read(tty,file,buf,count); 
8. * 也就是调用线路规程中read函数 
9. */  
10.   
11. static ssize_t tty_read(struct file *file, char __user *buf, size_t count,  
12.             loff_t *ppos)  
13. {  
14.     int i;  
15.     struct inode *inode = file->f_path.dentry->d_inode;  
16.     struct tty_struct *tty = file_tty(file);  
17.     struct tty_ldisc *ld;  
18.   
19.     if (tty_paranoia_check(tty, inode, "tty_read"))  
20.         return -EIO;  
21.     if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))  
22.         return -EIO;  
23.   
24.     /* We want to wait for the line discipline to sort out in this 
25.        situation */  
26.     ld = tty_ldisc_ref_wait(tty);  
27.     if (ld->ops->read)  
28.         i = (ld->ops->read)(tty, file, buf, count);  
29.     else  
30.         i = -EIO;  
31.     tty_ldisc_deref(ld);  
32.     if (i > 0)  
33.         inode->i_atime = current_fs_time(inode->i_sb);  
34.     return i;  
35. }  
36.   
37.   
38. /* 线路规程的ops是： tty_ldisc_N_TTY 
39. * read =   = n_tty_read, 
40. * buf代表的是用户空间传下来的buf， 将来需要我们把数据写到buf中去 
41. */  
42. static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,unsigned char __user *buf, size_t nr)  
43. {  
44.     unsigned char __user *b = buf;  
45.       
46.     /*其实n_tty_read就是调用copy_from_read_buf将tty->read_buf中的数据送到用户传下来的buf中。 前面都是一些合法的判断 
47.     */  
48.     uncopied = copy_from_read_buf(tty, &b, &nr);  
49.     uncopied += copy_from_read_buf(tty, &b, &nr);  
50. }  
51.   
52. /*** 其实从copy_from_read_buf中可以很明显的看见*/  
53. static int copy_from_read_buf(struct tty_struct *tty,unsigned char __user **b,size_t *nr)  
54. {  
55.     /*很明显的可以看见copy_to_user函数。数据是从tty->read_buf中拷贝到b中去的。 
56.     * 那么tty->read中的数据那又是从那里来的？ 
57.     */  
58.     if (n) {  
59.         retval = copy_to_user(*b, &tty->read_buf[tty->read_tail], n);  
60.         n -= retval;  
61.         tty_audit_add_data(tty, &tty->read_buf[tty->read_tail], n);  
62.         spin_lock_irqsave(&tty->read_lock, flags);  
63.         tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1);  
64.         tty->read_cnt -= n;  
65.         /* Turn single EOF into zero-length read */  
66.         if (L_EXTPROC(tty) && tty->icanon && n == 1) {  
67.             if (!tty->read_cnt && (*b)[n-1] == EOF_CHAR(tty))  
68.                 n--;  
69.         }  
70.         spin_unlock_irqrestore(&tty->read_lock, flags);  
71.         *b += n;  
72.         *nr -= n;  
73.     }  
74.     return retval;  
75. }  
76.   
77. /*接下来分析tty->read_buf中的数据是从那里来的？ 
78. * 首先： 数据当然是从硬件里read出来的。 
79. * 那么当我们的串口有数据的话，当然就调用我们以前注册的rx中断函数了。 
80. */  
81.   
82. static irqreturn_t s3c24xx_serial_rx_chars(int irq, void *dev_id)  
83. {  
84.     struct s3c24xx_uart_port *ourport = dev_id;  
85.     struct uart_port *port = &ourport->port;  
86.     struct tty_struct *tty = port->state->port.tty;  
87.     unsigned int ufcon, ch, flag, ufstat, uerstat;  
88.     int max_count = 64;  
89.   
90.     while (max_count-- > 0) {  
91.         /*读取UFCON串口配置寄存器*/  
92.         ufcon = rd_regl(port, S3C2410_UFCON);  
93.         /*读取 UFSTAT串口状态寄存器。*/  
94.         ufstat = rd_regl(port, S3C2410_UFSTAT);  
95.   
96.         /*根据读出的ufstat判断UFSTAT中rx的fifo是否为0*/  
97.         if (s3c24xx_serial_rx_fifocnt(ourport, ufstat) == 0)  
98.             break;  
99.   
100.         /*读取UERSTAT错误状态寄存器*/  
101.         uerstat = rd_regl(port, S3C2410_UERSTAT);  
102.         /*读取URXH寄存器*/  
103.         ch = rd_regb(port, S3C2410_URXH);  
104.   
105.         /*进行流量控制*/  
106.         if (port->flags & UPF_CONS_FLOW) {  
107.             int txe = s3c24xx_serial_txempty_nofifo(port);  
108.   
109.             if (rx_enabled(port)) {  
110.                 if (!txe) {  
111.                     rx_enabled(port) = 0;  
112.                     continue;  
113.                 }  
114.             } else {  
115.                 if (txe) {  
116.                     ufcon |= S3C2410_UFCON_RESETRX;  
117.                     wr_regl(port, S3C2410_UFCON, ufcon);  
118.                     rx_enabled(port) = 1;  
119.                     goto out;  
120.                 }  
121.                 continue;  
122.             }  
123.         }  
124.   
125.         /* insert the character into the buffer */  
126.   
127.         flag = TTY_NORMAL;  
128.         port->icount.rx++;  
129.   
130.         if (unlikely(uerstat & S3C2410_UERSTAT_ANY)) {  
131.             dbg("rxerr: port ch=0x%02x, rxs=0x%08x\n",  
132.                 ch, uerstat);  
133.   
134.             /* check for break */  
135.             if (uerstat & S3C2410_UERSTAT_BREAK) {  
136.                 dbg("break!\n");  
137.                 port->icount.brk++;  
138.                 if (uart_handle_break(port))  
139.                     goto ignore_char;  
140.             }  
141.   
142.             if (uerstat & S3C2410_UERSTAT_FRAME)  
143.                 port->icount.frame++;  
144.             if (uerstat & S3C2410_UERSTAT_OVERRUN)  
145.                 port->icount.overrun++;  
146.   
147.             uerstat &= port->read_status_mask;  
148.   
149.             if (uerstat & S3C2410_UERSTAT_BREAK)  
150.                 flag = TTY_BREAK;  
151.             else if (uerstat & S3C2410_UERSTAT_PARITY)  
152.                 flag = TTY_PARITY;  
153.             else if (uerstat & (S3C2410_UERSTAT_FRAME |  
154.                         S3C2410_UERSTAT_OVERRUN))  
155.                 flag = TTY_FRAME;  
156.         }  
157.           
158.         if (uart_handle_sysrq_char(port, ch))  
159.             goto ignore_char;  
160.   
161.         /*插入ch也就是数据到tty->tty_bufhead中去。 当whiel大循环完后， 整个64字节数据都存放到tty->tty_bufhead中去*/  
162.         uart_insert_char(port, uerstat, S3C2410_UERSTAT_OVERRUN,  
163.                  ch, flag);  
164.             }  
165.               
166.         /*这是才将整个数据送tty->read_buf中去*/  
167.         tty_flip_buffer_push(tty);  
168. }  
169. /* 将串口产生的数据送进tty->buf.tail中去。 */  
170. static inline int tty_insert_flip_char(struct tty_struct *tty,unsigned char ch, char flag)  
171. {  
172.     struct tty_buffer *tb = tty->buf.tail;  
173.     if (tb && tb->used < tb->size) {  
174.         tb->flag_buf_ptr[tb->used] = flag;        /*用于存放flag,也就是状态位*/  
175.         tb->char_buf_ptr[tb->used++] = ch;        /*用于存放真正的数据*/  
176.         return 1;  
177.     }  
178.     return tty_insert_flip_string_flags(tty, &ch, &flag, 1);  
179. }  
180.   
181. static void flush_to_ldisc(struct work_struct *work)  
182. {  
183.             char_buf = head->char_buf_ptr + head->read;       /*char_buf用于存放真实数据*/  
184.             flag_buf = head->flag_buf_ptr + head->read;   /*flag_buf用于存放flag标志*/  
185.             head->read += count;                                                       
186.             spin_unlock_irqrestore(&tty->buf.lock, flags);  
187.             disc->ops->receive_buf(tty, char_buf,         /*调用tty_ldisc_N_TTY中的recive_buf函数*/  
188.                             flag_buf, count);  
189. }  
190.   
191. static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,char *fp, int count)  
192. {  
193.       
194.     if (tty->real_raw) {  
195.         spin_lock_irqsave(&tty->read_lock, cpuflags);  
196.         i = min(N_TTY_BUF_SIZE - tty->read_cnt,          /*判断大小*/  
197.             N_TTY_BUF_SIZE - tty->read_head);  
198.         i = min(count, i);  
199.         memcpy(tty->read_buf + tty->read_head, cp, i);        /*这才是真正的拷贝数据到tty->read_buf中去*/  
200.         tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1); /*其实read_buf是一个环形缓冲区。 每次写进数据都会调正read_head的位置。 同时改变read_cnt*/  
201.         tty->read_cnt += i;  
202.         cp += i;  
203.         count -= i;  
204.   
205.         i = min(N_TTY_BUF_SIZE - tty->read_cnt,  
206.             N_TTY_BUF_SIZE - tty->read_head);  
207.         i = min(count, i);  
208.         memcpy(tty->read_buf + tty->read_head, cp, i);  
209.         tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);  
210.         tty->read_cnt += i;  
211.         spin_unlock_irqrestore(&tty->read_lock, cpuflags);  
212.     }  
213. }