Linux串口驱动分析read

/*串口read函数分析
* 当应用程序调用read系统调用时，会调用tty_fops中的tty_read
* 接下来分析tty_read函数
*
* 其中最重要的就是ld->ops->read(tty,file,buf,count);
* 也就是调用线路规程中read函数
*/

static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
			loff_t *ppos)
{
	int i;
	struct inode *inode = file->f_path.dentry->d_inode;
	struct tty_struct *tty = file_tty(file);
	struct tty_ldisc *ld;

	if (tty_paranoia_check(tty, inode, "tty_read"))
		return -EIO;
	if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
		return -EIO;

	/* We want to wait for the line discipline to sort out in this
	   situation */
	ld = tty_ldisc_ref_wait(tty);
	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;
}


/* 线路规程的ops是： tty_ldisc_N_TTY
* read =   = n_tty_read,
* buf代表的是用户空间传下来的buf， 将来需要我们把数据写到buf中去
*/
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;
	
	/*其实n_tty_read就是调用copy_from_read_buf将tty->read_buf中的数据送到用户传下来的buf中。 前面都是一些合法的判断
	*/
	uncopied = copy_from_read_buf(tty, &b, &nr);
	uncopied += copy_from_read_buf(tty, &b, &nr);
}

/*** 其实从copy_from_read_buf中可以很明显的看见*/
static int copy_from_read_buf(struct tty_struct *tty,unsigned char __user **b,size_t *nr)
{
	/*很明显的可以看见copy_to_user函数。数据是从tty->read_buf中拷贝到b中去的。
	* 那么tty->read中的数据那又是从那里来的？
	*/
	if (n) {
		retval = copy_to_user(*b, &tty->read_buf[tty->read_tail], n);
		n -= retval;
		tty_audit_add_data(tty, &tty->read_buf[tty->read_tail], n);
		spin_lock_irqsave(&tty->read_lock, flags);
		tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1);
		tty->read_cnt -= n;
		/* Turn single EOF into zero-length read */
		if (L_EXTPROC(tty) && tty->icanon && n == 1) {
			if (!tty->read_cnt && (*b)[n-1] == EOF_CHAR(tty))
				n--;
		}
		spin_unlock_irqrestore(&tty->read_lock, flags);
		*b += n;
		*nr -= n;
	}
	return retval;
}

/*接下来分析tty->read_buf中的数据是从那里来的？
* 首先： 数据当然是从硬件里read出来的。
* 那么当我们的串口有数据的话，当然就调用我们以前注册的rx中断函数了。
*/

static irqreturn_t s3c24xx_serial_rx_chars(int irq, void *dev_id)
{
	struct s3c24xx_uart_port *ourport = dev_id;
	struct uart_port *port = &ourport->port;
	struct tty_struct *tty = port->state->port.tty;
	unsigned int ufcon, ch, flag, ufstat, uerstat;
	int max_count = 64;

	while (max_count-- > 0) {
		/*读取UFCON串口配置寄存器*/
		ufcon = rd_regl(port, S3C2410_UFCON);
		/*读取 UFSTAT串口状态寄存器。*/
		ufstat = rd_regl(port, S3C2410_UFSTAT);

		/*根据读出的ufstat判断UFSTAT中rx的fifo是否为0*/
		if (s3c24xx_serial_rx_fifocnt(ourport, ufstat) == 0)
			break;

		/*读取UERSTAT错误状态寄存器*/
		uerstat = rd_regl(port, S3C2410_UERSTAT);
		/*读取URXH寄存器*/
		ch = rd_regb(port, S3C2410_URXH);

		/*进行流量控制*/
		if (port->flags & UPF_CONS_FLOW) {
			int txe = s3c24xx_serial_txempty_nofifo(port);

			if (rx_enabled(port)) {
				if (!txe) {
					rx_enabled(port) = 0;
					continue;
				}
			} else {
				if (txe) {
					ufcon |= S3C2410_UFCON_RESETRX;
					wr_regl(port, S3C2410_UFCON, ufcon);
					rx_enabled(port) = 1;
					goto out;
				}
				continue;
			}
		}

		/* insert the character into the buffer */

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

		if (unlikely(uerstat & S3C2410_UERSTAT_ANY)) {
			dbg("rxerr: port ch=0x%02x, rxs=0x%08x\n",
			    ch, uerstat);

			/* check for break */
			if (uerstat & S3C2410_UERSTAT_BREAK) {
				dbg("break!\n");
				port->icount.brk++;
				if (uart_handle_break(port))
				    goto ignore_char;
			}

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

			uerstat &= port->read_status_mask;

			if (uerstat & S3C2410_UERSTAT_BREAK)
				flag = TTY_BREAK;
			else if (uerstat & S3C2410_UERSTAT_PARITY)
				flag = TTY_PARITY;
			else if (uerstat & (S3C2410_UERSTAT_FRAME |
					    S3C2410_UERSTAT_OVERRUN))
				flag = TTY_FRAME;
		}
		
		if (uart_handle_sysrq_char(port, ch))
			goto ignore_char;

		/*插入ch也就是数据到tty->tty_bufhead中去。 当whiel大循环完后， 整个64字节数据都存放到tty->tty_bufhead中去*/
		uart_insert_char(port, uerstat, S3C2410_UERSTAT_OVERRUN,
				 ch, flag);
			}
			
		/*这是才将整个数据送tty->read_buf中去*/
		tty_flip_buffer_push(tty);
}
/* 将串口产生的数据送进tty->buf.tail中去。 */
static inline int tty_insert_flip_char(struct tty_struct *tty,unsigned char ch, char flag)
{
	struct tty_buffer *tb = tty->buf.tail;
	if (tb && tb->used < tb->size) {
		tb->flag_buf_ptr[tb->used] = flag;		/*用于存放flag,也就是状态位*/
		tb->char_buf_ptr[tb->used++] = ch;		/*用于存放真正的数据*/
		return 1;
	}
	return tty_insert_flip_string_flags(tty, &ch, &flag, 1);
}

static void flush_to_ldisc(struct work_struct *work)
{
			char_buf = head->char_buf_ptr + head->read;		/*char_buf用于存放真实数据*/
			flag_buf = head->flag_buf_ptr + head->read;   /*flag_buf用于存放flag标志*/
			head->read += count;														
			spin_unlock_irqrestore(&tty->buf.lock, flags);
			disc->ops->receive_buf(tty, char_buf,			/*调用tty_ldisc_N_TTY中的recive_buf函数*/
							flag_buf, count);
}

static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,char *fp, int count)
{
	
	if (tty->real_raw) {
		spin_lock_irqsave(&tty->read_lock, cpuflags);
		i = min(N_TTY_BUF_SIZE - tty->read_cnt,			/*判断大小*/
			N_TTY_BUF_SIZE - tty->read_head);
		i = min(count, i);
		memcpy(tty->read_buf + tty->read_head, cp, i);		/*这才是真正的拷贝数据到tty->read_buf中去*/
		tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1); /*其实read_buf是一个环形缓冲区。 每次写进数据都会调正read_head的位置。 同时改变read_cnt*/
		tty->read_cnt += i;
		cp += i;
		count -= i;

		i = min(N_TTY_BUF_SIZE - tty->read_cnt,
			N_TTY_BUF_SIZE - tty->read_head);
		i = min(count, i);
		memcpy(tty->read_buf + tty->read_head, cp, i);
		tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
		tty->read_cnt += i;
		spin_unlock_irqrestore(&tty->read_lock, cpuflags);
	}
}