[linux-block.git] / drivers / media / usb / pvrusb2 / pvrusb2-ioread.c

/*
 *
 *
 *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include "pvrusb2-ioread.h"
#include "pvrusb2-debug.h"
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <linux/uaccess.h>

#define BUFFER_COUNT 32
#define BUFFER_SIZE PAGE_ALIGN(0x4000)

struct pvr2_ioread {
	struct pvr2_stream *stream;
	char *buffer_storage[BUFFER_COUNT];
	char *sync_key_ptr;
	unsigned int sync_key_len;
	unsigned int sync_buf_offs;
	unsigned int sync_state;
	unsigned int sync_trashed_count;
	int enabled;         // Streaming is on
	int spigot_open;     // OK to pass data to client
	int stream_running;  // Passing data to client now

	/* State relevant to current buffer being read */
	struct pvr2_buffer *c_buf;
	char *c_data_ptr;
	unsigned int c_data_len;
	unsigned int c_data_offs;
	struct mutex mutex;
};

static int pvr2_ioread_init(struct pvr2_ioread *cp)
{
	unsigned int idx;

	cp->stream = NULL;
	mutex_init(&cp->mutex);

	for (idx = 0; idx < BUFFER_COUNT; idx++) {
		cp->buffer_storage[idx] = kmalloc(BUFFER_SIZE,GFP_KERNEL);
		if (!(cp->buffer_storage[idx])) break;
	}

	if (idx < BUFFER_COUNT) {
		// An allocation appears to have failed
		for (idx = 0; idx < BUFFER_COUNT; idx++) {
			if (!(cp->buffer_storage[idx])) continue;
			kfree(cp->buffer_storage[idx]);
		}
		return -ENOMEM;
	}
	return 0;
}

static void pvr2_ioread_done(struct pvr2_ioread *cp)
{
	unsigned int idx;

	pvr2_ioread_setup(cp,NULL);
	for (idx = 0; idx < BUFFER_COUNT; idx++) {
		if (!(cp->buffer_storage[idx])) continue;
		kfree(cp->buffer_storage[idx]);
	}
}

struct pvr2_ioread *pvr2_ioread_create(void)
{
	struct pvr2_ioread *cp;
	cp = kzalloc(sizeof(*cp),GFP_KERNEL);
	if (!cp) return NULL;
	pvr2_trace(PVR2_TRACE_STRUCT,"pvr2_ioread_create id=%p",cp);
	if (pvr2_ioread_init(cp) < 0) {
		kfree(cp);
		return NULL;
	}
	return cp;
}

void pvr2_ioread_destroy(struct pvr2_ioread *cp)
{
	if (!cp) return;
	pvr2_ioread_done(cp);
	pvr2_trace(PVR2_TRACE_STRUCT,"pvr2_ioread_destroy id=%p",cp);
	if (cp->sync_key_ptr) {
		kfree(cp->sync_key_ptr);
		cp->sync_key_ptr = NULL;
	}
	kfree(cp);
}

void pvr2_ioread_set_sync_key(struct pvr2_ioread *cp,
			      const char *sync_key_ptr,
			      unsigned int sync_key_len)
{
	if (!cp) return;

	if (!sync_key_ptr) sync_key_len = 0;
	if ((sync_key_len == cp->sync_key_len) &&
	    ((!sync_key_len) ||
	     (!memcmp(sync_key_ptr,cp->sync_key_ptr,sync_key_len)))) return;

	if (sync_key_len != cp->sync_key_len) {
		if (cp->sync_key_ptr) {
			kfree(cp->sync_key_ptr);
			cp->sync_key_ptr = NULL;
		}
		cp->sync_key_len = 0;
		if (sync_key_len) {
			cp->sync_key_ptr = kmalloc(sync_key_len,GFP_KERNEL);
			if (cp->sync_key_ptr) {
				cp->sync_key_len = sync_key_len;
			}
		}
	}
	if (!cp->sync_key_len) return;
	memcpy(cp->sync_key_ptr,sync_key_ptr,cp->sync_key_len);
}

static void pvr2_ioread_stop(struct pvr2_ioread *cp)
{
	if (!(cp->enabled)) return;
	pvr2_trace(PVR2_TRACE_START_STOP,
		   "/*---TRACE_READ---*/ pvr2_ioread_stop id=%p",cp);
	pvr2_stream_kill(cp->stream);
	cp->c_buf = NULL;
	cp->c_data_ptr = NULL;
	cp->c_data_len = 0;
	cp->c_data_offs = 0;
	cp->enabled = 0;
	cp->stream_running = 0;
	cp->spigot_open = 0;
	if (cp->sync_state) {
		pvr2_trace(PVR2_TRACE_DATA_FLOW,
			   "/*---TRACE_READ---*/ sync_state <== 0");
		cp->sync_state = 0;
	}
}

static int pvr2_ioread_start(struct pvr2_ioread *cp)
{
	int stat;
	struct pvr2_buffer *bp;
	if (cp->enabled) return 0;
	if (!(cp->stream)) return 0;
	pvr2_trace(PVR2_TRACE_START_STOP,
		   "/*---TRACE_READ---*/ pvr2_ioread_start id=%p",cp);
	while ((bp = pvr2_stream_get_idle_buffer(cp->stream)) != NULL) {
		stat = pvr2_buffer_queue(bp);
		if (stat < 0) {
			pvr2_trace(PVR2_TRACE_DATA_FLOW,
				   "/*---TRACE_READ---*/ pvr2_ioread_start id=%p error=%d",
				   cp,stat);
			pvr2_ioread_stop(cp);
			return stat;
		}
	}
	cp->enabled = !0;
	cp->c_buf = NULL;
	cp->c_data_ptr = NULL;
	cp->c_data_len = 0;
	cp->c_data_offs = 0;
	cp->stream_running = 0;
	if (cp->sync_key_len) {
		pvr2_trace(PVR2_TRACE_DATA_FLOW,
			   "/*---TRACE_READ---*/ sync_state <== 1");
		cp->sync_state = 1;
		cp->sync_trashed_count = 0;
		cp->sync_buf_offs = 0;
	}
	cp->spigot_open = 0;
	return 0;
}

struct pvr2_stream *pvr2_ioread_get_stream(struct pvr2_ioread *cp)
{
	return cp->stream;
}

int pvr2_ioread_setup(struct pvr2_ioread *cp,struct pvr2_stream *sp)
{
	int ret;
	unsigned int idx;
	struct pvr2_buffer *bp;

	mutex_lock(&cp->mutex);
	do {
		if (cp->stream) {
			pvr2_trace(PVR2_TRACE_START_STOP,
				   "/*---TRACE_READ---*/ pvr2_ioread_setup (tear-down) id=%p",
				   cp);
			pvr2_ioread_stop(cp);
			pvr2_stream_kill(cp->stream);
			if (pvr2_stream_get_buffer_count(cp->stream)) {
				pvr2_stream_set_buffer_count(cp->stream,0);
			}
			cp->stream = NULL;
		}
		if (sp) {
			pvr2_trace(PVR2_TRACE_START_STOP,
				   "/*---TRACE_READ---*/ pvr2_ioread_setup (setup) id=%p",
				   cp);
			pvr2_stream_kill(sp);
			ret = pvr2_stream_set_buffer_count(sp,BUFFER_COUNT);
			if (ret < 0) {
				mutex_unlock(&cp->mutex);
				return ret;
			}
			for (idx = 0; idx < BUFFER_COUNT; idx++) {
				bp = pvr2_stream_get_buffer(sp,idx);
				pvr2_buffer_set_buffer(bp,
						       cp->buffer_storage[idx],
						       BUFFER_SIZE);
			}
			cp->stream = sp;
		}
	} while (0);
	mutex_unlock(&cp->mutex);

	return 0;
}

int pvr2_ioread_set_enabled(struct pvr2_ioread *cp,int fl)
{
	int ret = 0;
	if ((!fl) == (!(cp->enabled))) return ret;

	mutex_lock(&cp->mutex);
	do {
		if (fl) {
			ret = pvr2_ioread_start(cp);
		} else {
			pvr2_ioread_stop(cp);
		}
	} while (0);
	mutex_unlock(&cp->mutex);
	return ret;
}

static int pvr2_ioread_get_buffer(struct pvr2_ioread *cp)
{
	int stat;

	while (cp->c_data_len <= cp->c_data_offs) {
		if (cp->c_buf) {
			// Flush out current buffer first.
			stat = pvr2_buffer_queue(cp->c_buf);
			if (stat < 0) {
				// Streaming error...
				pvr2_trace(PVR2_TRACE_DATA_FLOW,
					   "/*---TRACE_READ---*/ pvr2_ioread_read id=%p queue_error=%d",
					   cp,stat);
				pvr2_ioread_stop(cp);
				return 0;
			}
			cp->c_buf = NULL;
			cp->c_data_ptr = NULL;
			cp->c_data_len = 0;
			cp->c_data_offs = 0;
		}
		// Now get a freshly filled buffer.
		cp->c_buf = pvr2_stream_get_ready_buffer(cp->stream);
		if (!cp->c_buf) break; // Nothing ready; done.
		cp->c_data_len = pvr2_buffer_get_count(cp->c_buf);
		if (!cp->c_data_len) {
			// Nothing transferred.  Was there an error?
			stat = pvr2_buffer_get_status(cp->c_buf);
			if (stat < 0) {
				// Streaming error...
				pvr2_trace(PVR2_TRACE_DATA_FLOW,
					   "/*---TRACE_READ---*/ pvr2_ioread_read id=%p buffer_error=%d",
					   cp,stat);
				pvr2_ioread_stop(cp);
				// Give up.
				return 0;
			}
			// Start over...
			continue;
		}
		cp->c_data_offs = 0;
		cp->c_data_ptr = cp->buffer_storage[
			pvr2_buffer_get_id(cp->c_buf)];
	}
	return !0;
}

static void pvr2_ioread_filter(struct pvr2_ioread *cp)
{
	unsigned int idx;
	if (!cp->enabled) return;
	if (cp->sync_state != 1) return;

	// Search the stream for our synchronization key.  This is made
	// complicated by the fact that in order to be honest with
	// ourselves here we must search across buffer boundaries...
	mutex_lock(&cp->mutex);
	while (1) {
		// Ensure we have a buffer
		if (!pvr2_ioread_get_buffer(cp)) break;
		if (!cp->c_data_len) break;

		// Now walk the buffer contents until we match the key or
		// run out of buffer data.
		for (idx = cp->c_data_offs; idx < cp->c_data_len; idx++) {
			if (cp->sync_buf_offs >= cp->sync_key_len) break;
			if (cp->c_data_ptr[idx] ==
			    cp->sync_key_ptr[cp->sync_buf_offs]) {
				// Found the next key byte
				(cp->sync_buf_offs)++;
			} else {
				// Whoops, mismatched.  Start key over...
				cp->sync_buf_offs = 0;
			}
		}

		// Consume what we've walked through
		cp->c_data_offs += idx;
		cp->sync_trashed_count += idx;

		// If we've found the key, then update state and get out.
		if (cp->sync_buf_offs >= cp->sync_key_len) {
			cp->sync_trashed_count -= cp->sync_key_len;
			pvr2_trace(PVR2_TRACE_DATA_FLOW,
				   "/*---TRACE_READ---*/ sync_state <== 2 (skipped %u bytes)",
				   cp->sync_trashed_count);
			cp->sync_state = 2;
			cp->sync_buf_offs = 0;
			break;
		}

		if (cp->c_data_offs < cp->c_data_len) {
			// Sanity check - should NEVER get here
			pvr2_trace(PVR2_TRACE_ERROR_LEGS,
				   "ERROR: pvr2_ioread filter sync problem len=%u offs=%u",
				   cp->c_data_len,cp->c_data_offs);
			// Get out so we don't get stuck in an infinite
			// loop.
			break;
		}

		continue; // (for clarity)
	}
	mutex_unlock(&cp->mutex);
}

int pvr2_ioread_avail(struct pvr2_ioread *cp)
{
	int ret;
	if (!(cp->enabled)) {
		// Stream is not enabled; so this is an I/O error
		return -EIO;
	}

	if (cp->sync_state == 1) {
		pvr2_ioread_filter(cp);
		if (cp->sync_state == 1) return -EAGAIN;
	}

	ret = 0;
	if (cp->stream_running) {
		if (!pvr2_stream_get_ready_count(cp->stream)) {
			// No data available at all right now.
			ret = -EAGAIN;
		}
	} else {
		if (pvr2_stream_get_ready_count(cp->stream) < BUFFER_COUNT/2) {
			// Haven't buffered up enough yet; try again later
			ret = -EAGAIN;
		}
	}

	if ((!(cp->spigot_open)) != (!(ret == 0))) {
		cp->spigot_open = (ret == 0);
		pvr2_trace(PVR2_TRACE_DATA_FLOW,
			   "/*---TRACE_READ---*/ data is %s",
			   cp->spigot_open ? "available" : "pending");
	}

	return ret;
}

int pvr2_ioread_read(struct pvr2_ioread *cp,void __user *buf,unsigned int cnt)
{
	unsigned int copied_cnt;
	unsigned int bcnt;
	const char *src;
	int stat;
	int ret = 0;
	unsigned int req_cnt = cnt;

	if (!cnt) {
		pvr2_trace(PVR2_TRACE_TRAP,
			   "/*---TRACE_READ---*/ pvr2_ioread_read id=%p ZERO Request? Returning zero.",
cp);
		return 0;
	}

	stat = pvr2_ioread_avail(cp);
	if (stat < 0) return stat;

	cp->stream_running = !0;

	mutex_lock(&cp->mutex);
	do {

		// Suck data out of the buffers and copy to the user
		copied_cnt = 0;
		if (!buf) cnt = 0;
		while (1) {
			if (!pvr2_ioread_get_buffer(cp)) {
				ret = -EIO;
				break;
			}

			if (!cnt) break;

			if (cp->sync_state == 2) {
				// We're repeating the sync key data into
				// the stream.
				src = cp->sync_key_ptr + cp->sync_buf_offs;
				bcnt = cp->sync_key_len - cp->sync_buf_offs;
			} else {
				// Normal buffer copy
				src = cp->c_data_ptr + cp->c_data_offs;
				bcnt = cp->c_data_len - cp->c_data_offs;
			}

			if (!bcnt) break;

			// Don't run past user's buffer
			if (bcnt > cnt) bcnt = cnt;

			if (copy_to_user(buf,src,bcnt)) {
				// User supplied a bad pointer?
				// Give up - this *will* cause data
				// to be lost.
				ret = -EFAULT;
				break;
			}
			cnt -= bcnt;
			buf += bcnt;
			copied_cnt += bcnt;

			if (cp->sync_state == 2) {
				// Update offset inside sync key that we're
				// repeating back out.
				cp->sync_buf_offs += bcnt;
				if (cp->sync_buf_offs >= cp->sync_key_len) {
					// Consumed entire key; switch mode
					// to normal.
					pvr2_trace(PVR2_TRACE_DATA_FLOW,
						   "/*---TRACE_READ---*/ sync_state <== 0");
					cp->sync_state = 0;
				}
			} else {
				// Update buffer offset.
				cp->c_data_offs += bcnt;
			}
		}

	} while (0);
	mutex_unlock(&cp->mutex);

	if (!ret) {
		if (copied_cnt) {
			// If anything was copied, return that count
			ret = copied_cnt;
		} else {
			// Nothing copied; suggest to caller that another
			// attempt should be tried again later
			ret = -EAGAIN;
		}
	}

	pvr2_trace(PVR2_TRACE_DATA_FLOW,
		   "/*---TRACE_READ---*/ pvr2_ioread_read id=%p request=%d result=%d",
		   cp,req_cnt,ret);
	return ret;
}
Commit	Line	Data
d855497e MI	1	/*
d855497e MI	2	*
d855497e MI	3	*
	4	* Copyright (C) 2005 Mike Isely <isely@pobox.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*
	19	*/
	20
	21	#include "pvrusb2-ioread.h"
	22	#include "pvrusb2-debug.h"
	23	#include <linux/errno.h>
	24	#include <linux/string.h>
27ac792c	25	#include <linux/mm.h>
d855497e MI	26	#include <linux/slab.h>
d855497e MI	27	#include <linux/mutex.h>
7c0f6ba6	28	#include <linux/uaccess.h>
d855497e MI	29
	30	#define BUFFER_COUNT 32
	31	#define BUFFER_SIZE PAGE_ALIGN(0x4000)
	32
	33	struct pvr2_ioread {
	34	struct pvr2_stream *stream;
	35	char *buffer_storage[BUFFER_COUNT];
	36	char *sync_key_ptr;
	37	unsigned int sync_key_len;
	38	unsigned int sync_buf_offs;
	39	unsigned int sync_state;
	40	unsigned int sync_trashed_count;
	41	int enabled; // Streaming is on
	42	int spigot_open; // OK to pass data to client
	43	int stream_running; // Passing data to client now
	44
	45	/* State relevant to current buffer being read */
	46	struct pvr2_buffer *c_buf;
	47	char *c_data_ptr;
	48	unsigned int c_data_len;
	49	unsigned int c_data_offs;
	50	struct mutex mutex;
	51	};
	52
	53	static int pvr2_ioread_init(struct pvr2_ioread *cp)
	54	{
	55	unsigned int idx;
	56
a0fd1cb1	57	cp->stream = NULL;
d855497e MI	58	mutex_init(&cp->mutex);
	59
	60	for (idx = 0; idx < BUFFER_COUNT; idx++) {
	61	cp->buffer_storage[idx] = kmalloc(BUFFER_SIZE,GFP_KERNEL);
	62	if (!(cp->buffer_storage[idx])) break;
	63	}
	64
	65	if (idx < BUFFER_COUNT) {
	66	// An allocation appears to have failed
	67	for (idx = 0; idx < BUFFER_COUNT; idx++) {
	68	if (!(cp->buffer_storage[idx])) continue;
	69	kfree(cp->buffer_storage[idx]);
	70	}
	71	return -ENOMEM;
	72	}
	73	return 0;
	74	}
	75
	76	static void pvr2_ioread_done(struct pvr2_ioread *cp)
	77	{
	78	unsigned int idx;
	79
a0fd1cb1	80	pvr2_ioread_setup(cp,NULL);
d855497e MI	81	for (idx = 0; idx < BUFFER_COUNT; idx++) {
	82	if (!(cp->buffer_storage[idx])) continue;
	83	kfree(cp->buffer_storage[idx]);
	84	}
	85	}
	86
	87	struct pvr2_ioread *pvr2_ioread_create(void)
	88	{
	89	struct pvr2_ioread *cp;
ca545f7c	90	cp = kzalloc(sizeof(*cp),GFP_KERNEL);
a0fd1cb1	91	if (!cp) return NULL;
d855497e	92	pvr2_trace(PVR2_TRACE_STRUCT,"pvr2_ioread_create id=%p",cp);
d855497e MI	93	if (pvr2_ioread_init(cp) < 0) {
d855497e MI	94	kfree(cp);
a0fd1cb1	95	return NULL;
d855497e MI	96	}
	97	return cp;
	98	}
	99
	100	void pvr2_ioread_destroy(struct pvr2_ioread *cp)
	101	{
	102	if (!cp) return;
	103	pvr2_ioread_done(cp);
	104	pvr2_trace(PVR2_TRACE_STRUCT,"pvr2_ioread_destroy id=%p",cp);
	105	if (cp->sync_key_ptr) {
	106	kfree(cp->sync_key_ptr);
a0fd1cb1	107	cp->sync_key_ptr = NULL;
d855497e MI	108	}
	109	kfree(cp);
	110	}
	111
	112	void pvr2_ioread_set_sync_key(struct pvr2_ioread *cp,
	113	const char *sync_key_ptr,
	114	unsigned int sync_key_len)
	115	{
	116	if (!cp) return;
	117
	118	if (!sync_key_ptr) sync_key_len = 0;
	119	if ((sync_key_len == cp->sync_key_len) &&
	120	((!sync_key_len) \|\|
	121	(!memcmp(sync_key_ptr,cp->sync_key_ptr,sync_key_len)))) return;
	122
	123	if (sync_key_len != cp->sync_key_len) {
	124	if (cp->sync_key_ptr) {
	125	kfree(cp->sync_key_ptr);
a0fd1cb1	126	cp->sync_key_ptr = NULL;
d855497e MI	127	}
	128	cp->sync_key_len = 0;
	129	if (sync_key_len) {
	130	cp->sync_key_ptr = kmalloc(sync_key_len,GFP_KERNEL);
	131	if (cp->sync_key_ptr) {
	132	cp->sync_key_len = sync_key_len;
	133	}
	134	}
	135	}
	136	if (!cp->sync_key_len) return;
	137	memcpy(cp->sync_key_ptr,sync_key_ptr,cp->sync_key_len);
	138	}
	139
	140	static void pvr2_ioread_stop(struct pvr2_ioread *cp)
	141	{
	142	if (!(cp->enabled)) return;
	143	pvr2_trace(PVR2_TRACE_START_STOP,
	144	"/---TRACE_READ---/ pvr2_ioread_stop id=%p",cp);
	145	pvr2_stream_kill(cp->stream);
a0fd1cb1 MI	146	cp->c_buf = NULL;
a0fd1cb1 MI	147	cp->c_data_ptr = NULL;
d855497e MI	148	cp->c_data_len = 0;
	149	cp->c_data_offs = 0;
	150	cp->enabled = 0;
	151	cp->stream_running = 0;
	152	cp->spigot_open = 0;
	153	if (cp->sync_state) {
	154	pvr2_trace(PVR2_TRACE_DATA_FLOW,
	155	"/---TRACE_READ---/ sync_state <== 0");
	156	cp->sync_state = 0;
	157	}
	158	}
	159
	160	static int pvr2_ioread_start(struct pvr2_ioread *cp)
	161	{
	162	int stat;
	163	struct pvr2_buffer *bp;
	164	if (cp->enabled) return 0;
	165	if (!(cp->stream)) return 0;
	166	pvr2_trace(PVR2_TRACE_START_STOP,
	167	"/---TRACE_READ---/ pvr2_ioread_start id=%p",cp);
5fa1247a	168	while ((bp = pvr2_stream_get_idle_buffer(cp->stream)) != NULL) {
d855497e MI	169	stat = pvr2_buffer_queue(bp);
	170	if (stat < 0) {
	171	pvr2_trace(PVR2_TRACE_DATA_FLOW,
96292c89	172	"/---TRACE_READ---/ pvr2_ioread_start id=%p error=%d",
d855497e MI	173	cp,stat);
	174	pvr2_ioread_stop(cp);
	175	return stat;
	176	}
	177	}
	178	cp->enabled = !0;
a0fd1cb1 MI	179	cp->c_buf = NULL;
a0fd1cb1 MI	180	cp->c_data_ptr = NULL;
d855497e MI	181	cp->c_data_len = 0;
	182	cp->c_data_offs = 0;
	183	cp->stream_running = 0;
	184	if (cp->sync_key_len) {
	185	pvr2_trace(PVR2_TRACE_DATA_FLOW,
	186	"/---TRACE_READ---/ sync_state <== 1");
	187	cp->sync_state = 1;
	188	cp->sync_trashed_count = 0;
	189	cp->sync_buf_offs = 0;
	190	}
	191	cp->spigot_open = 0;
	192	return 0;
	193	}
	194
	195	struct pvr2_stream pvr2_ioread_get_stream(struct pvr2_ioread cp)
	196	{
	197	return cp->stream;
	198	}
	199
	200	int pvr2_ioread_setup(struct pvr2_ioread cp,struct pvr2_stream sp)
	201	{
	202	int ret;
	203	unsigned int idx;
	204	struct pvr2_buffer *bp;
	205
f419edd4 MCC	206	mutex_lock(&cp->mutex);
f419edd4 MCC	207	do {
d855497e MI	208	if (cp->stream) {
d855497e MI	209	pvr2_trace(PVR2_TRACE_START_STOP,
96292c89 MCC	210	"/---TRACE_READ---/ pvr2_ioread_setup (tear-down) id=%p",
96292c89 MCC	211	cp);
d855497e MI	212	pvr2_ioread_stop(cp);
d855497e MI	213	pvr2_stream_kill(cp->stream);
e61b6fc5 MI	214	if (pvr2_stream_get_buffer_count(cp->stream)) {
	215	pvr2_stream_set_buffer_count(cp->stream,0);
	216	}
a0fd1cb1	217	cp->stream = NULL;
d855497e MI	218	}
	219	if (sp) {
	220	pvr2_trace(PVR2_TRACE_START_STOP,
96292c89 MCC	221	"/---TRACE_READ---/ pvr2_ioread_setup (setup) id=%p",
96292c89 MCC	222	cp);
d855497e MI	223	pvr2_stream_kill(sp);
d855497e MI	224	ret = pvr2_stream_set_buffer_count(sp,BUFFER_COUNT);
4c61f678 JL	225	if (ret < 0) {
	226	mutex_unlock(&cp->mutex);
	227	return ret;
	228	}
d855497e MI	229	for (idx = 0; idx < BUFFER_COUNT; idx++) {
	230	bp = pvr2_stream_get_buffer(sp,idx);
	231	pvr2_buffer_set_buffer(bp,
	232	cp->buffer_storage[idx],
	233	BUFFER_SIZE);
	234	}
	235	cp->stream = sp;
	236	}
f419edd4 MCC	237	} while (0);
f419edd4 MCC	238	mutex_unlock(&cp->mutex);
d855497e MI	239
	240	return 0;
	241	}
	242
	243	int pvr2_ioread_set_enabled(struct pvr2_ioread *cp,int fl)
	244	{
	245	int ret = 0;
	246	if ((!fl) == (!(cp->enabled))) return ret;
	247
f419edd4 MCC	248	mutex_lock(&cp->mutex);
f419edd4 MCC	249	do {
d855497e MI	250	if (fl) {
	251	ret = pvr2_ioread_start(cp);
	252	} else {
	253	pvr2_ioread_stop(cp);
	254	}
f419edd4 MCC	255	} while (0);
f419edd4 MCC	256	mutex_unlock(&cp->mutex);
d855497e MI	257	return ret;
	258	}
	259
07e337ee	260	static int pvr2_ioread_get_buffer(struct pvr2_ioread *cp)
d855497e MI	261	{
	262	int stat;
	263
	264	while (cp->c_data_len <= cp->c_data_offs) {
	265	if (cp->c_buf) {
	266	// Flush out current buffer first.
	267	stat = pvr2_buffer_queue(cp->c_buf);
	268	if (stat < 0) {
	269	// Streaming error...
	270	pvr2_trace(PVR2_TRACE_DATA_FLOW,
96292c89	271	"/---TRACE_READ---/ pvr2_ioread_read id=%p queue_error=%d",
d855497e MI	272	cp,stat);
	273	pvr2_ioread_stop(cp);
	274	return 0;
	275	}
a0fd1cb1 MI	276	cp->c_buf = NULL;
a0fd1cb1 MI	277	cp->c_data_ptr = NULL;
d855497e MI	278	cp->c_data_len = 0;
	279	cp->c_data_offs = 0;
	280	}
	281	// Now get a freshly filled buffer.
	282	cp->c_buf = pvr2_stream_get_ready_buffer(cp->stream);
	283	if (!cp->c_buf) break; // Nothing ready; done.
	284	cp->c_data_len = pvr2_buffer_get_count(cp->c_buf);
	285	if (!cp->c_data_len) {
	286	// Nothing transferred. Was there an error?
	287	stat = pvr2_buffer_get_status(cp->c_buf);
	288	if (stat < 0) {
	289	// Streaming error...
	290	pvr2_trace(PVR2_TRACE_DATA_FLOW,
96292c89	291	"/---TRACE_READ---/ pvr2_ioread_read id=%p buffer_error=%d",
d855497e MI	292	cp,stat);
	293	pvr2_ioread_stop(cp);
	294	// Give up.
	295	return 0;
	296	}
	297	// Start over...
	298	continue;
	299	}
	300	cp->c_data_offs = 0;
	301	cp->c_data_ptr = cp->buffer_storage[
	302	pvr2_buffer_get_id(cp->c_buf)];
	303	}
	304	return !0;
	305	}
	306
07e337ee	307	static void pvr2_ioread_filter(struct pvr2_ioread *cp)
d855497e MI	308	{
	309	unsigned int idx;
	310	if (!cp->enabled) return;
	311	if (cp->sync_state != 1) return;
	312
	313	// Search the stream for our synchronization key. This is made
	314	// complicated by the fact that in order to be honest with
	315	// ourselves here we must search across buffer boundaries...
f419edd4 MCC	316	mutex_lock(&cp->mutex);
f419edd4 MCC	317	while (1) {
d855497e MI	318	// Ensure we have a buffer
	319	if (!pvr2_ioread_get_buffer(cp)) break;
	320	if (!cp->c_data_len) break;
	321
	322	// Now walk the buffer contents until we match the key or
	323	// run out of buffer data.
	324	for (idx = cp->c_data_offs; idx < cp->c_data_len; idx++) {
	325	if (cp->sync_buf_offs >= cp->sync_key_len) break;
	326	if (cp->c_data_ptr[idx] ==
	327	cp->sync_key_ptr[cp->sync_buf_offs]) {
	328	// Found the next key byte
	329	(cp->sync_buf_offs)++;
	330	} else {
	331	// Whoops, mismatched. Start key over...
	332	cp->sync_buf_offs = 0;
	333	}
	334	}
	335
	336	// Consume what we've walked through
	337	cp->c_data_offs += idx;
	338	cp->sync_trashed_count += idx;
	339
	340	// If we've found the key, then update state and get out.
	341	if (cp->sync_buf_offs >= cp->sync_key_len) {
	342	cp->sync_trashed_count -= cp->sync_key_len;
	343	pvr2_trace(PVR2_TRACE_DATA_FLOW,
96292c89	344	"/---TRACE_READ---/ sync_state <== 2 (skipped %u bytes)",
d855497e MI	345	cp->sync_trashed_count);
	346	cp->sync_state = 2;
	347	cp->sync_buf_offs = 0;
	348	break;
	349	}
	350
	351	if (cp->c_data_offs < cp->c_data_len) {
	352	// Sanity check - should NEVER get here
	353	pvr2_trace(PVR2_TRACE_ERROR_LEGS,
96292c89	354	"ERROR: pvr2_ioread filter sync problem len=%u offs=%u",
d855497e MI	355	cp->c_data_len,cp->c_data_offs);
	356	// Get out so we don't get stuck in an infinite
	357	// loop.
	358	break;
	359	}
	360
	361	continue; // (for clarity)
f419edd4 MCC	362	}
f419edd4 MCC	363	mutex_unlock(&cp->mutex);
d855497e MI	364	}
	365
	366	int pvr2_ioread_avail(struct pvr2_ioread *cp)
	367	{
	368	int ret;
	369	if (!(cp->enabled)) {
	370	// Stream is not enabled; so this is an I/O error
	371	return -EIO;
	372	}
	373
	374	if (cp->sync_state == 1) {
	375	pvr2_ioread_filter(cp);
	376	if (cp->sync_state == 1) return -EAGAIN;
	377	}
	378
	379	ret = 0;
	380	if (cp->stream_running) {
	381	if (!pvr2_stream_get_ready_count(cp->stream)) {
	382	// No data available at all right now.
	383	ret = -EAGAIN;
	384	}
	385	} else {
	386	if (pvr2_stream_get_ready_count(cp->stream) < BUFFER_COUNT/2) {
	387	// Haven't buffered up enough yet; try again later
	388	ret = -EAGAIN;
	389	}
	390	}
	391
	392	if ((!(cp->spigot_open)) != (!(ret == 0))) {
	393	cp->spigot_open = (ret == 0);
	394	pvr2_trace(PVR2_TRACE_DATA_FLOW,
	395	"/---TRACE_READ---/ data is %s",
	396	cp->spigot_open ? "available" : "pending");
	397	}
	398
	399	return ret;
	400	}
	401
	402	int pvr2_ioread_read(struct pvr2_ioread cp,void __user buf,unsigned int cnt)
	403	{
	404	unsigned int copied_cnt;
	405	unsigned int bcnt;
	406	const char *src;
	407	int stat;
	408	int ret = 0;
	409	unsigned int req_cnt = cnt;
	410
	411	if (!cnt) {
	412	pvr2_trace(PVR2_TRACE_TRAP,
96292c89 MCC	413	"/---TRACE_READ---/ pvr2_ioread_read id=%p ZERO Request? Returning zero.",
96292c89 MCC	414	cp);
d855497e MI	415	return 0;
	416	}
	417
	418	stat = pvr2_ioread_avail(cp);
	419	if (stat < 0) return stat;
	420
	421	cp->stream_running = !0;
	422
f419edd4 MCC	423	mutex_lock(&cp->mutex);
f419edd4 MCC	424	do {
d855497e MI	425
	426	// Suck data out of the buffers and copy to the user
	427	copied_cnt = 0;
	428	if (!buf) cnt = 0;
	429	while (1) {
	430	if (!pvr2_ioread_get_buffer(cp)) {
	431	ret = -EIO;
	432	break;
	433	}
	434
	435	if (!cnt) break;
	436
	437	if (cp->sync_state == 2) {
	438	// We're repeating the sync key data into
	439	// the stream.
	440	src = cp->sync_key_ptr + cp->sync_buf_offs;
	441	bcnt = cp->sync_key_len - cp->sync_buf_offs;
	442	} else {
	443	// Normal buffer copy
	444	src = cp->c_data_ptr + cp->c_data_offs;
	445	bcnt = cp->c_data_len - cp->c_data_offs;
	446	}
	447
	448	if (!bcnt) break;
	449
	450	// Don't run past user's buffer
	451	if (bcnt > cnt) bcnt = cnt;
	452
	453	if (copy_to_user(buf,src,bcnt)) {
	454	// User supplied a bad pointer?
	455	// Give up - this will cause data
	456	// to be lost.
	457	ret = -EFAULT;
	458	break;
	459	}
	460	cnt -= bcnt;
	461	buf += bcnt;
	462	copied_cnt += bcnt;
	463
	464	if (cp->sync_state == 2) {
	465	// Update offset inside sync key that we're
	466	// repeating back out.
	467	cp->sync_buf_offs += bcnt;
	468	if (cp->sync_buf_offs >= cp->sync_key_len) {
	469	// Consumed entire key; switch mode
	470	// to normal.
	471	pvr2_trace(PVR2_TRACE_DATA_FLOW,
96292c89	472	"/---TRACE_READ---/ sync_state <== 0");
d855497e MI	473	cp->sync_state = 0;
	474	}
	475	} else {
	476	// Update buffer offset.
	477	cp->c_data_offs += bcnt;
	478	}
	479	}
	480
f419edd4 MCC	481	} while (0);
f419edd4 MCC	482	mutex_unlock(&cp->mutex);
d855497e MI	483
	484	if (!ret) {
	485	if (copied_cnt) {
	486	// If anything was copied, return that count
	487	ret = copied_cnt;
	488	} else {
	489	// Nothing copied; suggest to caller that another
	490	// attempt should be tried again later
	491	ret = -EAGAIN;
	492	}
	493	}
	494
	495	pvr2_trace(PVR2_TRACE_DATA_FLOW,
96292c89	496	"/---TRACE_READ---/ pvr2_ioread_read id=%p request=%d result=%d",
d855497e MI	497	cp,req_cnt,ret);
	498	return ret;
	499	}