[mirror_ubuntu-bionic-kernel.git] / drivers / media / video / pvrusb2 / pvrusb2-context.c

/*
 *  $Id$
 *
 *  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/errno.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <asm/semaphore.h>


static void pvr2_context_destroy(struct pvr2_context *mp)
{
	if (mp->hdw) pvr2_hdw_destroy(mp->hdw);
	pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr_main id=%p",mp);
	flush_workqueue(mp->workqueue);
	destroy_workqueue(mp->workqueue);
	kfree(mp);
}


static void pvr2_context_trigger_poll(struct pvr2_context *mp)
{
	queue_work(mp->workqueue,&mp->workpoll);
}


static void pvr2_context_poll(struct pvr2_context *mp)
{
	pvr2_context_enter(mp); do {
		pvr2_hdw_poll(mp->hdw);
	} while (0); pvr2_context_exit(mp);
}


static void pvr2_context_setup(struct pvr2_context *mp)
{
	pvr2_context_enter(mp); do {
		if (!pvr2_hdw_dev_ok(mp->hdw)) break;
		pvr2_hdw_setup(mp->hdw);
		pvr2_hdw_setup_poll_trigger(
			mp->hdw,
			(void (*)(void *))pvr2_context_trigger_poll,
			mp);
		if (!pvr2_hdw_dev_ok(mp->hdw)) break;
		if (!pvr2_hdw_init_ok(mp->hdw)) break;
		mp->video_stream.stream = pvr2_hdw_get_video_stream(mp->hdw);
		if (mp->setup_func) {
			mp->setup_func(mp);
		}
	} while (0); pvr2_context_exit(mp);
}


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 = kmalloc(sizeof(*mp),GFP_KERNEL);
	if (!mp) goto done;
	memset(mp,0,sizeof(*mp));
	pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_main id=%p",mp);
	mp->setup_func = setup_func;
	mutex_init(&mp->mutex);
	mp->hdw = pvr2_hdw_create(intf,devid);
	if (!mp->hdw) {
		pvr2_context_destroy(mp);
		mp = NULL;
		goto done;
	}

	mp->workqueue = create_singlethread_workqueue("pvrusb2");
	INIT_WORK(&mp->workinit,(void (*)(void*))pvr2_context_setup,mp);
	INIT_WORK(&mp->workpoll,(void (*)(void*))pvr2_context_poll,mp);
	queue_work(mp->workqueue,&mp->workinit);
 done:
	return mp;
}


void pvr2_context_enter(struct pvr2_context *mp)
{
	mutex_lock(&mp->mutex);
	pvr2_trace(PVR2_TRACE_CREG,"pvr2_context_enter(id=%p)",mp);
}


void pvr2_context_exit(struct pvr2_context *mp)
{
	int destroy_flag = 0;
	if (!(mp->mc_first || !mp->disconnect_flag)) {
		destroy_flag = !0;
	}
	pvr2_trace(PVR2_TRACE_CREG,"pvr2_context_exit(id=%p) outside",mp);
	mutex_unlock(&mp->mutex);
	if (destroy_flag) pvr2_context_destroy(mp);
}


static void pvr2_context_run_checks(struct pvr2_context *mp)
{
	struct pvr2_channel *ch1,*ch2;
	for (ch1 = mp->mc_first; ch1; ch1 = ch2) {
		ch2 = ch1->mc_next;
		if (ch1->check_func) {
			ch1->check_func(ch1);
		}
	}
}


void pvr2_context_disconnect(struct pvr2_context *mp)
{
	pvr2_context_enter(mp); do {
		pvr2_hdw_disconnect(mp->hdw);
		mp->disconnect_flag = !0;
		pvr2_context_run_checks(mp);
	} while (0); pvr2_context_exit(mp);
}


void pvr2_channel_init(struct pvr2_channel *cp,struct pvr2_context *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;
}


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_channel_disclaim_stream(cp);
	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;
}


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->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 MI	1	/*
	2	* $Id$
	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-context.h"
	22	#include "pvrusb2-io.h"
	23	#include "pvrusb2-ioread.h"
	24	#include "pvrusb2-hdw.h"
	25	#include "pvrusb2-debug.h"
	26	#include <linux/errno.h>
	27	#include <linux/string.h>
	28	#include <linux/slab.h>
	29	#include <asm/semaphore.h>
	30
	31
	32	static void pvr2_context_destroy(struct pvr2_context *mp)
	33	{
	34	if (mp->hdw) pvr2_hdw_destroy(mp->hdw);
	35	pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr_main id=%p",mp);
	36	flush_workqueue(mp->workqueue);
	37	destroy_workqueue(mp->workqueue);
	38	kfree(mp);
	39	}
	40
	41
	42	static void pvr2_context_trigger_poll(struct pvr2_context *mp)
	43	{
	44	queue_work(mp->workqueue,&mp->workpoll);
	45	}
	46
	47
	48	static void pvr2_context_poll(struct pvr2_context *mp)
	49	{
	50	pvr2_context_enter(mp); do {
	51	pvr2_hdw_poll(mp->hdw);
	52	} while (0); pvr2_context_exit(mp);
	53	}
	54
	55
	56	static void pvr2_context_setup(struct pvr2_context *mp)
	57	{
	58	pvr2_context_enter(mp); do {
	59	if (!pvr2_hdw_dev_ok(mp->hdw)) break;
	60	pvr2_hdw_setup(mp->hdw);
	61	pvr2_hdw_setup_poll_trigger(
	62	mp->hdw,
	63	(void ()(void ))pvr2_context_trigger_poll,
	64	mp);
65	if (!pvr2_hdw_dev_ok(mp->hdw)) break;
66	if (!pvr2_hdw_init_ok(mp->hdw)) break;
67	mp->video_stream.stream = pvr2_hdw_get_video_stream(mp->hdw);
68	if (mp->setup_func) {
69	mp->setup_func(mp);
70	}
71	} while (0); pvr2_context_exit(mp);
72	}
73
74
75	struct pvr2_context *pvr2_context_create(
76	struct usb_interface *intf,
77	const struct usb_device_id *devid,
78	void (setup_func)(struct pvr2_context ))
79	{
a0fd1cb1	80	struct pvr2_context *mp = NULL;
d855497e MI	81	mp = kmalloc(sizeof(*mp),GFP_KERNEL);
	82	if (!mp) goto done;
	83	memset(mp,0,sizeof(*mp));
	84	pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_main id=%p",mp);
	85	mp->setup_func = setup_func;
	86	mutex_init(&mp->mutex);
	87	mp->hdw = pvr2_hdw_create(intf,devid);
	88	if (!mp->hdw) {
	89	pvr2_context_destroy(mp);
a0fd1cb1	90	mp = NULL;
d855497e MI	91	goto done;
	92	}
	93
	94	mp->workqueue = create_singlethread_workqueue("pvrusb2");
	95	INIT_WORK(&mp->workinit,(void ()(void))pvr2_context_setup,mp);
	96	INIT_WORK(&mp->workpoll,(void ()(void))pvr2_context_poll,mp);
	97	queue_work(mp->workqueue,&mp->workinit);
	98	done:
	99	return mp;
	100	}
	101
	102
	103	void pvr2_context_enter(struct pvr2_context *mp)
	104	{
	105	mutex_lock(&mp->mutex);
	106	pvr2_trace(PVR2_TRACE_CREG,"pvr2_context_enter(id=%p)",mp);
	107	}
	108
	109
	110	void pvr2_context_exit(struct pvr2_context *mp)
	111	{
	112	int destroy_flag = 0;
	113	if (!(mp->mc_first \|\| !mp->disconnect_flag)) {
	114	destroy_flag = !0;
	115	}
	116	pvr2_trace(PVR2_TRACE_CREG,"pvr2_context_exit(id=%p) outside",mp);
	117	mutex_unlock(&mp->mutex);
	118	if (destroy_flag) pvr2_context_destroy(mp);
	119	}
	120
	121
	122	static void pvr2_context_run_checks(struct pvr2_context *mp)
	123	{
	124	struct pvr2_channel ch1,ch2;
	125	for (ch1 = mp->mc_first; ch1; ch1 = ch2) {
	126	ch2 = ch1->mc_next;
	127	if (ch1->check_func) {
	128	ch1->check_func(ch1);
	129	}
	130	}
	131	}
	132
	133
	134	void pvr2_context_disconnect(struct pvr2_context *mp)
	135	{
	136	pvr2_context_enter(mp); do {
	137	pvr2_hdw_disconnect(mp->hdw);
	138	mp->disconnect_flag = !0;
	139	pvr2_context_run_checks(mp);
	140	} while (0); pvr2_context_exit(mp);
	141	}
	142
	143
	144	void pvr2_channel_init(struct pvr2_channel cp,struct pvr2_context mp)
	145	{
	146	cp->hdw = mp->hdw;
	147	cp->mc_head = mp;
a0fd1cb1	148	cp->mc_next = NULL;
d855497e MI	149	cp->mc_prev = mp->mc_last;
	150	if (mp->mc_last) {
	151	mp->mc_last->mc_next = cp;
	152	} else {
	153	mp->mc_first = cp;
	154	}
	155	mp->mc_last = cp;
	156	}
	157
	158
	159	static void pvr2_channel_disclaim_stream(struct pvr2_channel *cp)
	160	{
	161	if (!cp->stream) return;
	162	pvr2_stream_kill(cp->stream->stream);
a0fd1cb1 MI	163	cp->stream->user = NULL;
a0fd1cb1 MI	164	cp->stream = NULL;
d855497e MI	165	}
	166
	167
	168	void pvr2_channel_done(struct pvr2_channel *cp)
	169	{
	170	struct pvr2_context *mp = cp->mc_head;
	171	pvr2_channel_disclaim_stream(cp);
	172	if (cp->mc_next) {
	173	cp->mc_next->mc_prev = cp->mc_prev;
	174	} else {
	175	mp->mc_last = cp->mc_prev;
	176	}
	177	if (cp->mc_prev) {
	178	cp->mc_prev->mc_next = cp->mc_next;
	179	} else {
	180	mp->mc_first = cp->mc_next;
	181	}
a0fd1cb1	182	cp->hdw = NULL;
d855497e MI	183	}
	184
	185
	186	int pvr2_channel_claim_stream(struct pvr2_channel *cp,
	187	struct pvr2_context_stream *sp)
	188	{
	189	int code = 0;
	190	pvr2_context_enter(cp->mc_head); do {
	191	if (sp == cp->stream) break;
	192	if (sp->user) {
	193	code = -EBUSY;
	194	break;
	195	}
	196	pvr2_channel_disclaim_stream(cp);
	197	if (!sp) break;
	198	sp->user = cp;
	199	cp->stream = sp;
	200	} while (0); pvr2_context_exit(cp->mc_head);
	201	return code;
	202	}
	203
	204
	205	// This is the marker for the real beginning of a legitimate mpeg2 stream.
	206	static char stream_sync_key[] = {
	207	0x00, 0x00, 0x01, 0xba,
	208	};
	209
	210	struct pvr2_ioread *pvr2_channel_create_mpeg_stream(
	211	struct pvr2_context_stream *sp)
	212	{
	213	struct pvr2_ioread *cp;
	214	cp = pvr2_ioread_create();
a0fd1cb1	215	if (!cp) return NULL;
d855497e MI	216	pvr2_ioread_setup(cp,sp->stream);
	217	pvr2_ioread_set_sync_key(cp,stream_sync_key,sizeof(stream_sync_key));
	218	return cp;
	219	}
	220
	221
	222	/*
	223	Stuff for Emacs to see, in order to encourage consistent editing style:
	224	* Local Variables: *
	225	* mode: c *
	226	* fill-column: 75 *
	227	* tab-width: 8 *
	228	* c-basic-offset: 8 *
	229	* End: *
	230	*/