串口驱动分析-接收

1.TTY数据接收
tty_read.c:

1. /**
   
2.  *    tty_read    -    read method for tty device files
   
3.  *    @file: pointer to tty file
   
4.  *    @buf: user buffer
   
5.  *    @count: size of user buffer
   
6.  *    @ppos: unused
   
7.  *
   
8.  *    Perform the read system call function on this terminal device. Checks
   
9.  *    for hung up devices before calling the line discipline method.
   
10.  *
    
11.  *    Locking:
    
12.  *        Locks the line discipline internally while needed. Multiple
    
13.  *    read calls may be outstanding in parallel.
    
14.  */
    
15. 
    
16. static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
    
17.             loff_t *ppos)
    
18. {
    
19.     int i;
    
20.     struct tty_struct *tty;
    
21.     struct inode *inode;
    
22.     struct tty_ldisc *ld;
    
23. 
    
24.     tty = (struct tty_struct *)file->private_data;
    
25.     inode = file->f_path.dentry->d_inode;
    
26.     if (tty_paranoia_check(tty, inode, "tty_read"))
    
27.         return -EIO;
    
28.     if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
    
29.         return -EIO;
    
30. 
    
31.     /* We want to wait for the line discipline to sort out in this
    
32.      situation */
    
33.     ld = tty_ldisc_ref_wait(tty);
    
34.     if (ld->ops->read)
    
35.         i = (ld->ops->read)(tty, file, buf, count);                                   //这里调用了线路规程中的read
    
36.     else
    
37.         i = -EIO;
    
38.     tty_ldisc_deref(ld);
    
39.     if (i > 0)
    
40.         inode->i_atime = current_fs_time(inode->i_sb);
    
41.     return i;
    
42. }

tty_ldisc_N_TTY:

1. struct tty_ldisc_ops tty_ldisc_N_TTY = {
   
2.     .magic = TTY_LDISC_MAGIC,
   
3.     .name = "n_tty",
   
4.     .open = n_tty_open,
   
5.     .close = n_tty_close,
   
6.     .flush_buffer = n_tty_flush_buffer,
   
7.     .chars_in_buffer = n_tty_chars_in_buffer,
   
8.     .read = n_tty_read,                                                 //调用的read函数
   
9.     .write = n_tty_write,
   
10.     .ioctl = n_tty_ioctl,
    
11.     .set_termios = n_tty_set_termios,
    
12.     .poll = n_tty_poll,
    
13.     .receive_buf = n_tty_receive_buf,
    
14.     .write_wakeup = n_tty_write_wakeup
    
15. };

n_tty_read:

1. /**
   
2.  *    n_tty_read        -    read function for tty
   
3.  *    @tty: tty device
   
4.  *    @file: file object
   
5.  *    @buf: userspace buffer pointer
   
6.  *    @nr: size of I/O
   
7.  *
   
8.  *    Perform reads for the line discipline. We are guaranteed that the
   
9.  *    line discipline will not be closed under us but we may get multiple
   
10.  *    parallel readers and must handle this ourselves. We may also get
    
11.  *    a hangup. Always called in user context, may sleep.
    
12.  *
    
13.  *    This code must be sure never to sleep through a hangup.
    
14.  */
    
15. 
    
16. static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
    
17.              unsigned char __user *buf, size_t nr)
    
18. {
    
19.     unsigned char __user *b = buf;
    
20.     DECLARE_WAITQUEUE(wait, current);
    
21.     int c;
    
22.     int minimum, time;
    
23.     ssize_t retval = 0;
    
24.     ssize_t size;
    
25.     long timeout;
    
26.     unsigned long flags;
    
27.     int packet;
    
28. 
    
29.     .......
30. 
    
31.         /* This statement must be first before checking for input
    
32.          so that any interrupt will set the state back to
    
33.          TASK_RUNNING. */
    
34.         set_current_state(TASK_INTERRUPTIBLE);                                          //设置当前进程的状态，后面调度后阻塞
    
35. 
    
36.         if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
    
37.          ((minimum - (b - buf)) >= 1))
    
38.             tty->minimum_to_wake = (minimum - (b - buf));
    
39. 
    
40.         if (!input_available_p(tty, 0)) {                                                //判断有没有数据可以读取
    
41.             if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
    
42.                 retval = -EIO;
    
43.                 break;
    
44.             }
    
45.             if (tty_hung_up_p(file))
    
46.                 break;
    
47.             if (!timeout)
    
48.                 break;
    
49.             if (file->f_flags & O_NONBLOCK) {
    
50.                 retval = -EAGAIN;
    
51.                 break;
    
52.             }
    
53.             if (signal_pending(current)) {
    
54.                 retval = -ERESTARTSYS;
    
55.                 break;
    
56.             }
    
57.             /* FIXME: does n_tty_set_room need locking ? */
    
58.             n_tty_set_room(tty);
    
59.             timeout = schedule_timeout(timeout);                                         //调度，如果没有数据可读，让阻塞生效
    
60.             continue;
    
61.         }
    
62.         __set_current_state(TASK_RUNNING);                                               //如果有数据，
    
63. 
    
64.         /* Deal with packet mode. */
    
65.         if (packet && b == buf) {
    
66.             if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
    
67.                 retval = -EFAULT;
    
68.                 b--;
    
69.                 break;
    
70.             }
    
71.             nr--;
    
72.         }
    
73. 
    
74.         if (tty->icanon) {
    
75.             /* N.B. avoid overrun if nr == 0 */
    
76.             while (nr && tty->read_cnt) {
    
77.                 int eol;
    
78. 
    
79.                 eol = test_and_clear_bit(tty->read_tail,
    
80.                         tty->read_flags);
    
81.                 c = tty->read_buf[tty->read_tail];
    
82.                 spin_lock_irqsave(&tty->read_lock, flags);
    
83.                 tty->read_tail = ((tty->read_tail+1) &
    
84.                          (N_TTY_BUF_SIZE-1));
    
85.                 tty->read_cnt--;
    
86.                 if (eol) {
    
87.                     /* this test should be redundant:
    
88.                      * we shouldn't be reading data if
    
89.                      * canon_data is 0
    
90.                      */
    
91.                     if (--tty->canon_data < 0)
    
92.                         tty->canon_data = 0;
    
93.                 }
    
94.                 spin_unlock_irqrestore(&tty->read_lock, flags);
    
95. 
    
96.                 if (!eol || (c != __DISABLED_CHAR)) {
    
97.                     if (tty_put_user(tty, c, b++)) {
    
98.                         retval = -EFAULT;
    
99.                         b--;
    
100.                         break;
     
101.                     }
     
102.                     nr--;
     
103.                 }
     
104.                 if (eol) {
     
105.                     tty_audit_push(tty);
     
106.                     break;
     
107.                 }
     
108.             }
     
109.             if (retval)
     
110.                 break;
     
111.         } else {
     
112.             int uncopied;
     
113.             /* The copy function takes the read lock and handles
     
114.              locking internally for this case */
     
115.             uncopied = copy_from_read_buf(tty, &b, &nr);                                             //从readbuf中读取shu
     
116.             uncopied += copy_from_read_buf(tty, &b, &nr);
     
117.             if (uncopied) {
     
118.                 retval = -EFAULT;
     
119.                 break;
     
120.             }
     
121.         }
     
122. 
     
123.         /* If there is enough space in the read buffer now, let the
     
124.          * low-level driver know. We use n_tty_chars_in_buffer() to
     
125.          * check the buffer, as it now knows about canonical mode.
     
126.          * Otherwise, if the driver is throttled and the line is
     
127.          * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
     
128.          * we won't get any more characters.
     
129.          */
     
130.         if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) {
     
131.             n_tty_set_room(tty);
     
132.             check_unthrottle(tty);
     
133.         }
     
134. 
     
135.         if (b - buf >= minimum)
     
136.             break;
     
137.         if (time)
     
138.             timeout = time;
     
139.     }
     
140.     mutex_unlock(&tty->atomic_read_lock);
     
141.     remove_wait_queue(&tty->read_wait, &wait);
     
142. 
     
143.     if (!waitqueue_active(&tty->read_wait))
     
144.         tty->minimum_to_wake = minimum;
     
145. 
     
146.     __set_current_state(TASK_RUNNING);
     
147.     size = b - buf;
     
148.     if (size) {
     
149.         retval = size;
     
150.         if (nr)
     
151.             clear_bit(TTY_PUSH, &tty->flags);
     
152.     } else if (test_and_clear_bit(TTY_PUSH, &tty->flags))
     
153.          goto do_it_again;
     
154. 
     
155.     n_tty_set_room(tty);
     
156.     return retval;
     
157. }

copy_from_read_buf:

1. 
   
2. static int copy_from_read_buf(struct tty_struct *tty,
   
3.                  unsigned char __user **b,
   
4.                  size_t *nr)
   
5. 
   
6. {
   
7.     int retval;
   
8.     size_t n;
   
9.     unsigned long flags;
   
10. 
    
11.     retval = 0;
    
12.     spin_lock_irqsave(&tty->read_lock, flags);
    
13.     n = min(tty->read_cnt, N_TTY_BUF_SIZE - tty->read_tail);
    
14.     n = min(*nr, n);
    
15.     spin_unlock_irqrestore(&tty->read_lock, flags);
    
16.     if (n) {
    
17.         retval = copy_to_user(*b, &tty->read_buf[tty->read_tail], n);                         //read_buf就是读缓冲
18.         n -= retval;
    
19.         tty_audit_add_data(tty, &tty->read_buf[tty->read_tail], n);
    
20.         spin_lock_irqsave(&tty->read_lock, flags);
    
21.         tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1);
    
22.         tty->read_cnt -= n;
    
23.         spin_unlock_irqrestore(&tty->read_lock, flags);
    
24.         *b += n;
    
25.         *nr -= n;
    
26.     }
    
27.     return retval;
    
28. }

总结：应用APP-->TTY核心-->TTY线路规程（read_buf有就给APP，没有就阻塞）；然后read_buf其实是串口驱动收到的，只是不是同时处理的。

二、串口驱动接收分析
s3c24xx_serial_rx_chars：

1. static irqreturn_t
   
2. s3c24xx_serial_rx_chars(int irq, void *dev_id)
   
3. {
   
4.     struct s3c24xx_uart_port *ourport = dev_id;
   
5.     struct uart_port *port = &ourport->port;
   
6.     struct tty_struct *tty = port->info->port.tty;
   
7.     unsigned int ufcon, ch, flag, ufstat, uerstat;
   
8.     int max_count = 64;                                                             //一次中断最多64字符
   
9. 
   
10.     while (max_count-- > 0) {
    
11.         ufcon = rd_regl(port, S3C2410_UFCON);                                       //读取了UFCON寄存器
    
12.         ufstat = rd_regl(port, S3C2410_UFSTAT);                                     //读取UFSTAT
    
13. 
    
14.         if (s3c24xx_serial_rx_fifocnt(ourport, ufstat) == 0)                        //如果接收FIFO数据量为0，则退出
    
15.             break;
    
16. 
    
17.         uerstat = rd_regl(port, S3C2410_UERSTAT);                                   //读取uerstat
    
18.         ch = rd_regb(port, S3C2410_URXH);                                           //取出接收到的数据
    
19. 
    
20.         if (port->flags & UPF_CONS_FLOW) {                                          //流控处理
    
21.             int txe = s3c24xx_serial_txempty_nofifo(port);                          //判断发送缓冲是否为空
    
22. 
    
23.             if (rx_enabled(port)) {                                                 //如果port接收功能是使能的
    
24.                 if (!txe) {                                                         //如果txe为0
    
25.                     rx_enabled(port) = 0;                                           
    
26.                     continue;
    
27.                 }
    
28.             } else {
    
29.                 if (txe) {                                                          //如果txe为1
    
30.                     ufcon |= S3C2410_UFCON_RESETRX;
    
31.                     wr_regl(port, S3C2410_UFCON, ufcon);
    
32.                     rx_enabled(port) = 1;
    
33.                     goto out;
    
34.                 }
    
35.                 continue;
    
36.             }
    
37.         }
    
38. 
    
39.         /* insert the character into the buffer */
    
40. 
    
41.         flag = TTY_NORMAL;
    
42.         port->icount.rx++;
    
43. 
    
44.         if (unlikely(uerstat & S3C2410_UERSTAT_ANY)) {                             //根据USRSTAT寄存器的值，
    
45.             dbg("rxerr: port ch=0x%02x, rxs=0x%08x\n",
    
46.              ch, uerstat);
    
47. 
    
48.             /* check for break */
    
49.             if (uerstat & S3C2410_UERSTAT_BREAK) {
    
50.                 dbg("break!\n");
    
51.                 port->icount.brk++;
    
52.                 if (uart_handle_break(port))
    
53.                  goto ignore_char;
    
54.             }
    
55. 
    
56.             if (uerstat & S3C2410_UERSTAT_FRAME)
    
57.                 port->icount.frame++;
    
58.             if (uerstat & S3C2410_UERSTAT_OVERRUN)
    
59.                 port->icount.overrun++;
    
60. 
    
61.             uerstat &= port->read_status_mask;
    
62. 
    
63.             if (uerstat & S3C2410_UERSTAT_BREAK)
    
64.                 flag = TTY_BREAK;
    
65.             else if (uerstat & S3C2410_UERSTAT_PARITY)
    
66.                 flag = TTY_PARITY;
    
67.             else if (uerstat & (S3C2410_UERSTAT_FRAME |
    
68.                      S3C2410_UERSTAT_OVERRUN))
    
69.                 flag = TTY_FRAME;
    
70.         }
    
71. 
    
72.         if (uart_handle_sysrq_char(port, ch))                                        //如果收到的是sysrq字符，进行特殊处理
    
73.             goto ignore_char;
    
74. 
    
75.         uart_insert_char(port, uerstat, S3C2410_UERSTAT_OVERRUN,                     //把接收到的字符送进串口驱动的buf_uart_insert_char
    
76.                  ch, flag);
    
77. 
    
78.  ignore_char:
    
79.         continue;
    
80.     }
    
81.     tty_flip_buffer_push(tty);                                                       //把串口驱动收到的数据送进线路规程的read_buf
    
82. 
    
83.  out:
    
84.     return IRQ_HANDLED;
    
85. }

三、串口流控
当A向B发送数据时，B的缓冲如果满了。要向A发送一个FIFO满了的信号，这个就是流控：
分成软件（信号）、硬件（B的串口RTS设置成高电位,A的CTS就知道B已经满了）（又分成非自动、和自动）