Chinaunix首页 | 论坛 | 博客

思而不学

首页　| 　博文目录　| 　关于我

ch122633

  • 博客访问： 499938
  • 博文数量： 223
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 2145
  • 用 户 组： 普通用户
  • 注册时间： 2014-03-01 10:23
个人简介

该坚持的时候坚持，该妥协的时候妥协，该放弃的时候放弃

文章分类

全部博文（223）

文章存档

2017年（56）

2016年（118）

2015年（3）

2014年（46）

我的朋友
最近访客
推荐博文
相关博文
串口驱动分析-接收

分类： 嵌入式

2016-11-18 23:23:59

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.  */

  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;

  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;

  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.  */

  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;

  29.     .......

  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);                                          //设置当前进程的状态，后面调度后阻塞

  36.         if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
  37.          ((minimum - (b - buf)) >= 1))
  38.             tty->minimum_to_wake = (minimum - (b - buf));

  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);                                               //如果有数据，

  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.         }

  74.         if (tty->icanon) {
  75.             /* N.B. avoid overrun if nr == 0 */
  76.             while (nr && tty->read_cnt) {
  77.                 int eol;

  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);

  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.         }

  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.         }

  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);

  143.     if (!waitqueue_active(&tty->read_wait))
  144.         tty->minimum_to_wake = minimum;

  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;

  155.     n_tty_set_room(tty);
  156.     return retval;
  157. }
copy_from_read_buf:

  2. static int copy_from_read_buf(struct tty_struct *tty,
  3.                  unsigned char __user **b,
  4.                  size_t *nr)

  6. {
  7.     int retval;
  8.     size_t n;
  9.     unsigned long flags;

  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字符

  10.     while (max_count-- > 0) {
  11.         ufcon = rd_regl(port, S3C2410_UFCON);                                       //读取了UFCON寄存器
  12.         ufstat = rd_regl(port, S3C2410_UFSTAT);                                     //读取UFSTAT

  14.         if (s3c24xx_serial_rx_fifocnt(ourport, ufstat) == 0)                        //如果接收FIFO数据量为0，则退出
  15.             break;

  17.         uerstat = rd_regl(port, S3C2410_UERSTAT);                                   //读取uerstat
  18.         ch = rd_regb(port, S3C2410_URXH);                                           //取出接收到的数据

  20.         if (port->flags & UPF_CONS_FLOW) {                                          //流控处理
  21.             int txe = s3c24xx_serial_txempty_nofifo(port);                          //判断发送缓冲是否为空

  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.         }

  39.         /* insert the character into the buffer */

  41.         flag = TTY_NORMAL;
  42.         port->icount.rx++;

  44.         if (unlikely(uerstat & S3C2410_UERSTAT_ANY)) {                             //根据USRSTAT寄存器的值，
  45.             dbg("rxerr: port ch=0x%02x, rxs=0x%08x\n",
  46.              ch, uerstat);

  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.             }

  56.             if (uerstat & S3C2410_UERSTAT_FRAME)
  57.                 port->icount.frame++;
  58.             if (uerstat & S3C2410_UERSTAT_OVERRUN)
  59.                 port->icount.overrun++;

  61.             uerstat &= port->read_status_mask;

  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.         }

  72.         if (uart_handle_sysrq_char(port, ch))                                        //如果收到的是sysrq字符，进行特殊处理
  73.             goto ignore_char;

  75.         uart_insert_char(port, uerstat, S3C2410_UERSTAT_OVERRUN,                     //把接收到的字符送进串口驱动的buf_uart_insert_char
  76.                  ch, flag);

  78.  ignore_char:
  79.         continue;
  80.     }
  81.     tty_flip_buffer_push(tty);                                                       //把串口驱动收到的数据送进线路规程的read_buf

  83.  out:
  84.     return IRQ_HANDLED;
  85. }

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



阅读(596) | 评论(0) | 转发(0) |
0

上一篇：串口驱动分析-发送

下一篇：串口驱动编程实现

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6