自学教程：C++ tty2n_hdlc函数代码示例

/** * n_hdlc_tty_close - line discipline close * @tty - pointer to tty info structure * * Called when the line discipline is changed to something * else, the tty is closed, or the tty detects a hangup. */static void n_hdlc_tty_close(struct tty_struct *tty){	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_close() called/n",__FILE__,__LINE__);			if (n_hdlc != NULL) {		if (n_hdlc->magic != HDLC_MAGIC) {			printk (KERN_WARNING"n_hdlc: trying to close unopened tty!/n");			return;		}#if defined(TTY_NO_WRITE_SPLIT)		clear_bit(TTY_NO_WRITE_SPLIT,&tty->flags);#endif		tty->disc_data = NULL;		if (tty == n_hdlc->backup_tty)			n_hdlc->backup_tty = NULL;		if (tty != n_hdlc->tty)			return;		if (n_hdlc->backup_tty) {			n_hdlc->tty = n_hdlc->backup_tty;		} else {			n_hdlc_release (n_hdlc);		}	}		if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_close() success/n",__FILE__,__LINE__);		}	/* end of n_hdlc_tty_close() */

static unsigned int n_hdlc_tty_poll(struct tty_struct *tty, struct file *filp,				    poll_table *wait){	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);	unsigned int mask = 0;	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_poll() called/n",__FILE__,__LINE__);			if (n_hdlc && n_hdlc->magic == HDLC_MAGIC && tty == n_hdlc->tty) {						poll_wait(filp, &tty->read_wait, wait);		poll_wait(filp, &tty->write_wait, wait);				if (n_hdlc->rx_buf_list.head)			mask |= POLLIN | POLLRDNORM;			if (test_bit(TTY_OTHER_CLOSED, &tty->flags))			mask |= POLLHUP;		if (tty_hung_up_p(filp))			mask |= POLLHUP;		if (!tty_is_writelocked(tty) &&				n_hdlc->tx_free_buf_list.head)			mask |= POLLOUT | POLLWRNORM;		}	return mask;}	

/** * n_hdlc_tty_ioctl - process IOCTL system call for the tty device. * @tty - pointer to tty instance data * @file - pointer to open file object for device * @cmd - IOCTL command code * @arg - argument for IOCTL call (cmd dependent) * * Returns command dependent result. */static int n_hdlc_tty_ioctl(struct tty_struct *tty, struct file *file,			    unsigned int cmd, unsigned long arg){	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);	int error = 0;	int count;	unsigned long flags;	struct n_hdlc_buf *buf = NULL;	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_ioctl() called %d/n",			__FILE__,__LINE__,cmd);			/* Verify the status of the device */	if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC)		return -EBADF;	switch (cmd) {	case FIONREAD:		/* report count of read data available */		/* in next available frame (if any) */		spin_lock_irqsave(&n_hdlc->rx_buf_list.spinlock,flags);		buf = list_first_entry_or_null(&n_hdlc->rx_buf_list.list,						struct n_hdlc_buf, list_item);		if (buf)			count = buf->count;		else			count = 0;		spin_unlock_irqrestore(&n_hdlc->rx_buf_list.spinlock,flags);		error = put_user(count, (int __user *)arg);		break;	case TIOCOUTQ:		/* get the pending tx byte count in the driver */		count = tty_chars_in_buffer(tty);		/* add size of next output frame in queue */		spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock,flags);		buf = list_first_entry_or_null(&n_hdlc->tx_buf_list.list,						struct n_hdlc_buf, list_item);		if (buf)			count += buf->count;		spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock,flags);		error = put_user(count, (int __user *)arg);		break;	case TCFLSH:		switch (arg) {		case TCIOFLUSH:		case TCOFLUSH:			flush_tx_queue(tty);		}		/* fall through to default */	default:		error = n_tty_ioctl_helper(tty, file, cmd, arg);		break;	}	return error;	}	/* end of n_hdlc_tty_ioctl() */

/** * n_hdlc_tty_poll - TTY callback for poll system call * @tty - pointer to tty instance data * @filp - pointer to open file object for device * @poll_table - wait queue for operations *  * Determine which operations (read/write) will not block and return info * to caller. * Returns a bit mask containing info on which ops will not block. */static unsigned int n_hdlc_tty_poll(struct tty_struct *tty, struct file *filp,				    poll_table *wait){	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);	unsigned int mask = 0;	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_poll() called/n",__FILE__,__LINE__);			if (n_hdlc && n_hdlc->magic == HDLC_MAGIC && tty == n_hdlc->tty) {		/* queue current process into any wait queue that */		/* may awaken in the future (read and write) */		poll_wait(filp, &tty->read_wait, wait);		poll_wait(filp, &tty->write_wait, wait);		/* set bits for operations that won't block */		if (n_hdlc->rx_buf_list.head)			mask |= POLLIN | POLLRDNORM;	/* readable */		if (test_bit(TTY_OTHER_CLOSED, &tty->flags))			mask |= POLLHUP;		if (tty_hung_up_p(filp))			mask |= POLLHUP;		if (!tty_is_writelocked(tty) &&				n_hdlc->tx_free_buf_list.head)			mask |= POLLOUT | POLLWRNORM;	/* writable */	}	return mask;}	/* end of n_hdlc_tty_poll() */

static void flush_rx_queue(struct tty_struct *tty){	struct n_hdlc *n_hdlc = tty2n_hdlc(tty);	struct n_hdlc_buf *buf;	while ((buf = n_hdlc_buf_get(&n_hdlc->rx_buf_list)))		n_hdlc_buf_put(&n_hdlc->rx_free_buf_list, buf);}

/* n_hdlc_tty_receive() *  * 	Called by tty low level driver when receive data is * 	available. Data is interpreted as one HDLC frame. * 	 * Arguments:	 	tty		pointer to tty isntance data * 			data		pointer to received data * 			flags		pointer to flags for data * 			count		count of received data in bytes * 	 * Return Value:	None */static void n_hdlc_tty_receive(struct tty_struct *tty,	const __u8 * data, char *flags, int count){	register struct n_hdlc *n_hdlc = tty2n_hdlc (tty);	register N_HDLC_BUF *buf;	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_receive() called count=%d/n",			__FILE__,__LINE__, count);			/* This can happen if stuff comes in on the backup tty */	if (n_hdlc == 0 || tty != n_hdlc->tty)		return;			/* verify line is using HDLC discipline */	if (n_hdlc->magic != HDLC_MAGIC) {		printk("%s(%d) line not using HDLC discipline/n",			__FILE__,__LINE__);		return;	}		if ( count>maxframe ) {		if (debuglevel >= DEBUG_LEVEL_INFO)				printk("%s(%d) rx count>maxframesize, data discarded/n",			       __FILE__,__LINE__);		return;	}	/* get a free HDLC buffer */		buf = n_hdlc_buf_get(&n_hdlc->rx_free_buf_list);	if (!buf) {		/* no buffers in free list, attempt to allocate another rx buffer */		/* unless the maximum count has been reached */		if (n_hdlc->rx_buf_list.count < MAX_RX_BUF_COUNT)			buf = (N_HDLC_BUF*)kmalloc(N_HDLC_BUF_SIZE,GFP_ATOMIC);	}		if (!buf) {		if (debuglevel >= DEBUG_LEVEL_INFO)				printk("%s(%d) no more rx buffers, data discarded/n",			       __FILE__,__LINE__);		return;	}			/* copy received data to HDLC buffer */	memcpy(buf->buf,data,count);	buf->count=count;	/* add HDLC buffer to list of received frames */	n_hdlc_buf_put(&n_hdlc->rx_buf_list,buf);		/* wake up any blocked reads and perform async signalling */	wake_up_interruptible (&n_hdlc->read_wait);	wake_up_interruptible (&n_hdlc->poll_wait);	if (n_hdlc->tty->fasync != NULL)		kill_fasync (&n_hdlc->tty->fasync, SIGIO, POLL_IN);}	/* end of n_hdlc_tty_receive() */

static void n_hdlc_tty_receive(struct tty_struct *tty, const __u8 *data,			       char *flags, int count){	register struct n_hdlc *n_hdlc = tty2n_hdlc (tty);	register struct n_hdlc_buf *buf;	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_receive() called count=%d/n",			__FILE__,__LINE__, count);				if (!n_hdlc || tty != n_hdlc->tty)		return;				if (n_hdlc->magic != HDLC_MAGIC) {		printk("%s(%d) line not using HDLC discipline/n",			__FILE__,__LINE__);		return;	}		if ( count>maxframe ) {		if (debuglevel >= DEBUG_LEVEL_INFO)				printk("%s(%d) rx count>maxframesize, data discarded/n",			       __FILE__,__LINE__);		return;	}			buf = n_hdlc_buf_get(&n_hdlc->rx_free_buf_list);	if (!buf) {						if (n_hdlc->rx_buf_list.count < MAX_RX_BUF_COUNT)			buf = kmalloc(N_HDLC_BUF_SIZE, GFP_ATOMIC);	}		if (!buf) {		if (debuglevel >= DEBUG_LEVEL_INFO)				printk("%s(%d) no more rx buffers, data discarded/n",			       __FILE__,__LINE__);		return;	}				memcpy(buf->buf,data,count);	buf->count=count;		n_hdlc_buf_put(&n_hdlc->rx_buf_list, buf);			wake_up_interruptible (&tty->read_wait);	if (n_hdlc->tty->fasync != NULL)		kill_fasync (&n_hdlc->tty->fasync, SIGIO, POLL_IN);}	

static int n_hdlc_tty_ioctl(struct tty_struct *tty, struct file *file,			    unsigned int cmd, unsigned long arg){	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);	int error = 0;	int count;	unsigned long flags;		if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_ioctl() called %d/n",			__FILE__,__LINE__,cmd);				if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC)		return -EBADF;	switch (cmd) {	case FIONREAD:						spin_lock_irqsave(&n_hdlc->rx_buf_list.spinlock,flags);		if (n_hdlc->rx_buf_list.head)			count = n_hdlc->rx_buf_list.head->count;		else			count = 0;		spin_unlock_irqrestore(&n_hdlc->rx_buf_list.spinlock,flags);		error = put_user(count, (int __user *)arg);		break;	case TIOCOUTQ:				count = tty_chars_in_buffer(tty);				spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock,flags);		if (n_hdlc->tx_buf_list.head)			count += n_hdlc->tx_buf_list.head->count;		spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock,flags);		error = put_user(count, (int __user *)arg);		break;	case TCFLSH:		switch (arg) {		case TCIOFLUSH:		case TCOFLUSH:			flush_tx_queue(tty);		}			default:		error = n_tty_ioctl_helper(tty, file, cmd, arg);		break;	}	return error;	}	

static void flush_tx_queue(struct tty_struct *tty){	struct n_hdlc *n_hdlc = tty2n_hdlc(tty);	struct n_hdlc_buf *buf;	unsigned long flags;	while ((buf = n_hdlc_buf_get(&n_hdlc->tx_buf_list)))		n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, buf); 	spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock, flags);	if (n_hdlc->tbuf) {		n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, n_hdlc->tbuf);		n_hdlc->tbuf = NULL;	}	spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags);}

/* n_hdlc_tty_ioctl() * *	Process IOCTL system call for the tty device. * * Arguments: * *	tty		pointer to tty instance data *	file		pointer to open file object for device *	cmd		IOCTL command code *	arg		argument for IOCTL call (cmd dependent) * * Return Value:	Command dependent */static int n_hdlc_tty_ioctl (struct tty_struct *tty, struct file * file,               unsigned int cmd, unsigned long arg){	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);	int error = 0;	int count;	unsigned long flags;		if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_ioctl() called %d/n",			__FILE__,__LINE__,cmd);			/* Verify the status of the device */	if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC)		return -EBADF;	switch (cmd) {	case FIONREAD:		/* report count of read data available */		/* in next available frame (if any) */		spin_lock_irqsave(&n_hdlc->rx_buf_list.spinlock,flags);		if (n_hdlc->rx_buf_list.head)			count = n_hdlc->rx_buf_list.head->count;		else			count = 0;		spin_unlock_irqrestore(&n_hdlc->rx_buf_list.spinlock,flags);		PUT_USER (error, count, (int *) arg);		break;	case TIOCOUTQ:		/* get the pending tx byte count in the driver */		count = tty->driver.chars_in_buffer ?				tty->driver.chars_in_buffer(tty) : 0;		/* add size of next output frame in queue */		spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock,flags);		if (n_hdlc->tx_buf_list.head)			count += n_hdlc->tx_buf_list.head->count;		spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock,flags);		PUT_USER (error, count, (int*)arg);		break;	default:		error = n_tty_ioctl (tty, file, cmd, arg);		break;	}	return error;	}	/* end of n_hdlc_tty_ioctl() */

/* n_hdlc_tty_open *  * 	called when line discipline changed to n_hdlc * 	 * Arguments:	tty	pointer to tty info structure * Return Value:	0 if success, otherwise error code */static int n_hdlc_tty_open (struct tty_struct *tty){	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_open() called (major=%u,minor=%u)/n",		__FILE__,__LINE__,		MAJOR(tty->device), MINOR(tty->device));			/* There should not be an existing table for this slot. */	if (n_hdlc) {		printk (KERN_ERR"n_hdlc_tty_open:tty already associated!/n" );		return -EEXIST;	}		n_hdlc = n_hdlc_alloc();	if (!n_hdlc) {		printk (KERN_ERR "n_hdlc_alloc failed/n");		return -ENFILE;	}			tty->disc_data = n_hdlc;	n_hdlc->tty    = tty;		MOD_INC_USE_COUNT;	#if defined(TTY_NO_WRITE_SPLIT)	/* change tty_io write() to not split large writes into 8K chunks */	set_bit(TTY_NO_WRITE_SPLIT,&tty->flags);#endif		/* Flush any pending characters in the driver and discipline. */		if (tty->ldisc.flush_buffer)		tty->ldisc.flush_buffer (tty);	if (tty->driver.flush_buffer)		tty->driver.flush_buffer (tty);			if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_open() success/n",__FILE__,__LINE__);			return 0;	}	/* end of n_tty_hdlc_open() */

/** * n_hdlc_tty_wakeup - Callback for transmit wakeup * @tty	- pointer to associated tty instance data * * Called when low level device driver can accept more send data. */static void n_hdlc_tty_wakeup(struct tty_struct *tty){	struct n_hdlc *n_hdlc = tty2n_hdlc(tty);	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_wakeup() called/n",__FILE__,__LINE__);			if (!n_hdlc)		return;	if (tty != n_hdlc->tty) {		tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);		return;	}	n_hdlc_send_frames (n_hdlc, tty);		}	/* end of n_hdlc_tty_wakeup() */

/** * n_hdlc_tty_open - called when line discipline changed to n_hdlc * @tty - pointer to tty info structure * * Returns 0 if success, otherwise error code */static int n_hdlc_tty_open (struct tty_struct *tty){	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_open() called (device=%s)/n",		__FILE__,__LINE__,		tty->name);			/* There should not be an existing table for this slot. */	if (n_hdlc) {		printk (KERN_ERR"n_hdlc_tty_open:tty already associated!/n" );		return -EEXIST;	}		n_hdlc = n_hdlc_alloc();	if (!n_hdlc) {		printk (KERN_ERR "n_hdlc_alloc failed/n");		return -ENFILE;	}			tty->disc_data = n_hdlc;	n_hdlc->tty    = tty;	tty->receive_room = 65536;	#if defined(TTY_NO_WRITE_SPLIT)	/* change tty_io write() to not split large writes into 8K chunks */	set_bit(TTY_NO_WRITE_SPLIT,&tty->flags);#endif		/* flush receive data from driver */	tty_driver_flush_buffer(tty);			if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_open() success/n",__FILE__,__LINE__);			return 0;	}	/* end of n_tty_hdlc_open() */

static int n_hdlc_tty_open (struct tty_struct *tty){	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_open() called (device=%s)/n",		__FILE__,__LINE__,		tty->name);				if (n_hdlc) {		printk (KERN_ERR"n_hdlc_tty_open:tty already associated!/n" );		return -EEXIST;	}		n_hdlc = n_hdlc_alloc();	if (!n_hdlc) {		printk (KERN_ERR "n_hdlc_alloc failed/n");		return -ENFILE;	}			tty->disc_data = n_hdlc;	n_hdlc->tty    = tty;	tty->receive_room = 65536;	#if defined(TTY_NO_WRITE_SPLIT)		set_bit(TTY_NO_WRITE_SPLIT,&tty->flags);#endif			tty_driver_flush_buffer(tty);			if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_open() success/n",__FILE__,__LINE__);			return 0;	}	

/** * n_hdlc_tty_read - Called to retrieve one frame of data (if available) * @tty - pointer to tty instance data * @file - pointer to open file object * @buf - pointer to returned data buffer * @nr - size of returned data buffer * 	 * Returns the number of bytes returned or error code. */static ssize_t n_hdlc_tty_read(struct tty_struct *tty, struct file *file,			   __u8 __user *buf, size_t nr){	struct n_hdlc *n_hdlc = tty2n_hdlc(tty);	int ret;	struct n_hdlc_buf *rbuf;	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_read() called/n",__FILE__,__LINE__);			/* Validate the pointers */	if (!n_hdlc)		return -EIO;	/* verify user access to buffer */	if (!access_ok(VERIFY_WRITE, buf, nr)) {		printk(KERN_WARNING "%s(%d) n_hdlc_tty_read() can't verify user "		"buffer/n", __FILE__, __LINE__);		return -EFAULT;	}	tty_lock();	for (;;) {		if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {			tty_unlock();			return -EIO;		}		n_hdlc = tty2n_hdlc (tty);		if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC ||			 tty != n_hdlc->tty) {			tty_unlock();			return 0;		}		rbuf = n_hdlc_buf_get(&n_hdlc->rx_buf_list);		if (rbuf)			break;					/* no data */		if (file->f_flags & O_NONBLOCK) {			tty_unlock();			return -EAGAIN;		}					interruptible_sleep_on (&tty->read_wait);		if (signal_pending(current)) {			tty_unlock();			return -EINTR;		}	}			if (rbuf->count > nr)		/* frame too large for caller's buffer (discard frame) */		ret = -EOVERFLOW;	else {		/* Copy the data to the caller's buffer */		if (copy_to_user(buf, rbuf->buf, rbuf->count))			ret = -EFAULT;		else			ret = rbuf->count;	}		/* return HDLC buffer to free list unless the free list */	/* count has exceeded the default value, in which case the */	/* buffer is freed back to the OS to conserve memory */	if (n_hdlc->rx_free_buf_list.count > DEFAULT_RX_BUF_COUNT)		kfree(rbuf);	else			n_hdlc_buf_put(&n_hdlc->rx_free_buf_list,rbuf);	tty_unlock();	return ret;	}	/* end of n_hdlc_tty_read() */

/** * n_hdlc_tty_write - write a single frame of data to device * @tty	- pointer to associated tty device instance data * @file - pointer to file object data * @data - pointer to transmit data (one frame) * @count - size of transmit frame in bytes * 		 * Returns the number of bytes written (or error code). */static ssize_t n_hdlc_tty_write(struct tty_struct *tty, struct file *file,			    const unsigned char *data, size_t count){	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);	int error = 0;	DECLARE_WAITQUEUE(wait, current);	struct n_hdlc_buf *tbuf;	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_write() called count=%Zd/n",			__FILE__,__LINE__,count);			/* Verify pointers */	if (!n_hdlc)		return -EIO;	if (n_hdlc->magic != HDLC_MAGIC)		return -EIO;	/* verify frame size */	if (count > maxframe ) {		if (debuglevel & DEBUG_LEVEL_INFO)			printk (KERN_WARNING				"n_hdlc_tty_write: truncating user packet "				"from %lu to %d/n", (unsigned long) count,				maxframe );		count = maxframe;	}		add_wait_queue(&tty->write_wait, &wait);	for (;;) {		set_current_state(TASK_INTERRUPTIBLE);			tbuf = n_hdlc_buf_get(&n_hdlc->tx_free_buf_list);		if (tbuf)			break;		if (file->f_flags & O_NONBLOCK) {			error = -EAGAIN;			break;		}		schedule();					n_hdlc = tty2n_hdlc (tty);		if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC || 		    tty != n_hdlc->tty) {			printk("n_hdlc_tty_write: %p invalid after wait!/n", n_hdlc);			error = -EIO;			break;		}					if (signal_pending(current)) {			error = -EINTR;			break;		}	}	__set_current_state(TASK_RUNNING);	remove_wait_queue(&tty->write_wait, &wait);	if (!error) {				/* Retrieve the user's buffer */		memcpy(tbuf->buf, data, count);		/* Send the data */		tbuf->count = error = count;		n_hdlc_buf_put(&n_hdlc->tx_buf_list,tbuf);		n_hdlc_send_frames(n_hdlc,tty);	}	return error;	}	/* end of n_hdlc_tty_write() */

/** * n_hdlc_tty_read - Called to retrieve one frame of data (if available) * @tty - pointer to tty instance data * @file - pointer to open file object * @buf - pointer to returned data buffer * @nr - size of returned data buffer * 	 * Returns the number of bytes returned or error code. */static ssize_t n_hdlc_tty_read(struct tty_struct *tty, struct file *file,			   __u8 __user *buf, size_t nr){	struct n_hdlc *n_hdlc = tty2n_hdlc(tty);	int ret = 0;	struct n_hdlc_buf *rbuf;	DECLARE_WAITQUEUE(wait, current);	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_read() called/n",__FILE__,__LINE__);			/* Validate the pointers */	if (!n_hdlc)		return -EIO;	/* verify user access to buffer */	if (!access_ok(VERIFY_WRITE, buf, nr)) {		printk(KERN_WARNING "%s(%d) n_hdlc_tty_read() can't verify user "		"buffer/n", __FILE__, __LINE__);		return -EFAULT;	}	add_wait_queue(&tty->read_wait, &wait);	for (;;) {		if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {			ret = -EIO;			break;		}		if (tty_hung_up_p(file))			break;		set_current_state(TASK_INTERRUPTIBLE);		rbuf = n_hdlc_buf_get(&n_hdlc->rx_buf_list);		if (rbuf) {			if (rbuf->count > nr) {				/* too large for caller's buffer */				ret = -EOVERFLOW;			} else {				if (copy_to_user(buf, rbuf->buf, rbuf->count))					ret = -EFAULT;				else					ret = rbuf->count;			}			if (n_hdlc->rx_free_buf_list.count >			    DEFAULT_RX_BUF_COUNT)				kfree(rbuf);			else				n_hdlc_buf_put(&n_hdlc->rx_free_buf_list, rbuf);			break;		}					/* no data */		if (file->f_flags & O_NONBLOCK) {			ret = -EAGAIN;			break;		}		schedule();		if (signal_pending(current)) {			ret = -EINTR;			break;		}	}	remove_wait_queue(&tty->read_wait, &wait);	__set_current_state(TASK_RUNNING);	return ret;	}	/* end of n_hdlc_tty_read() */

/* n_hdlc_tty_read() *  * 	Called to retreive one frame of data (if available) * 	 * Arguments: *  * 	tty		pointer to tty instance data * 	file		pointer to open file object * 	buf		pointer to returned data buffer * 	nr		size of returned data buffer * 	 * Return Value: *  * 	Number of bytes returned or error code */static rw_ret_t n_hdlc_tty_read (struct tty_struct *tty,	struct file *file, __u8 * buf, rw_count_t nr){	struct n_hdlc *n_hdlc = tty2n_hdlc(tty);	int error;	rw_ret_t ret;	N_HDLC_BUF *rbuf;	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_read() called/n",__FILE__,__LINE__);			/* Validate the pointers */	if (!n_hdlc)		return -EIO;	/* verify user access to buffer */	error = verify_area (VERIFY_WRITE, buf, nr);	if (error != 0) {		printk(KERN_WARNING"%s(%d) n_hdlc_tty_read() can't verify user "		"buffer/n",__FILE__,__LINE__);		return (error);	}	for (;;) {		n_hdlc = tty2n_hdlc (tty);		if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC ||			 tty != n_hdlc->tty)			return 0;		rbuf = n_hdlc_buf_get(&n_hdlc->rx_buf_list);		if (rbuf)			break;					/* no data */		if (file->f_flags & O_NONBLOCK)			return -EAGAIN;					interruptible_sleep_on (&n_hdlc->read_wait);		if (signal_pending(current))			return -EINTR;	}			if (rbuf->count > nr) {		/* frame too large for caller's buffer (discard frame) */		ret = (rw_ret_t)-EOVERFLOW;	} else {		/* Copy the data to the caller's buffer */		COPY_TO_USER(error,buf,rbuf->buf,rbuf->count);		if (error)			ret = (rw_ret_t)error;		else			ret = (rw_ret_t)rbuf->count;	}		/* return HDLC buffer to free list unless the free list */	/* count has exceeded the default value, in which case the */	/* buffer is freed back to the OS to conserve memory */	if (n_hdlc->rx_free_buf_list.count > DEFAULT_RX_BUF_COUNT)		kfree(rbuf);	else			n_hdlc_buf_put(&n_hdlc->rx_free_buf_list,rbuf);		return ret;	}	/* end of n_hdlc_tty_read() */

/* n_hdlc_tty_write() *  * 	write a single frame of data to device * 	 * Arguments:	tty	pointer to associated tty device instance data * 		file	pointer to file object data * 		data	pointer to transmit data (one frame) * 		count	size of transmit frame in bytes * 		 * Return Value:	number of bytes written (or error code) */static rw_ret_t n_hdlc_tty_write (struct tty_struct *tty, struct file *file,	const __u8 * data, rw_count_t count){	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);	int error = 0;	DECLARE_WAITQUEUE(wait, current);	N_HDLC_BUF *tbuf;	if (debuglevel >= DEBUG_LEVEL_INFO)			printk("%s(%d)n_hdlc_tty_write() called count=%d/n",			__FILE__,__LINE__,count);			/* Verify pointers */	if (!n_hdlc)		return -EIO;	if (n_hdlc->magic != HDLC_MAGIC)		return -EIO;	/* verify frame size */	if (count > maxframe ) {		if (debuglevel & DEBUG_LEVEL_INFO)			printk (KERN_WARNING				"n_hdlc_tty_write: truncating user packet "				"from %lu to %d/n", (unsigned long) count,				maxframe );		count = maxframe;	}		add_wait_queue(&n_hdlc->write_wait, &wait);	set_current_state(TASK_INTERRUPTIBLE);		/* Allocate transmit buffer */	/* sleep until transmit buffer available */			while (!(tbuf = n_hdlc_buf_get(&n_hdlc->tx_free_buf_list))) {		schedule();					n_hdlc = tty2n_hdlc (tty);		if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC || 		    tty != n_hdlc->tty) {			printk("n_hdlc_tty_write: %p invalid after wait!/n", n_hdlc);			error = -EIO;			break;		}					if (signal_pending(current)) {			error = -EINTR;			break;		}	}	set_current_state(TASK_RUNNING);	remove_wait_queue(&n_hdlc->write_wait, &wait);	if (!error) {				/* Retrieve the user's buffer */		COPY_FROM_USER (error, tbuf->buf, data, count);		if (error) {			/* return tx buffer to free list */			n_hdlc_buf_put(&n_hdlc->tx_free_buf_list,tbuf);		} else {			/* Send the data */			tbuf->count = error = count;			n_hdlc_buf_put(&n_hdlc->tx_buf_list,tbuf);			n_hdlc_send_frames(n_hdlc,tty);		}	}	return error;	}	/* end of n_hdlc_tty_write() */