[deliverable/linux.git] / drivers / tty / tty_buffer.c

/*
 * Tty buffer allocation management
 */

#include <linux/types.h>
#include <linux/errno.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/wait.h>
#include <linux/bitops.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/ratelimit.h>


#define MIN_TTYB_SIZE	256
#define TTYB_ALIGN_MASK	255

/*
 * Byte threshold to limit memory consumption for flip buffers.
 * The actual memory limit is > 2x this amount.
 */
#define TTYB_MEM_LIMIT	65536


/**
 *	tty_buffer_space_avail	-	return unused buffer space
 *	@port - tty_port owning the flip buffer
 *
 *	Returns the # of bytes which can be written by the driver without
 *	reaching the buffer limit.
 *
 *	Note: this does not guarantee that memory is available to write
 *	the returned # of bytes (use tty_prepare_flip_string_xxx() to
 *	pre-allocate if memory guarantee is required).
 */

int tty_buffer_space_avail(struct tty_port *port)
{
	int space = TTYB_MEM_LIMIT - atomic_read(&port->buf.memory_used);
	return max(space, 0);
}

static void tty_buffer_reset(struct tty_buffer *p, size_t size)
{
	p->used = 0;
	p->size = size;
	p->next = NULL;
	p->commit = 0;
	p->read = 0;
}

/**
 *	tty_buffer_free_all		-	free buffers used by a tty
 *	@tty: tty to free from
 *
 *	Remove all the buffers pending on a tty whether queued with data
 *	or in the free ring. Must be called when the tty is no longer in use
 */

void tty_buffer_free_all(struct tty_port *port)
{
	struct tty_bufhead *buf = &port->buf;
	struct tty_buffer *p, *next;
	struct llist_node *llist;

	while ((p = buf->head) != NULL) {
		buf->head = p->next;
		if (p->size > 0)
			kfree(p);
	}
	llist = llist_del_all(&buf->free);
	llist_for_each_entry_safe(p, next, llist, free)
		kfree(p);

	tty_buffer_reset(&buf->sentinel, 0);
	buf->head = &buf->sentinel;
	buf->tail = &buf->sentinel;

	atomic_set(&buf->memory_used, 0);
}

/**
 *	tty_buffer_alloc	-	allocate a tty buffer
 *	@tty: tty device
 *	@size: desired size (characters)
 *
 *	Allocate a new tty buffer to hold the desired number of characters.
 *	We round our buffers off in 256 character chunks to get better
 *	allocation behaviour.
 *	Return NULL if out of memory or the allocation would exceed the
 *	per device queue
 */

static struct tty_buffer *tty_buffer_alloc(struct tty_port *port, size_t size)
{
	struct llist_node *free;
	struct tty_buffer *p;

	/* Round the buffer size out */
	size = __ALIGN_MASK(size, TTYB_ALIGN_MASK);

	if (size <= MIN_TTYB_SIZE) {
		free = llist_del_first(&port->buf.free);
		if (free) {
			p = llist_entry(free, struct tty_buffer, free);
			goto found;
		}
	}

	/* Should possibly check if this fails for the largest buffer we
	   have queued and recycle that ? */
	if (atomic_read(&port->buf.memory_used) > TTYB_MEM_LIMIT)
		return NULL;
	p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
	if (p == NULL)
		return NULL;

found:
	tty_buffer_reset(p, size);
	atomic_add(size, &port->buf.memory_used);
	return p;
}

/**
 *	tty_buffer_free		-	free a tty buffer
 *	@tty: tty owning the buffer
 *	@b: the buffer to free
 *
 *	Free a tty buffer, or add it to the free list according to our
 *	internal strategy
 */

static void tty_buffer_free(struct tty_port *port, struct tty_buffer *b)
{
	struct tty_bufhead *buf = &port->buf;

	/* Dumb strategy for now - should keep some stats */
	WARN_ON(atomic_sub_return(b->size, &buf->memory_used) < 0);

	if (b->size > MIN_TTYB_SIZE)
		kfree(b);
	else if (b->size > 0)
		llist_add(&b->free, &buf->free);
}

/**
 *	tty_buffer_flush		-	flush full tty buffers
 *	@tty: tty to flush
 *
 *	flush all the buffers containing receive data. If the buffer is
 *	being processed by flush_to_ldisc then we defer the processing
 *	to that function
 *
 *	Locking: takes flush_mutex to ensure single-threaded flip buffer
 *		 'consumer'
 */

void tty_buffer_flush(struct tty_struct *tty)
{
	struct tty_port *port = tty->port;
	struct tty_bufhead *buf = &port->buf;
	struct tty_buffer *next;

	buf->flushpending = 1;

	mutex_lock(&buf->flush_mutex);
	while ((next = buf->head->next) != NULL) {
		tty_buffer_free(port, buf->head);
		buf->head = next;
	}
	buf->head->read = buf->head->commit;
	buf->flushpending = 0;
	mutex_unlock(&buf->flush_mutex);
}

/**
 *	tty_buffer_request_room		-	grow tty buffer if needed
 *	@tty: tty structure
 *	@size: size desired
 *
 *	Make at least size bytes of linear space available for the tty
 *	buffer. If we fail return the size we managed to find.
 */
int tty_buffer_request_room(struct tty_port *port, size_t size)
{
	struct tty_bufhead *buf = &port->buf;
	struct tty_buffer *b, *n;
	int left;

	b = buf->tail;
	left = b->size - b->used;

	if (left < size) {
		/* This is the slow path - looking for new buffers to use */
		if ((n = tty_buffer_alloc(port, size)) != NULL) {
			buf->tail = n;
			b->commit = b->used;
			smp_mb();
			b->next = n;
		} else
			size = left;
	}
	return size;
}
EXPORT_SYMBOL_GPL(tty_buffer_request_room);

/**
 *	tty_insert_flip_string_fixed_flag - Add characters to the tty buffer
 *	@port: tty port
 *	@chars: characters
 *	@flag: flag value for each character
 *	@size: size
 *
 *	Queue a series of bytes to the tty buffering. All the characters
 *	passed are marked with the supplied flag. Returns the number added.
 */

int tty_insert_flip_string_fixed_flag(struct tty_port *port,
		const unsigned char *chars, char flag, size_t size)
{
	int copied = 0;
	do {
		int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
		int space = tty_buffer_request_room(port, goal);
		struct tty_buffer *tb = port->buf.tail;
		if (unlikely(space == 0))
			break;
		memcpy(char_buf_ptr(tb, tb->used), chars, space);
		memset(flag_buf_ptr(tb, tb->used), flag, space);
		tb->used += space;
		copied += space;
		chars += space;
		/* There is a small chance that we need to split the data over
		   several buffers. If this is the case we must loop */
	} while (unlikely(size > copied));
	return copied;
}
EXPORT_SYMBOL(tty_insert_flip_string_fixed_flag);

/**
 *	tty_insert_flip_string_flags	-	Add characters to the tty buffer
 *	@port: tty port
 *	@chars: characters
 *	@flags: flag bytes
 *	@size: size
 *
 *	Queue a series of bytes to the tty buffering. For each character
 *	the flags array indicates the status of the character. Returns the
 *	number added.
 */

int tty_insert_flip_string_flags(struct tty_port *port,
		const unsigned char *chars, const char *flags, size_t size)
{
	int copied = 0;
	do {
		int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
		int space = tty_buffer_request_room(port, goal);
		struct tty_buffer *tb = port->buf.tail;
		if (unlikely(space == 0))
			break;
		memcpy(char_buf_ptr(tb, tb->used), chars, space);
		memcpy(flag_buf_ptr(tb, tb->used), flags, space);
		tb->used += space;
		copied += space;
		chars += space;
		flags += space;
		/* There is a small chance that we need to split the data over
		   several buffers. If this is the case we must loop */
	} while (unlikely(size > copied));
	return copied;
}
EXPORT_SYMBOL(tty_insert_flip_string_flags);

/**
 *	tty_schedule_flip	-	push characters to ldisc
 *	@port: tty port to push from
 *
 *	Takes any pending buffers and transfers their ownership to the
 *	ldisc side of the queue. It then schedules those characters for
 *	processing by the line discipline.
 *	Note that this function can only be used when the low_latency flag
 *	is unset. Otherwise the workqueue won't be flushed.
 */

void tty_schedule_flip(struct tty_port *port)
{
	struct tty_bufhead *buf = &port->buf;
	WARN_ON(port->low_latency);

	buf->tail->commit = buf->tail->used;
	schedule_work(&buf->work);
}
EXPORT_SYMBOL(tty_schedule_flip);

/**
 *	tty_prepare_flip_string		-	make room for characters
 *	@port: tty port
 *	@chars: return pointer for character write area
 *	@size: desired size
 *
 *	Prepare a block of space in the buffer for data. Returns the length
 *	available and buffer pointer to the space which is now allocated and
 *	accounted for as ready for normal characters. This is used for drivers
 *	that need their own block copy routines into the buffer. There is no
 *	guarantee the buffer is a DMA target!
 */

int tty_prepare_flip_string(struct tty_port *port, unsigned char **chars,
		size_t size)
{
	int space = tty_buffer_request_room(port, size);
	if (likely(space)) {
		struct tty_buffer *tb = port->buf.tail;
		*chars = char_buf_ptr(tb, tb->used);
		memset(flag_buf_ptr(tb, tb->used), TTY_NORMAL, space);
		tb->used += space;
	}
	return space;
}
EXPORT_SYMBOL_GPL(tty_prepare_flip_string);

/**
 *	tty_prepare_flip_string_flags	-	make room for characters
 *	@port: tty port
 *	@chars: return pointer for character write area
 *	@flags: return pointer for status flag write area
 *	@size: desired size
 *
 *	Prepare a block of space in the buffer for data. Returns the length
 *	available and buffer pointer to the space which is now allocated and
 *	accounted for as ready for characters. This is used for drivers
 *	that need their own block copy routines into the buffer. There is no
 *	guarantee the buffer is a DMA target!
 */

int tty_prepare_flip_string_flags(struct tty_port *port,
			unsigned char **chars, char **flags, size_t size)
{
	int space = tty_buffer_request_room(port, size);
	if (likely(space)) {
		struct tty_buffer *tb = port->buf.tail;
		*chars = char_buf_ptr(tb, tb->used);
		*flags = flag_buf_ptr(tb, tb->used);
		tb->used += space;
	}
	return space;
}
EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);


static int
receive_buf(struct tty_struct *tty, struct tty_buffer *head, int count)
{
	struct tty_ldisc *disc = tty->ldisc;
	unsigned char *p = char_buf_ptr(head, head->read);
	char	      *f = flag_buf_ptr(head, head->read);

	if (disc->ops->receive_buf2)
		count = disc->ops->receive_buf2(tty, p, f, count);
	else {
		count = min_t(int, count, tty->receive_room);
		if (count)
			disc->ops->receive_buf(tty, p, f, count);
	}
	head->read += count;
	return count;
}

/**
 *	flush_to_ldisc
 *	@work: tty structure passed from work queue.
 *
 *	This routine is called out of the software interrupt to flush data
 *	from the buffer chain to the line discipline.
 *
 *	The receive_buf method is single threaded for each tty instance.
 *
 *	Locking: takes flush_mutex to ensure single-threaded flip buffer
 *		 'consumer'
 */

static void flush_to_ldisc(struct work_struct *work)
{
	struct tty_port *port = container_of(work, struct tty_port, buf.work);
	struct tty_bufhead *buf = &port->buf;
	struct tty_struct *tty;
	struct tty_ldisc *disc;

	tty = port->itty;
	if (tty == NULL)
		return;

	disc = tty_ldisc_ref(tty);
	if (disc == NULL)
		return;

	mutex_lock(&buf->flush_mutex);

	while (1) {
		struct tty_buffer *head = buf->head;
		int count;

		/* Ldisc or user is trying to flush the buffers. */
		if (buf->flushpending)
			break;

		count = head->commit - head->read;
		if (!count) {
			if (head->next == NULL)
				break;
			buf->head = head->next;
			tty_buffer_free(port, head);
			continue;
		}

		count = receive_buf(tty, head, count);
		if (!count)
			break;
	}

	mutex_unlock(&buf->flush_mutex);

	tty_ldisc_deref(disc);
}

/**
 *	tty_flush_to_ldisc
 *	@tty: tty to push
 *
 *	Push the terminal flip buffers to the line discipline.
 *
 *	Must not be called from IRQ context.
 */
void tty_flush_to_ldisc(struct tty_struct *tty)
{
	if (!tty->port->low_latency)
		flush_work(&tty->port->buf.work);
}

/**
 *	tty_flip_buffer_push	-	terminal
 *	@port: tty port to push
 *
 *	Queue a push of the terminal flip buffers to the line discipline. This
 *	function must not be called from IRQ context if port->low_latency is
 *	set.
 *
 *	In the event of the queue being busy for flipping the work will be
 *	held off and retried later.
 */

void tty_flip_buffer_push(struct tty_port *port)
{
	struct tty_bufhead *buf = &port->buf;

	buf->tail->commit = buf->tail->used;

	if (port->low_latency)
		flush_to_ldisc(&buf->work);
	else
		schedule_work(&buf->work);
}
EXPORT_SYMBOL(tty_flip_buffer_push);

/**
 *	tty_buffer_init		-	prepare a tty buffer structure
 *	@tty: tty to initialise
 *
 *	Set up the initial state of the buffer management for a tty device.
 *	Must be called before the other tty buffer functions are used.
 */

void tty_buffer_init(struct tty_port *port)
{
	struct tty_bufhead *buf = &port->buf;

	mutex_init(&buf->flush_mutex);
	tty_buffer_reset(&buf->sentinel, 0);
	buf->head = &buf->sentinel;
	buf->tail = &buf->sentinel;
	init_llist_head(&buf->free);
	atomic_set(&buf->memory_used, 0);
	buf->flushpending = 0;
	INIT_WORK(&buf->work, flush_to_ldisc);
}
Commit	Line	Data
e0495736 AC	1	/*
	2	* Tty buffer allocation management
	3	*/
	4
	5	#include <linux/types.h>
	6	#include <linux/errno.h>
	7	#include <linux/tty.h>
	8	#include <linux/tty_driver.h>
	9	#include <linux/tty_flip.h>
	10	#include <linux/timer.h>
	11	#include <linux/string.h>
	12	#include <linux/slab.h>
	13	#include <linux/sched.h>
	14	#include <linux/init.h>
	15	#include <linux/wait.h>
	16	#include <linux/bitops.h>
	17	#include <linux/delay.h>
	18	#include <linux/module.h>
593fb1ae	19	#include <linux/ratelimit.h>
e0495736	20
1cef50e3 PH	21
	22	#define MIN_TTYB_SIZE 256
	23	#define TTYB_ALIGN_MASK 255
	24
7bfe0b71 PH	25	/*
	26	* Byte threshold to limit memory consumption for flip buffers.
	27	* The actual memory limit is > 2x this amount.
	28	*/
	29	#define TTYB_MEM_LIMIT 65536
	30
	31
	32	/**
	33	* tty_buffer_space_avail - return unused buffer space
	34	* @port - tty_port owning the flip buffer
	35	*
	36	* Returns the # of bytes which can be written by the driver without
	37	* reaching the buffer limit.
	38	*
	39	* Note: this does not guarantee that memory is available to write
	40	* the returned # of bytes (use tty_prepare_flip_string_xxx() to
	41	* pre-allocate if memory guarantee is required).
	42	*/
	43
	44	int tty_buffer_space_avail(struct tty_port *port)
	45	{
	46	int space = TTYB_MEM_LIMIT - atomic_read(&port->buf.memory_used);
	47	return max(space, 0);
	48	}
	49
9dd5139f PH	50	static void tty_buffer_reset(struct tty_buffer *p, size_t size)
	51	{
	52	p->used = 0;
	53	p->size = size;
	54	p->next = NULL;
	55	p->commit = 0;
	56	p->read = 0;
	57	}
	58
e0495736 AC	59	/**
	60	* tty_buffer_free_all - free buffers used by a tty
	61	* @tty: tty to free from
	62	*
	63	* Remove all the buffers pending on a tty whether queued with data
	64	* or in the free ring. Must be called when the tty is no longer in use
e0495736 AC	65	*/
e0495736 AC	66
ecbbfd44	67	void tty_buffer_free_all(struct tty_port *port)
e0495736	68	{
ecbbfd44	69	struct tty_bufhead *buf = &port->buf;
809850b7 PH	70	struct tty_buffer p, next;
809850b7 PH	71	struct llist_node *llist;
5cff39c6	72
2cf7b67e PH	73	while ((p = buf->head) != NULL) {
2cf7b67e PH	74	buf->head = p->next;
7391ee16 PH	75	if (p->size > 0)
7391ee16 PH	76	kfree(p);
e0495736	77	}
809850b7 PH	78	llist = llist_del_all(&buf->free);
809850b7 PH	79	llist_for_each_entry_safe(p, next, llist, free)
2cf7b67e	80	kfree(p);
809850b7	81
7391ee16 PH	82	tty_buffer_reset(&buf->sentinel, 0);
	83	buf->head = &buf->sentinel;
	84	buf->tail = &buf->sentinel;
7bfe0b71 PH	85
7bfe0b71 PH	86	atomic_set(&buf->memory_used, 0);
e0495736 AC	87	}
	88
	89	/**
	90	* tty_buffer_alloc - allocate a tty buffer
	91	* @tty: tty device
	92	* @size: desired size (characters)
	93	*
	94	* Allocate a new tty buffer to hold the desired number of characters.
11b9faa4 PH	95	* We round our buffers off in 256 character chunks to get better
11b9faa4 PH	96	* allocation behaviour.
e0495736 AC	97	* Return NULL if out of memory or the allocation would exceed the
e0495736 AC	98	* per device queue
e0495736 AC	99	*/
e0495736 AC	100
ecbbfd44	101	static struct tty_buffer tty_buffer_alloc(struct tty_port port, size_t size)
e0495736	102	{
809850b7	103	struct llist_node *free;
e0495736 AC	104	struct tty_buffer *p;
e0495736 AC	105
11b9faa4 PH	106	/* Round the buffer size out */
	107	size = __ALIGN_MASK(size, TTYB_ALIGN_MASK);
	108
	109	if (size <= MIN_TTYB_SIZE) {
809850b7 PH	110	free = llist_del_first(&port->buf.free);
	111	if (free) {
	112	p = llist_entry(free, struct tty_buffer, free);
11b9faa4 PH	113	goto found;
	114	}
	115	}
	116
	117	/* Should possibly check if this fails for the largest buffer we
	118	have queued and recycle that ? */
7bfe0b71	119	if (atomic_read(&port->buf.memory_used) > TTYB_MEM_LIMIT)
e0495736 AC	120	return NULL;
	121	p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
	122	if (p == NULL)
	123	return NULL;
9dd5139f	124
11b9faa4	125	found:
9dd5139f	126	tty_buffer_reset(p, size);
7bfe0b71	127	atomic_add(size, &port->buf.memory_used);
e0495736 AC	128	return p;
	129	}
	130
	131	/**
	132	* tty_buffer_free - free a tty buffer
	133	* @tty: tty owning the buffer
	134	* @b: the buffer to free
	135	*
	136	* Free a tty buffer, or add it to the free list according to our
	137	* internal strategy
e0495736 AC	138	*/
e0495736 AC	139
ecbbfd44	140	static void tty_buffer_free(struct tty_port port, struct tty_buffer b)
e0495736	141	{
ecbbfd44	142	struct tty_bufhead *buf = &port->buf;
5cff39c6	143
e0495736	144	/* Dumb strategy for now - should keep some stats */
7bfe0b71	145	WARN_ON(atomic_sub_return(b->size, &buf->memory_used) < 0);
e0495736	146
1cef50e3	147	if (b->size > MIN_TTYB_SIZE)
e0495736	148	kfree(b);
7391ee16	149	else if (b->size > 0)
809850b7	150	llist_add(&b->free, &buf->free);
e0495736 AC	151	}
e0495736 AC	152
e0495736 AC	153	/**
	154	* tty_buffer_flush - flush full tty buffers
	155	* @tty: tty to flush
	156	*
	157	* flush all the buffers containing receive data. If the buffer is
	158	* being processed by flush_to_ldisc then we defer the processing
	159	* to that function
	160	*
e9975fde PH	161	* Locking: takes flush_mutex to ensure single-threaded flip buffer
e9975fde PH	162	* 'consumer'
e0495736 AC	163	*/
	164
	165	void tty_buffer_flush(struct tty_struct *tty)
	166	{
2fc20661	167	struct tty_port *port = tty->port;
ecbbfd44	168	struct tty_bufhead *buf = &port->buf;
47aa658a	169	struct tty_buffer *next;
e0495736	170
0f56bd2f	171	buf->flushpending = 1;
e9975fde	172
d7a68be4	173	mutex_lock(&buf->flush_mutex);
47aa658a PH	174	while ((next = buf->head->next) != NULL) {
	175	tty_buffer_free(port, buf->head);
	176	buf->head = next;
	177	}
	178	buf->head->read = buf->head->commit;
0f56bd2f	179	buf->flushpending = 0;
e9975fde	180	mutex_unlock(&buf->flush_mutex);
e0495736 AC	181	}
e0495736 AC	182
e0495736	183	/**
64325a3b	184	* tty_buffer_request_room - grow tty buffer if needed
e0495736 AC	185	* @tty: tty structure
	186	* @size: size desired
	187	*
	188	* Make at least size bytes of linear space available for the tty
	189	* buffer. If we fail return the size we managed to find.
e0495736	190	*/
64325a3b	191	int tty_buffer_request_room(struct tty_port *port, size_t size)
e0495736	192	{
ecbbfd44	193	struct tty_bufhead *buf = &port->buf;
e0495736 AC	194	struct tty_buffer b, n;
e0495736 AC	195	int left;
e8437d7e	196
5cff39c6	197	b = buf->tail;
7391ee16	198	left = b->size - b->used;
e0495736 AC	199
	200	if (left < size) {
	201	/* This is the slow path - looking for new buffers to use */
11b9faa4	202	if ((n = tty_buffer_alloc(port, size)) != NULL) {
5cff39c6	203	buf->tail = n;
e8437d7e PH	204	b->commit = b->used;
	205	smp_mb();
	206	b->next = n;
e0495736 AC	207	} else
	208	size = left;
	209	}
e0495736 AC	210	return size;
	211	}
	212	EXPORT_SYMBOL_GPL(tty_buffer_request_room);
	213
	214	/**
2832fc11	215	* tty_insert_flip_string_fixed_flag - Add characters to the tty buffer
2f693357	216	* @port: tty port
e0495736	217	* @chars: characters
2832fc11	218	* @flag: flag value for each character
e0495736 AC	219	* @size: size
	220	*
	221	* Queue a series of bytes to the tty buffering. All the characters
ccc5ca8d	222	* passed are marked with the supplied flag. Returns the number added.
e0495736 AC	223	*/
e0495736 AC	224
2f693357	225	int tty_insert_flip_string_fixed_flag(struct tty_port *port,
2832fc11	226	const unsigned char *chars, char flag, size_t size)
e0495736 AC	227	{
	228	int copied = 0;
	229	do {
d4bee0a6	230	int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
64325a3b IZ	231	int space = tty_buffer_request_room(port, goal);
64325a3b IZ	232	struct tty_buffer *tb = port->buf.tail;
7391ee16	233	if (unlikely(space == 0))
e0495736	234	break;
1fc359fc PH	235	memcpy(char_buf_ptr(tb, tb->used), chars, space);
1fc359fc PH	236	memset(flag_buf_ptr(tb, tb->used), flag, space);
e0495736 AC	237	tb->used += space;
	238	copied += space;
	239	chars += space;
	240	/* There is a small chance that we need to split the data over
	241	several buffers. If this is the case we must loop */
	242	} while (unlikely(size > copied));
	243	return copied;
	244	}
2832fc11	245	EXPORT_SYMBOL(tty_insert_flip_string_fixed_flag);
e0495736 AC	246
	247	/**
	248	* tty_insert_flip_string_flags - Add characters to the tty buffer
2f693357	249	* @port: tty port
e0495736 AC	250	* @chars: characters
	251	* @flags: flag bytes
	252	* @size: size
	253	*
	254	* Queue a series of bytes to the tty buffering. For each character
	255	* the flags array indicates the status of the character. Returns the
	256	* number added.
e0495736 AC	257	*/
e0495736 AC	258
2f693357	259	int tty_insert_flip_string_flags(struct tty_port *port,
e0495736 AC	260	const unsigned char chars, const char flags, size_t size)
	261	{
	262	int copied = 0;
	263	do {
d4bee0a6	264	int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
64325a3b IZ	265	int space = tty_buffer_request_room(port, goal);
64325a3b IZ	266	struct tty_buffer *tb = port->buf.tail;
7391ee16	267	if (unlikely(space == 0))
e0495736	268	break;
1fc359fc PH	269	memcpy(char_buf_ptr(tb, tb->used), chars, space);
1fc359fc PH	270	memcpy(flag_buf_ptr(tb, tb->used), flags, space);
e0495736 AC	271	tb->used += space;
	272	copied += space;
	273	chars += space;
	274	flags += space;
	275	/* There is a small chance that we need to split the data over
	276	several buffers. If this is the case we must loop */
	277	} while (unlikely(size > copied));
	278	return copied;
	279	}
	280	EXPORT_SYMBOL(tty_insert_flip_string_flags);
	281
	282	/**
	283	* tty_schedule_flip - push characters to ldisc
6732c8bb	284	* @port: tty port to push from
e0495736 AC	285	*
	286	* Takes any pending buffers and transfers their ownership to the
	287	* ldisc side of the queue. It then schedules those characters for
	288	* processing by the line discipline.
cee4ad1e IS	289	* Note that this function can only be used when the low_latency flag
cee4ad1e IS	290	* is unset. Otherwise the workqueue won't be flushed.
e0495736 AC	291	*/
e0495736 AC	292
6732c8bb	293	void tty_schedule_flip(struct tty_port *port)
e0495736	294	{
6732c8bb	295	struct tty_bufhead *buf = &port->buf;
6732c8bb	296	WARN_ON(port->low_latency);
5cff39c6	297
7391ee16	298	buf->tail->commit = buf->tail->used;
5cff39c6	299	schedule_work(&buf->work);
e0495736 AC	300	}
	301	EXPORT_SYMBOL(tty_schedule_flip);
	302
	303	/**
	304	* tty_prepare_flip_string - make room for characters
2f693357	305	* @port: tty port
e0495736 AC	306	* @chars: return pointer for character write area
	307	* @size: desired size
	308	*
	309	* Prepare a block of space in the buffer for data. Returns the length
	310	* available and buffer pointer to the space which is now allocated and
	311	* accounted for as ready for normal characters. This is used for drivers
	312	* that need their own block copy routines into the buffer. There is no
	313	* guarantee the buffer is a DMA target!
e0495736 AC	314	*/
e0495736 AC	315
2f693357	316	int tty_prepare_flip_string(struct tty_port port, unsigned char *chars,
ecbbfd44	317	size_t size)
e0495736	318	{
64325a3b	319	int space = tty_buffer_request_room(port, size);
e0495736	320	if (likely(space)) {
64325a3b	321	struct tty_buffer *tb = port->buf.tail;
1fc359fc PH	322	*chars = char_buf_ptr(tb, tb->used);
1fc359fc PH	323	memset(flag_buf_ptr(tb, tb->used), TTY_NORMAL, space);
e0495736 AC	324	tb->used += space;
	325	}
	326	return space;
	327	}
	328	EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
	329
	330	/**
	331	* tty_prepare_flip_string_flags - make room for characters
2f693357	332	* @port: tty port
e0495736 AC	333	* @chars: return pointer for character write area
	334	* @flags: return pointer for status flag write area
	335	* @size: desired size
	336	*
	337	* Prepare a block of space in the buffer for data. Returns the length
	338	* available and buffer pointer to the space which is now allocated and
	339	* accounted for as ready for characters. This is used for drivers
	340	* that need their own block copy routines into the buffer. There is no
	341	* guarantee the buffer is a DMA target!
e0495736 AC	342	*/
e0495736 AC	343
2f693357	344	int tty_prepare_flip_string_flags(struct tty_port *port,
e0495736 AC	345	unsigned char chars, char flags, size_t size)
e0495736 AC	346	{
64325a3b	347	int space = tty_buffer_request_room(port, size);
e0495736	348	if (likely(space)) {
64325a3b	349	struct tty_buffer *tb = port->buf.tail;
1fc359fc PH	350	*chars = char_buf_ptr(tb, tb->used);
1fc359fc PH	351	*flags = flag_buf_ptr(tb, tb->used);
e0495736 AC	352	tb->used += space;
	353	}
	354	return space;
	355	}
	356	EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
	357
	358
da261e7f PH	359	static int
	360	receive_buf(struct tty_struct tty, struct tty_buffer head, int count)
	361	{
	362	struct tty_ldisc *disc = tty->ldisc;
1fc359fc PH	363	unsigned char *p = char_buf_ptr(head, head->read);
1fc359fc PH	364	char *f = flag_buf_ptr(head, head->read);
da261e7f	365
24a89d1c PH	366	if (disc->ops->receive_buf2)
	367	count = disc->ops->receive_buf2(tty, p, f, count);
	368	else {
	369	count = min_t(int, count, tty->receive_room);
	370	if (count)
	371	disc->ops->receive_buf(tty, p, f, count);
	372	}
da261e7f PH	373	head->read += count;
	374	return count;
	375	}
e0495736 AC	376
	377	/**
	378	* flush_to_ldisc
	379	* @work: tty structure passed from work queue.
	380	*
	381	* This routine is called out of the software interrupt to flush data
	382	* from the buffer chain to the line discipline.
	383	*
e9975fde PH	384	* The receive_buf method is single threaded for each tty instance.
	385	*
	386	* Locking: takes flush_mutex to ensure single-threaded flip buffer
	387	* 'consumer'
e0495736 AC	388	*/
	389
	390	static void flush_to_ldisc(struct work_struct *work)
	391	{
ecbbfd44 JS	392	struct tty_port *port = container_of(work, struct tty_port, buf.work);
	393	struct tty_bufhead *buf = &port->buf;
	394	struct tty_struct *tty;
e0495736	395	struct tty_ldisc *disc;
e0495736	396
ecbbfd44	397	tty = port->itty;
34dcfb84	398	if (tty == NULL)
ecbbfd44 JS	399	return;
ecbbfd44 JS	400
e0495736	401	disc = tty_ldisc_ref(tty);
36697529	402	if (disc == NULL)
e0495736 AC	403	return;
e0495736 AC	404
e9975fde	405	mutex_lock(&buf->flush_mutex);
45242006	406
d7a68be4 PH	407	while (1) {
	408	struct tty_buffer *head = buf->head;
	409	int count;
	410
	411	/* Ldisc or user is trying to flush the buffers. */
0f56bd2f	412	if (buf->flushpending)
d7a68be4 PH	413	break;
	414
	415	count = head->commit - head->read;
	416	if (!count) {
	417	if (head->next == NULL)
da261e7f	418	break;
d7a68be4 PH	419	buf->head = head->next;
	420	tty_buffer_free(port, head);
	421	continue;
e0495736	422	}
d7a68be4 PH	423
	424	count = receive_buf(tty, head, count);
	425	if (!count)
	426	break;
e0495736	427	}
45242006	428
e9975fde	429	mutex_unlock(&buf->flush_mutex);
e0495736 AC	430
	431	tty_ldisc_deref(disc);
	432	}
	433
e043e42b OH	434	/**
	435	* tty_flush_to_ldisc
	436	* @tty: tty to push
	437	*
	438	* Push the terminal flip buffers to the line discipline.
	439	*
	440	* Must not be called from IRQ context.
	441	*/
	442	void tty_flush_to_ldisc(struct tty_struct *tty)
	443	{
d6c53c0e	444	if (!tty->port->low_latency)
ecbbfd44	445	flush_work(&tty->port->buf.work);
e043e42b OH	446	}
e043e42b OH	447
e0495736 AC	448	/**
e0495736 AC	449	* tty_flip_buffer_push - terminal
2e124b4a	450	* @port: tty port to push
e0495736 AC	451	*
e0495736 AC	452	* Queue a push of the terminal flip buffers to the line discipline. This
d6c53c0e JS	453	* function must not be called from IRQ context if port->low_latency is
d6c53c0e JS	454	* set.
e0495736 AC	455	*
	456	* In the event of the queue being busy for flipping the work will be
	457	* held off and retried later.
e0495736 AC	458	*/
e0495736 AC	459
2e124b4a	460	void tty_flip_buffer_push(struct tty_port *port)
e0495736	461	{
2e124b4a	462	struct tty_bufhead *buf = &port->buf;
5cff39c6	463
7391ee16	464	buf->tail->commit = buf->tail->used;
e0495736	465
2e124b4a	466	if (port->low_latency)
5cff39c6	467	flush_to_ldisc(&buf->work);
e0495736	468	else
5cff39c6	469	schedule_work(&buf->work);
e0495736 AC	470	}
	471	EXPORT_SYMBOL(tty_flip_buffer_push);
	472
	473	/**
	474	* tty_buffer_init - prepare a tty buffer structure
	475	* @tty: tty to initialise
	476	*
	477	* Set up the initial state of the buffer management for a tty device.
	478	* Must be called before the other tty buffer functions are used.
e0495736 AC	479	*/
e0495736 AC	480
ecbbfd44	481	void tty_buffer_init(struct tty_port *port)
e0495736	482	{
ecbbfd44	483	struct tty_bufhead *buf = &port->buf;
5cff39c6	484
e9975fde	485	mutex_init(&buf->flush_mutex);
7391ee16 PH	486	tty_buffer_reset(&buf->sentinel, 0);
	487	buf->head = &buf->sentinel;
	488	buf->tail = &buf->sentinel;
809850b7	489	init_llist_head(&buf->free);
7bfe0b71	490	atomic_set(&buf->memory_used, 0);
0f56bd2f	491	buf->flushpending = 0;
5cff39c6	492	INIT_WORK(&buf->work, flush_to_ldisc);
e0495736 AC	493	}
e0495736 AC	494