[mirror_ubuntu-bionic-kernel.git] / drivers / media / video / pvrusb2 / pvrusb2-context.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-context.h"
#include "pvrusb2-io.h"
#include "pvrusb2-ioread.h"
#include "pvrusb2-hdw.h"
#include "pvrusb2-debug.h"
#include <linux/wait.h>
#include <linux/kthread.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/slab.h>

static struct pvr2_context *pvr2_context_exist_first;
static struct pvr2_context *pvr2_context_exist_last;
static struct pvr2_context *pvr2_context_notify_first;
static struct pvr2_context *pvr2_context_notify_last;
static DEFINE_MUTEX(pvr2_context_mutex);
static DECLARE_WAIT_QUEUE_HEAD(pvr2_context_sync_data);
static DECLARE_WAIT_QUEUE_HEAD(pvr2_context_cleanup_data);
static int pvr2_context_cleanup_flag;
static int pvr2_context_cleaned_flag;
static struct task_struct *pvr2_context_thread_ptr;


static void pvr2_context_set_notify(struct pvr2_context *mp, int fl)
{
	int signal_flag = 0;
	mutex_lock(&pvr2_context_mutex);
	if (fl) {
		if (!mp->notify_flag) {
			signal_flag = (pvr2_context_notify_first == NULL);
			mp->notify_prev = pvr2_context_notify_last;
			mp->notify_next = NULL;
			pvr2_context_notify_last = mp;
			if (mp->notify_prev) {
				mp->notify_prev->notify_next = mp;
			} else {
				pvr2_context_notify_first = mp;
			}
			mp->notify_flag = !0;
		}
	} else {
		if (mp->notify_flag) {
			mp->notify_flag = 0;
			if (mp->notify_next) {
				mp->notify_next->notify_prev = mp->notify_prev;
			} else {
				pvr2_context_notify_last = mp->notify_prev;
			}
			if (mp->notify_prev) {
				mp->notify_prev->notify_next = mp->notify_next;
			} else {
				pvr2_context_notify_first = mp->notify_next;
			}
		}
	}
	mutex_unlock(&pvr2_context_mutex);
	if (signal_flag) wake_up(&pvr2_context_sync_data);
}


static void pvr2_context_destroy(struct pvr2_context *mp)
{
	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context %p (destroy)",mp);
	if (mp->hdw) pvr2_hdw_destroy(mp->hdw);
	pvr2_context_set_notify(mp, 0);
	mutex_lock(&pvr2_context_mutex);
	if (mp->exist_next) {
		mp->exist_next->exist_prev = mp->exist_prev;
	} else {
		pvr2_context_exist_last = mp->exist_prev;
	}
	if (mp->exist_prev) {
		mp->exist_prev->exist_next = mp->exist_next;
	} else {
		pvr2_context_exist_first = mp->exist_next;
	}
	if (!pvr2_context_exist_first) {
		/* Trigger wakeup on control thread in case it is waiting
		   for an exit condition. */
		wake_up(&pvr2_context_sync_data);
	}
	mutex_unlock(&pvr2_context_mutex);
	kfree(mp);
}


static void pvr2_context_notify(struct pvr2_context *mp)
{
	pvr2_context_set_notify(mp,!0);
}


static void pvr2_context_check(struct pvr2_context *mp)
{
	struct pvr2_channel *ch1, *ch2;
	pvr2_trace(PVR2_TRACE_CTXT,
		   "pvr2_context %p (notify)", mp);
	if (!mp->initialized_flag && !mp->disconnect_flag) {
		mp->initialized_flag = !0;
		pvr2_trace(PVR2_TRACE_CTXT,
			   "pvr2_context %p (initialize)", mp);
		/* Finish hardware initialization */
		if (pvr2_hdw_initialize(mp->hdw,
					(void (*)(void *))pvr2_context_notify,
					mp)) {
			mp->video_stream.stream =
				pvr2_hdw_get_video_stream(mp->hdw);
			/* Trigger interface initialization.  By doing this
			   here initialization runs in our own safe and
			   cozy thread context. */
			if (mp->setup_func) mp->setup_func(mp);
		} else {
			pvr2_trace(PVR2_TRACE_CTXT,
				   "pvr2_context %p (thread skipping setup)",
				   mp);
			/* Even though initialization did not succeed,
			   we're still going to continue anyway.  We need
			   to do this in order to await the expected
			   disconnect (which we will detect in the normal
			   course of operation). */
		}
	}

	for (ch1 = mp->mc_first; ch1; ch1 = ch2) {
		ch2 = ch1->mc_next;
		if (ch1->check_func) ch1->check_func(ch1);
	}

	if (mp->disconnect_flag && !mp->mc_first) {
		/* Go away... */
		pvr2_context_destroy(mp);
		return;
	}
}


static int pvr2_context_shutok(void)
{
	return pvr2_context_cleanup_flag && (pvr2_context_exist_first == NULL);
}


static int pvr2_context_thread_func(void *foo)
{
	struct pvr2_context *mp;

	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context thread start");

	do {
		while ((mp = pvr2_context_notify_first) != NULL) {
			pvr2_context_set_notify(mp, 0);
			pvr2_context_check(mp);
		}
		wait_event_interruptible(
			pvr2_context_sync_data,
			((pvr2_context_notify_first != NULL) ||
			 pvr2_context_shutok()));
	} while (!pvr2_context_shutok());

	pvr2_context_cleaned_flag = !0;
	wake_up(&pvr2_context_cleanup_data);

	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context thread cleaned up");

	wait_event_interruptible(
		pvr2_context_sync_data,
		kthread_should_stop());

	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context thread end");

	return 0;
}


int pvr2_context_global_init(void)
{
	pvr2_context_thread_ptr = kthread_run(pvr2_context_thread_func,
					      NULL,
					      "pvrusb2-context");
	return (pvr2_context_thread_ptr ? 0 : -ENOMEM);
}


void pvr2_context_global_done(void)
{
	pvr2_context_cleanup_flag = !0;
	wake_up(&pvr2_context_sync_data);
	wait_event_interruptible(
		pvr2_context_cleanup_data,
		pvr2_context_cleaned_flag);
	kthread_stop(pvr2_context_thread_ptr);
}


struct pvr2_context *pvr2_context_create(
	struct usb_interface *intf,
	const struct usb_device_id *devid,
	void (*setup_func)(struct pvr2_context *))
{
	struct pvr2_context *mp = NULL;
	mp = kzalloc(sizeof(*mp),GFP_KERNEL);
	if (!mp) goto done;
	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context %p (create)",mp);
	mp->setup_func = setup_func;
	mutex_init(&mp->mutex);
	mutex_lock(&pvr2_context_mutex);
	mp->exist_prev = pvr2_context_exist_last;
	mp->exist_next = NULL;
	pvr2_context_exist_last = mp;
	if (mp->exist_prev) {
		mp->exist_prev->exist_next = mp;
	} else {
		pvr2_context_exist_first = mp;
	}
	mutex_unlock(&pvr2_context_mutex);
	mp->hdw = pvr2_hdw_create(intf,devid);
	if (!mp->hdw) {
		pvr2_context_destroy(mp);
		mp = NULL;
		goto done;
	}
	pvr2_context_set_notify(mp, !0);
 done:
	return mp;
}


static void pvr2_context_reset_input_limits(struct pvr2_context *mp)
{
	unsigned int tmsk,mmsk;
	struct pvr2_channel *cp;
	struct pvr2_hdw *hdw = mp->hdw;
	mmsk = pvr2_hdw_get_input_available(hdw);
	tmsk = mmsk;
	for (cp = mp->mc_first; cp; cp = cp->mc_next) {
		if (!cp->input_mask) continue;
		tmsk &= cp->input_mask;
	}
	pvr2_hdw_set_input_allowed(hdw,mmsk,tmsk);
	pvr2_hdw_commit_ctl(hdw);
}


static void pvr2_context_enter(struct pvr2_context *mp)
{
	mutex_lock(&mp->mutex);
}


static void pvr2_context_exit(struct pvr2_context *mp)
{
	int destroy_flag = 0;
	if (!(mp->mc_first || !mp->disconnect_flag)) {
		destroy_flag = !0;
	}
	mutex_unlock(&mp->mutex);
	if (destroy_flag) pvr2_context_notify(mp);
}


void pvr2_context_disconnect(struct pvr2_context *mp)
{
	pvr2_hdw_disconnect(mp->hdw);
	mp->disconnect_flag = !0;
	pvr2_context_notify(mp);
}


void pvr2_channel_init(struct pvr2_channel *cp,struct pvr2_context *mp)
{
	pvr2_context_enter(mp);
	cp->hdw = mp->hdw;
	cp->mc_head = mp;
	cp->mc_next = NULL;
	cp->mc_prev = mp->mc_last;
	if (mp->mc_last) {
		mp->mc_last->mc_next = cp;
	} else {
		mp->mc_first = cp;
	}
	mp->mc_last = cp;
	pvr2_context_exit(mp);
}


static void pvr2_channel_disclaim_stream(struct pvr2_channel *cp)
{
	if (!cp->stream) return;
	pvr2_stream_kill(cp->stream->stream);
	cp->stream->user = NULL;
	cp->stream = NULL;
}


void pvr2_channel_done(struct pvr2_channel *cp)
{
	struct pvr2_context *mp = cp->mc_head;
	pvr2_context_enter(mp);
	cp->input_mask = 0;
	pvr2_channel_disclaim_stream(cp);
	pvr2_context_reset_input_limits(mp);
	if (cp->mc_next) {
		cp->mc_next->mc_prev = cp->mc_prev;
	} else {
		mp->mc_last = cp->mc_prev;
	}
	if (cp->mc_prev) {
		cp->mc_prev->mc_next = cp->mc_next;
	} else {
		mp->mc_first = cp->mc_next;
	}
	cp->hdw = NULL;
	pvr2_context_exit(mp);
}


int pvr2_channel_limit_inputs(struct pvr2_channel *cp,unsigned int cmsk)
{
	unsigned int tmsk,mmsk;
	int ret = 0;
	struct pvr2_channel *p2;
	struct pvr2_hdw *hdw = cp->hdw;

	mmsk = pvr2_hdw_get_input_available(hdw);
	cmsk &= mmsk;
	if (cmsk == cp->input_mask) {
		/* No change; nothing to do */
		return 0;
	}

	pvr2_context_enter(cp->mc_head);
	do {
		if (!cmsk) {
			cp->input_mask = 0;
			pvr2_context_reset_input_limits(cp->mc_head);
			break;
		}
		tmsk = mmsk;
		for (p2 = cp->mc_head->mc_first; p2; p2 = p2->mc_next) {
			if (p2 == cp) continue;
			if (!p2->input_mask) continue;
			tmsk &= p2->input_mask;
		}
		if (!(tmsk & cmsk)) {
			ret = -EPERM;
			break;
		}
		tmsk &= cmsk;
		if ((ret = pvr2_hdw_set_input_allowed(hdw,mmsk,tmsk)) != 0) {
			/* Internal failure changing allowed list; probably
			   should not happen, but react if it does. */
			break;
		}
		cp->input_mask = cmsk;
		pvr2_hdw_commit_ctl(hdw);
	} while (0);
	pvr2_context_exit(cp->mc_head);
	return ret;
}


unsigned int pvr2_channel_get_limited_inputs(struct pvr2_channel *cp)
{
	return cp->input_mask;
}


int pvr2_channel_claim_stream(struct pvr2_channel *cp,
			      struct pvr2_context_stream *sp)
{
	int code = 0;
	pvr2_context_enter(cp->mc_head); do {
		if (sp == cp->stream) break;
		if (sp && sp->user) {
			code = -EBUSY;
			break;
		}
		pvr2_channel_disclaim_stream(cp);
		if (!sp) break;
		sp->user = cp;
		cp->stream = sp;
	} while (0); pvr2_context_exit(cp->mc_head);
	return code;
}


// This is the marker for the real beginning of a legitimate mpeg2 stream.
static char stream_sync_key[] = {
	0x00, 0x00, 0x01, 0xba,
};

struct pvr2_ioread *pvr2_channel_create_mpeg_stream(
	struct pvr2_context_stream *sp)
{
	struct pvr2_ioread *cp;
	cp = pvr2_ioread_create();
	if (!cp) return NULL;
	pvr2_ioread_setup(cp,sp->stream);
	pvr2_ioread_set_sync_key(cp,stream_sync_key,sizeof(stream_sync_key));
	return cp;
}


/*
  Stuff for Emacs to see, in order to encourage consistent editing style:
  *** Local Variables: ***
  *** mode: c ***
  *** fill-column: 75 ***
  *** tab-width: 8 ***
  *** c-basic-offset: 8 ***
  *** End: ***
  */
Commit	Line	Data
d855497e	1	/*
d855497e MI	2	*
	3	* Copyright (C) 2005 Mike Isely <isely@pobox.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	17	*
	18	*/
	19
	20	#include "pvrusb2-context.h"
	21	#include "pvrusb2-io.h"
	22	#include "pvrusb2-ioread.h"
	23	#include "pvrusb2-hdw.h"
	24	#include "pvrusb2-debug.h"
e5be15c6	25	#include <linux/wait.h>
794b1607	26	#include <linux/kthread.h>
d855497e MI	27	#include <linux/errno.h>
	28	#include <linux/string.h>
	29	#include <linux/slab.h>
d855497e	30
e5be15c6 MI	31	static struct pvr2_context *pvr2_context_exist_first;
	32	static struct pvr2_context *pvr2_context_exist_last;
	33	static struct pvr2_context *pvr2_context_notify_first;
	34	static struct pvr2_context *pvr2_context_notify_last;
	35	static DEFINE_MUTEX(pvr2_context_mutex);
	36	static DECLARE_WAIT_QUEUE_HEAD(pvr2_context_sync_data);
18ecbb47 MI	37	static DECLARE_WAIT_QUEUE_HEAD(pvr2_context_cleanup_data);
	38	static int pvr2_context_cleanup_flag;
	39	static int pvr2_context_cleaned_flag;
e5be15c6 MI	40	static struct task_struct *pvr2_context_thread_ptr;
	41
	42
	43	static void pvr2_context_set_notify(struct pvr2_context *mp, int fl)
	44	{
	45	int signal_flag = 0;
	46	mutex_lock(&pvr2_context_mutex);
	47	if (fl) {
	48	if (!mp->notify_flag) {
	49	signal_flag = (pvr2_context_notify_first == NULL);
	50	mp->notify_prev = pvr2_context_notify_last;
	51	mp->notify_next = NULL;
	52	pvr2_context_notify_last = mp;
	53	if (mp->notify_prev) {
	54	mp->notify_prev->notify_next = mp;
	55	} else {
	56	pvr2_context_notify_first = mp;
	57	}
	58	mp->notify_flag = !0;
	59	}
	60	} else {
	61	if (mp->notify_flag) {
	62	mp->notify_flag = 0;
	63	if (mp->notify_next) {
	64	mp->notify_next->notify_prev = mp->notify_prev;
	65	} else {
	66	pvr2_context_notify_last = mp->notify_prev;
	67	}
	68	if (mp->notify_prev) {
	69	mp->notify_prev->notify_next = mp->notify_next;
	70	} else {
	71	pvr2_context_notify_first = mp->notify_next;
	72	}
	73	}
	74	}
	75	mutex_unlock(&pvr2_context_mutex);
	76	if (signal_flag) wake_up(&pvr2_context_sync_data);
	77	}
	78
d855497e MI	79
	80	static void pvr2_context_destroy(struct pvr2_context *mp)
	81	{
794b1607	82	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context %p (destroy)",mp);
681c7399	83	if (mp->hdw) pvr2_hdw_destroy(mp->hdw);
e5be15c6 MI	84	pvr2_context_set_notify(mp, 0);
	85	mutex_lock(&pvr2_context_mutex);
	86	if (mp->exist_next) {
	87	mp->exist_next->exist_prev = mp->exist_prev;
	88	} else {
	89	pvr2_context_exist_last = mp->exist_prev;
	90	}
	91	if (mp->exist_prev) {
	92	mp->exist_prev->exist_next = mp->exist_next;
	93	} else {
	94	pvr2_context_exist_first = mp->exist_next;
	95	}
	96	if (!pvr2_context_exist_first) {
	97	/* Trigger wakeup on control thread in case it is waiting
	98	for an exit condition. */
	99	wake_up(&pvr2_context_sync_data);
	100	}
	101	mutex_unlock(&pvr2_context_mutex);
d855497e MI	102	kfree(mp);
	103	}
	104
	105
794b1607	106	static void pvr2_context_notify(struct pvr2_context *mp)
d855497e	107	{
e5be15c6	108	pvr2_context_set_notify(mp,!0);
794b1607 MI	109	}
	110
	111
e5be15c6	112	static void pvr2_context_check(struct pvr2_context *mp)
794b1607	113	{
e5be15c6 MI	114	struct pvr2_channel ch1, ch2;
	115	pvr2_trace(PVR2_TRACE_CTXT,
	116	"pvr2_context %p (notify)", mp);
	117	if (!mp->initialized_flag && !mp->disconnect_flag) {
	118	mp->initialized_flag = !0;
794b1607	119	pvr2_trace(PVR2_TRACE_CTXT,
e5be15c6 MI	120	"pvr2_context %p (initialize)", mp);
	121	/* Finish hardware initialization */
	122	if (pvr2_hdw_initialize(mp->hdw,
	123	(void ()(void ))pvr2_context_notify,
	124	mp)) {
	125	mp->video_stream.stream =
	126	pvr2_hdw_get_video_stream(mp->hdw);
	127	/* Trigger interface initialization. By doing this
	128	here initialization runs in our own safe and
	129	cozy thread context. */
	130	if (mp->setup_func) mp->setup_func(mp);
	131	} else {
794b1607	132	pvr2_trace(PVR2_TRACE_CTXT,
e5be15c6 MI	133	"pvr2_context %p (thread skipping setup)",
	134	mp);
	135	/* Even though initialization did not succeed,
	136	we're still going to continue anyway. We need
	137	to do this in order to await the expected
	138	disconnect (which we will detect in the normal
	139	course of operation). */
d855497e	140	}
794b1607	141	}
e5be15c6 MI	142
	143	for (ch1 = mp->mc_first; ch1; ch1 = ch2) {
	144	ch2 = ch1->mc_next;
	145	if (ch1->check_func) ch1->check_func(ch1);
	146	}
	147
	148	if (mp->disconnect_flag && !mp->mc_first) {
	149	/* Go away... */
	150	pvr2_context_destroy(mp);
	151	return;
	152	}
	153	}
	154
	155
	156	static int pvr2_context_shutok(void)
	157	{
18ecbb47	158	return pvr2_context_cleanup_flag && (pvr2_context_exist_first == NULL);
e5be15c6 MI	159	}
	160
	161
	162	static int pvr2_context_thread_func(void *foo)
	163	{
	164	struct pvr2_context *mp;
	165
	166	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context thread start");
	167
	168	do {
	169	while ((mp = pvr2_context_notify_first) != NULL) {
	170	pvr2_context_set_notify(mp, 0);
	171	pvr2_context_check(mp);
	172	}
	173	wait_event_interruptible(
	174	pvr2_context_sync_data,
	175	((pvr2_context_notify_first != NULL) \|\|
	176	pvr2_context_shutok()));
	177	} while (!pvr2_context_shutok());
	178
18ecbb47 MI	179	pvr2_context_cleaned_flag = !0;
	180	wake_up(&pvr2_context_cleanup_data);
	181
	182	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context thread cleaned up");
	183
	184	wait_event_interruptible(
	185	pvr2_context_sync_data,
	186	kthread_should_stop());
	187
e5be15c6 MI	188	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context thread end");
e5be15c6 MI	189
794b1607 MI	190	return 0;
794b1607 MI	191	}
d855497e MI	192
d855497e MI	193
e5be15c6 MI	194	int pvr2_context_global_init(void)
	195	{
	196	pvr2_context_thread_ptr = kthread_run(pvr2_context_thread_func,
a6a3a17b	197	NULL,
e5be15c6 MI	198	"pvrusb2-context");
	199	return (pvr2_context_thread_ptr ? 0 : -ENOMEM);
	200	}
	201
	202
	203	void pvr2_context_global_done(void)
	204	{
18ecbb47 MI	205	pvr2_context_cleanup_flag = !0;
	206	wake_up(&pvr2_context_sync_data);
	207	wait_event_interruptible(
	208	pvr2_context_cleanup_data,
	209	pvr2_context_cleaned_flag);
e5be15c6 MI	210	kthread_stop(pvr2_context_thread_ptr);
	211	}
	212
	213
d855497e MI	214	struct pvr2_context *pvr2_context_create(
	215	struct usb_interface *intf,
	216	const struct usb_device_id *devid,
	217	void (setup_func)(struct pvr2_context ))
	218	{
a0fd1cb1	219	struct pvr2_context *mp = NULL;
ca545f7c	220	mp = kzalloc(sizeof(*mp),GFP_KERNEL);
d855497e	221	if (!mp) goto done;
794b1607	222	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context %p (create)",mp);
d855497e MI	223	mp->setup_func = setup_func;
d855497e MI	224	mutex_init(&mp->mutex);
e5be15c6 MI	225	mutex_lock(&pvr2_context_mutex);
	226	mp->exist_prev = pvr2_context_exist_last;
	227	mp->exist_next = NULL;
	228	pvr2_context_exist_last = mp;
	229	if (mp->exist_prev) {
	230	mp->exist_prev->exist_next = mp;
	231	} else {
	232	pvr2_context_exist_first = mp;
	233	}
	234	mutex_unlock(&pvr2_context_mutex);
d855497e MI	235	mp->hdw = pvr2_hdw_create(intf,devid);
	236	if (!mp->hdw) {
	237	pvr2_context_destroy(mp);
a0fd1cb1	238	mp = NULL;
d855497e MI	239	goto done;
d855497e MI	240	}
e5be15c6	241	pvr2_context_set_notify(mp, !0);
d855497e MI	242	done:
	243	return mp;
	244	}
	245
	246
1cb03b76 MI	247	static void pvr2_context_reset_input_limits(struct pvr2_context *mp)
	248	{
	249	unsigned int tmsk,mmsk;
	250	struct pvr2_channel *cp;
	251	struct pvr2_hdw *hdw = mp->hdw;
	252	mmsk = pvr2_hdw_get_input_available(hdw);
	253	tmsk = mmsk;
	254	for (cp = mp->mc_first; cp; cp = cp->mc_next) {
	255	if (!cp->input_mask) continue;
	256	tmsk &= cp->input_mask;
	257	}
	258	pvr2_hdw_set_input_allowed(hdw,mmsk,tmsk);
	259	pvr2_hdw_commit_ctl(hdw);
	260	}
	261
	262
794b1607	263	static void pvr2_context_enter(struct pvr2_context *mp)
d855497e MI	264	{
d855497e MI	265	mutex_lock(&mp->mutex);
d855497e MI	266	}
	267
	268
794b1607	269	static void pvr2_context_exit(struct pvr2_context *mp)
d855497e MI	270	{
	271	int destroy_flag = 0;
	272	if (!(mp->mc_first \|\| !mp->disconnect_flag)) {
	273	destroy_flag = !0;
	274	}
d855497e	275	mutex_unlock(&mp->mutex);
794b1607	276	if (destroy_flag) pvr2_context_notify(mp);
d855497e MI	277	}
	278
	279
	280	void pvr2_context_disconnect(struct pvr2_context *mp)
	281	{
794b1607 MI	282	pvr2_hdw_disconnect(mp->hdw);
	283	mp->disconnect_flag = !0;
	284	pvr2_context_notify(mp);
d855497e MI	285	}
	286
	287
	288	void pvr2_channel_init(struct pvr2_channel cp,struct pvr2_context mp)
	289	{
794b1607	290	pvr2_context_enter(mp);
d855497e MI	291	cp->hdw = mp->hdw;
d855497e MI	292	cp->mc_head = mp;
a0fd1cb1	293	cp->mc_next = NULL;
d855497e MI	294	cp->mc_prev = mp->mc_last;
	295	if (mp->mc_last) {
	296	mp->mc_last->mc_next = cp;
	297	} else {
	298	mp->mc_first = cp;
	299	}
	300	mp->mc_last = cp;
794b1607	301	pvr2_context_exit(mp);
d855497e MI	302	}
	303
	304
	305	static void pvr2_channel_disclaim_stream(struct pvr2_channel *cp)
	306	{
	307	if (!cp->stream) return;
	308	pvr2_stream_kill(cp->stream->stream);
a0fd1cb1 MI	309	cp->stream->user = NULL;
a0fd1cb1 MI	310	cp->stream = NULL;
d855497e MI	311	}
	312
	313
	314	void pvr2_channel_done(struct pvr2_channel *cp)
	315	{
	316	struct pvr2_context *mp = cp->mc_head;
794b1607	317	pvr2_context_enter(mp);
1cb03b76	318	cp->input_mask = 0;
d855497e	319	pvr2_channel_disclaim_stream(cp);
1cb03b76	320	pvr2_context_reset_input_limits(mp);
d855497e MI	321	if (cp->mc_next) {
	322	cp->mc_next->mc_prev = cp->mc_prev;
	323	} else {
	324	mp->mc_last = cp->mc_prev;
	325	}
	326	if (cp->mc_prev) {
	327	cp->mc_prev->mc_next = cp->mc_next;
	328	} else {
	329	mp->mc_first = cp->mc_next;
	330	}
a0fd1cb1	331	cp->hdw = NULL;
794b1607	332	pvr2_context_exit(mp);
d855497e MI	333	}
	334
	335
1cb03b76 MI	336	int pvr2_channel_limit_inputs(struct pvr2_channel *cp,unsigned int cmsk)
	337	{
	338	unsigned int tmsk,mmsk;
	339	int ret = 0;
	340	struct pvr2_channel *p2;
	341	struct pvr2_hdw *hdw = cp->hdw;
	342
	343	mmsk = pvr2_hdw_get_input_available(hdw);
	344	cmsk &= mmsk;
	345	if (cmsk == cp->input_mask) {
	346	/* No change; nothing to do */
	347	return 0;
	348	}
	349
	350	pvr2_context_enter(cp->mc_head);
	351	do {
	352	if (!cmsk) {
	353	cp->input_mask = 0;
	354	pvr2_context_reset_input_limits(cp->mc_head);
	355	break;
	356	}
	357	tmsk = mmsk;
	358	for (p2 = cp->mc_head->mc_first; p2; p2 = p2->mc_next) {
	359	if (p2 == cp) continue;
	360	if (!p2->input_mask) continue;
	361	tmsk &= p2->input_mask;
	362	}
	363	if (!(tmsk & cmsk)) {
	364	ret = -EPERM;
	365	break;
	366	}
	367	tmsk &= cmsk;
	368	if ((ret = pvr2_hdw_set_input_allowed(hdw,mmsk,tmsk)) != 0) {
	369	/* Internal failure changing allowed list; probably
	370	should not happen, but react if it does. */
	371	break;
	372	}
	373	cp->input_mask = cmsk;
	374	pvr2_hdw_commit_ctl(hdw);
	375	} while (0);
	376	pvr2_context_exit(cp->mc_head);
	377	return ret;
	378	}
	379
	380
	381	unsigned int pvr2_channel_get_limited_inputs(struct pvr2_channel *cp)
	382	{
	383	return cp->input_mask;
	384	}
	385
	386
d855497e MI	387	int pvr2_channel_claim_stream(struct pvr2_channel *cp,
	388	struct pvr2_context_stream *sp)
	389	{
	390	int code = 0;
	391	pvr2_context_enter(cp->mc_head); do {
	392	if (sp == cp->stream) break;
99a6acf9	393	if (sp && sp->user) {
d855497e MI	394	code = -EBUSY;
	395	break;
	396	}
	397	pvr2_channel_disclaim_stream(cp);
	398	if (!sp) break;
	399	sp->user = cp;
	400	cp->stream = sp;
	401	} while (0); pvr2_context_exit(cp->mc_head);
	402	return code;
	403	}
	404
	405
	406	// This is the marker for the real beginning of a legitimate mpeg2 stream.
	407	static char stream_sync_key[] = {
	408	0x00, 0x00, 0x01, 0xba,
	409	};
	410
	411	struct pvr2_ioread *pvr2_channel_create_mpeg_stream(
	412	struct pvr2_context_stream *sp)
	413	{
	414	struct pvr2_ioread *cp;
	415	cp = pvr2_ioread_create();
a0fd1cb1	416	if (!cp) return NULL;
d855497e MI	417	pvr2_ioread_setup(cp,sp->stream);
	418	pvr2_ioread_set_sync_key(cp,stream_sync_key,sizeof(stream_sync_key));
	419	return cp;
	420	}
	421
	422
	423	/*
	424	Stuff for Emacs to see, in order to encourage consistent editing style:
	425	* Local Variables: *
	426	* mode: c *
	427	* fill-column: 75 *
	428	* tab-width: 8 *
	429	* c-basic-offset: 8 *
	430	* End: *
	431	*/