[net-next-2.6.git] / drivers / media / video / zoran / videocodec.c

/*
 * VIDEO MOTION CODECs internal API for video devices
 *
 * Interface for MJPEG (and maybe later MPEG/WAVELETS) codec's
 * bound to a master device.
 *
 * (c) 2002 Wolfgang Scherr <scherr@net4you.at>
 *
 * $Id: videocodec.c,v 1.1.2.8 2003/03/29 07:16:04 rbultje Exp $
 *
 * ------------------------------------------------------------------------
 *
 * 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, or
 * (at your option) any later version.
 *
 * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * ------------------------------------------------------------------------
 */

#define VIDEOCODEC_VERSION "v0.2"

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/slab.h>

// kernel config is here (procfs flag)

#ifdef CONFIG_PROC_FS
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>
#endif

#include "videocodec.h"

static int debug;
module_param(debug, int, 0);
MODULE_PARM_DESC(debug, "Debug level (0-4)");

#define dprintk(num, format, args...) \
	do { \
		if (debug >= num) \
			printk(format, ##args); \
	} while (0)

struct attached_list {
	struct videocodec *codec;
	struct attached_list *next;
};

struct codec_list {
	const struct videocodec *codec;
	int attached;
	struct attached_list *list;
	struct codec_list *next;
};

static struct codec_list *codeclist_top = NULL;

/* ================================================= */
/* function prototypes of the master/slave interface */
/* ================================================= */

struct videocodec *
videocodec_attach (struct videocodec_master *master)
{
	struct codec_list *h = codeclist_top;
	struct attached_list *a, *ptr;
	struct videocodec *codec;
	int res;

	if (!master) {
		dprintk(1, KERN_ERR "videocodec_attach: no data\n");
		return NULL;
	}

	dprintk(2,
		"videocodec_attach: '%s', flags %lx, magic %lx\n",
		master->name, master->flags, master->magic);

	if (!h) {
		dprintk(1,
			KERN_ERR
			"videocodec_attach: no device available\n");
		return NULL;
	}

	while (h) {
		// attach only if the slave has at least the flags
		// expected by the master
		if ((master->flags & h->codec->flags) == master->flags) {
			dprintk(4, "videocodec_attach: try '%s'\n",
				h->codec->name);

			if (!try_module_get(h->codec->owner))
				return NULL;

			codec = kmemdup(h->codec, sizeof(struct videocodec),
					GFP_KERNEL);
			if (!codec) {
				dprintk(1,
					KERN_ERR
					"videocodec_attach: no mem\n");
				goto out_module_put;
			}

			snprintf(codec->name, sizeof(codec->name),
				 "%s[%d]", codec->name, h->attached);
			codec->master_data = master;
			res = codec->setup(codec);
			if (res == 0) {
				dprintk(3, "videocodec_attach '%s'\n",
					codec->name);
				ptr = kzalloc(sizeof(struct attached_list), GFP_KERNEL);
				if (!ptr) {
					dprintk(1,
						KERN_ERR
						"videocodec_attach: no memory\n");
					goto out_kfree;
				}
				ptr->codec = codec;

				a = h->list;
				if (!a) {
					h->list = ptr;
					dprintk(4,
						"videocodec: first element\n");
				} else {
					while (a->next)
						a = a->next;	// find end
					a->next = ptr;
					dprintk(4,
						"videocodec: in after '%s'\n",
						h->codec->name);
				}

				h->attached += 1;
				return codec;
			} else {
				kfree(codec);
			}
		}
		h = h->next;
	}

	dprintk(1, KERN_ERR "videocodec_attach: no codec found!\n");
	return NULL;

 out_module_put:
	module_put(h->codec->owner);
 out_kfree:
	kfree(codec);
	return NULL;
}

int
videocodec_detach (struct videocodec *codec)
{
	struct codec_list *h = codeclist_top;
	struct attached_list *a, *prev;
	int res;

	if (!codec) {
		dprintk(1, KERN_ERR "videocodec_detach: no data\n");
		return -EINVAL;
	}

	dprintk(2,
		"videocodec_detach: '%s', type: %x, flags %lx, magic %lx\n",
		codec->name, codec->type, codec->flags, codec->magic);

	if (!h) {
		dprintk(1,
			KERN_ERR "videocodec_detach: no device left...\n");
		return -ENXIO;
	}

	while (h) {
		a = h->list;
		prev = NULL;
		while (a) {
			if (codec == a->codec) {
				res = a->codec->unset(a->codec);
				if (res >= 0) {
					dprintk(3,
						"videocodec_detach: '%s'\n",
						a->codec->name);
					a->codec->master_data = NULL;
				} else {
					dprintk(1,
						KERN_ERR
						"videocodec_detach: '%s'\n",
						a->codec->name);
					a->codec->master_data = NULL;
				}
				if (prev == NULL) {
					h->list = a->next;
					dprintk(4,
						"videocodec: delete first\n");
				} else {
					prev->next = a->next;
					dprintk(4,
						"videocodec: delete middle\n");
				}
				module_put(a->codec->owner);
				kfree(a->codec);
				kfree(a);
				h->attached -= 1;
				return 0;
			}
			prev = a;
			a = a->next;
		}
		h = h->next;
	}

	dprintk(1, KERN_ERR "videocodec_detach: given codec not found!\n");
	return -EINVAL;
}

int
videocodec_register (const struct videocodec *codec)
{
	struct codec_list *ptr, *h = codeclist_top;

	if (!codec) {
		dprintk(1, KERN_ERR "videocodec_register: no data!\n");
		return -EINVAL;
	}

	dprintk(2,
		"videocodec: register '%s', type: %x, flags %lx, magic %lx\n",
		codec->name, codec->type, codec->flags, codec->magic);

	ptr = kzalloc(sizeof(struct codec_list), GFP_KERNEL);
	if (!ptr) {
		dprintk(1, KERN_ERR "videocodec_register: no memory\n");
		return -ENOMEM;
	}
	ptr->codec = codec;

	if (!h) {
		codeclist_top = ptr;
		dprintk(4, "videocodec: hooked in as first element\n");
	} else {
		while (h->next)
			h = h->next;	// find the end
		h->next = ptr;
		dprintk(4, "videocodec: hooked in after '%s'\n",
			h->codec->name);
	}

	return 0;
}

int
videocodec_unregister (const struct videocodec *codec)
{
	struct codec_list *prev = NULL, *h = codeclist_top;

	if (!codec) {
		dprintk(1, KERN_ERR "videocodec_unregister: no data!\n");
		return -EINVAL;
	}

	dprintk(2,
		"videocodec: unregister '%s', type: %x, flags %lx, magic %lx\n",
		codec->name, codec->type, codec->flags, codec->magic);

	if (!h) {
		dprintk(1,
			KERN_ERR
			"videocodec_unregister: no device left...\n");
		return -ENXIO;
	}

	while (h) {
		if (codec == h->codec) {
			if (h->attached) {
				dprintk(1,
					KERN_ERR
					"videocodec: '%s' is used\n",
					h->codec->name);
				return -EBUSY;
			}
			dprintk(3, "videocodec: unregister '%s' is ok.\n",
				h->codec->name);
			if (prev == NULL) {
				codeclist_top = h->next;
				dprintk(4,
					"videocodec: delete first element\n");
			} else {
				prev->next = h->next;
				dprintk(4,
					"videocodec: delete middle element\n");
			}
			kfree(h);
			return 0;
		}
		prev = h;
		h = h->next;
	}

	dprintk(1,
		KERN_ERR
		"videocodec_unregister: given codec not found!\n");
	return -EINVAL;
}

#ifdef CONFIG_PROC_FS
static int proc_videocodecs_show(struct seq_file *m, void *v)
{
	struct codec_list *h = codeclist_top;
	struct attached_list *a;

	seq_printf(m, "<S>lave or attached <M>aster name  type flags    magic    ");
	seq_printf(m, "(connected as)\n");

	h = codeclist_top;
	while (h) {
		seq_printf(m, "S %32s %04x %08lx %08lx (TEMPLATE)\n",
			      h->codec->name, h->codec->type,
			      h->codec->flags, h->codec->magic);
		a = h->list;
		while (a) {
			seq_printf(m, "M %32s %04x %08lx %08lx (%s)\n",
				      a->codec->master_data->name,
				      a->codec->master_data->type,
				      a->codec->master_data->flags,
				      a->codec->master_data->magic,
				      a->codec->name);
			a = a->next;
		}
		h = h->next;
	}

	return 0;
}

static int proc_videocodecs_open(struct inode *inode, struct file *file)
{
	return single_open(file, proc_videocodecs_show, NULL);
}

static const struct file_operations videocodecs_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= proc_videocodecs_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};
#endif

/* ===================== */
/* hook in driver module */
/* ===================== */
static int __init
videocodec_init (void)
{
#ifdef CONFIG_PROC_FS
	static struct proc_dir_entry *videocodec_proc_entry;
#endif

	printk(KERN_INFO "Linux video codec intermediate layer: %s\n",
	       VIDEOCODEC_VERSION);

#ifdef CONFIG_PROC_FS
	videocodec_proc_entry = proc_create("videocodecs", 0, NULL, &videocodecs_proc_fops);
	if (!videocodec_proc_entry) {
		dprintk(1, KERN_ERR "videocodec: can't init procfs.\n");
	}
#endif
	return 0;
}

static void __exit
videocodec_exit (void)
{
#ifdef CONFIG_PROC_FS
	remove_proc_entry("videocodecs", NULL);
#endif
}

EXPORT_SYMBOL(videocodec_attach);
EXPORT_SYMBOL(videocodec_detach);
EXPORT_SYMBOL(videocodec_register);
EXPORT_SYMBOL(videocodec_unregister);

module_init(videocodec_init);
module_exit(videocodec_exit);

MODULE_AUTHOR("Wolfgang Scherr <scherr@net4you.at>");
MODULE_DESCRIPTION("Intermediate API module for video codecs "
		   VIDEOCODEC_VERSION);
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* VIDEO MOTION CODECs internal API for video devices
	3	*
	4	* Interface for MJPEG (and maybe later MPEG/WAVELETS) codec's
	5	* bound to a master device.
	6	*
	7	* (c) 2002 Wolfgang Scherr <scherr@net4you.at>
	8	*
	9	* $Id: videocodec.c,v 1.1.2.8 2003/03/29 07:16:04 rbultje Exp $
	10	*
	11	* ------------------------------------------------------------------------
	12	*
	13	* This program is free software; you can redistribute it and/or modify
	14	* it under the terms of the GNU General Public License as published by
	15	* the Free Software Foundation; either version 2 of the License, or
	16	* (at your option) any later version.
	17	*
	18	* This program is distributed in the hope that it will be useful,
	19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	21	* GNU General Public License for more details.
	22	*
	23	* You should have received a copy of the GNU General Public License
	24	* along with this program; if not, write to the Free Software
	25	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	26	*
	27	* ------------------------------------------------------------------------
	28	*/
	29
	30	#define VIDEOCODEC_VERSION "v0.2"
	31
	32	#include <linux/kernel.h>
	33	#include <linux/module.h>
	34	#include <linux/init.h>
	35	#include <linux/types.h>
	36	#include <linux/slab.h>
	37
	38	// kernel config is here (procfs flag)
1da177e4 LT	39
	40	#ifdef CONFIG_PROC_FS
	41	#include <linux/proc_fs.h>
9faa2d75	42	#include <linux/seq_file.h>
1da177e4 LT	43	#include <asm/uaccess.h>
	44	#endif
	45
	46	#include "videocodec.h"
	47
ff699e6b	48	static int debug;
1da177e4 LT	49	module_param(debug, int, 0);
	50	MODULE_PARM_DESC(debug, "Debug level (0-4)");
	51
	52	#define dprintk(num, format, args...) \
	53	do { \
	54	if (debug >= num) \
	55	printk(format, ##args); \
	56	} while (0)
	57
	58	struct attached_list {
	59	struct videocodec *codec;
	60	struct attached_list *next;
	61	};
	62
	63	struct codec_list {
	64	const struct videocodec *codec;
	65	int attached;
	66	struct attached_list *list;
	67	struct codec_list *next;
	68	};
	69
	70	static struct codec_list *codeclist_top = NULL;
	71
	72	/* ================================================= */
	73	/* function prototypes of the master/slave interface */
	74	/* ================================================= */
	75
	76	struct videocodec *
	77	videocodec_attach (struct videocodec_master *master)
	78	{
	79	struct codec_list *h = codeclist_top;
	80	struct attached_list a, ptr;
	81	struct videocodec *codec;
	82	int res;
	83
	84	if (!master) {
	85	dprintk(1, KERN_ERR "videocodec_attach: no data\n");
	86	return NULL;
	87	}
	88
	89	dprintk(2,
22c4a4e9 MCC	90	"videocodec_attach: '%s', flags %lx, magic %lx\n",
22c4a4e9 MCC	91	master->name, master->flags, master->magic);
1da177e4 LT	92
	93	if (!h) {
	94	dprintk(1,
	95	KERN_ERR
	96	"videocodec_attach: no device available\n");
	97	return NULL;
	98	}
	99
	100	while (h) {
	101	// attach only if the slave has at least the flags
	102	// expected by the master
	103	if ((master->flags & h->codec->flags) == master->flags) {
	104	dprintk(4, "videocodec_attach: try '%s'\n",
	105	h->codec->name);
	106
	107	if (!try_module_get(h->codec->owner))
	108	return NULL;
	109
7a12f4b5 JL	110	codec = kmemdup(h->codec, sizeof(struct videocodec),
7a12f4b5 JL	111	GFP_KERNEL);
1da177e4 LT	112	if (!codec) {
	113	dprintk(1,
	114	KERN_ERR
	115	"videocodec_attach: no mem\n");
	116	goto out_module_put;
	117	}
1da177e4 LT	118
	119	snprintf(codec->name, sizeof(codec->name),
	120	"%s[%d]", codec->name, h->attached);
	121	codec->master_data = master;
	122	res = codec->setup(codec);
	123	if (res == 0) {
	124	dprintk(3, "videocodec_attach '%s'\n",
	125	codec->name);
7408187d	126	ptr = kzalloc(sizeof(struct attached_list), GFP_KERNEL);
1da177e4 LT	127	if (!ptr) {
	128	dprintk(1,
	129	KERN_ERR
	130	"videocodec_attach: no memory\n");
	131	goto out_kfree;
	132	}
1da177e4 LT	133	ptr->codec = codec;
	134
	135	a = h->list;
	136	if (!a) {
	137	h->list = ptr;
	138	dprintk(4,
	139	"videocodec: first element\n");
	140	} else {
	141	while (a->next)
	142	a = a->next; // find end
	143	a->next = ptr;
	144	dprintk(4,
	145	"videocodec: in after '%s'\n",
	146	h->codec->name);
	147	}
	148
	149	h->attached += 1;
	150	return codec;
	151	} else {
	152	kfree(codec);
	153	}
	154	}
	155	h = h->next;
	156	}
	157
	158	dprintk(1, KERN_ERR "videocodec_attach: no codec found!\n");
	159	return NULL;
	160
	161	out_module_put:
	162	module_put(h->codec->owner);
	163	out_kfree:
	164	kfree(codec);
	165	return NULL;
	166	}
	167
	168	int
	169	videocodec_detach (struct videocodec *codec)
	170	{
	171	struct codec_list *h = codeclist_top;
	172	struct attached_list a, prev;
	173	int res;
	174
	175	if (!codec) {
	176	dprintk(1, KERN_ERR "videocodec_detach: no data\n");
	177	return -EINVAL;
	178	}
	179
	180	dprintk(2,
	181	"videocodec_detach: '%s', type: %x, flags %lx, magic %lx\n",
	182	codec->name, codec->type, codec->flags, codec->magic);
	183
	184	if (!h) {
	185	dprintk(1,
	186	KERN_ERR "videocodec_detach: no device left...\n");
	187	return -ENXIO;
	188	}
	189
	190	while (h) {
	191	a = h->list;
	192	prev = NULL;
	193	while (a) {
	194	if (codec == a->codec) {
	195	res = a->codec->unset(a->codec);
	196	if (res >= 0) {
197	dprintk(3,
198	"videocodec_detach: '%s'\n",
199	a->codec->name);
200	a->codec->master_data = NULL;
201	} else {
202	dprintk(1,
203	KERN_ERR
204	"videocodec_detach: '%s'\n",
205	a->codec->name);
206	a->codec->master_data = NULL;
207	}
208	if (prev == NULL) {
209	h->list = a->next;
210	dprintk(4,
211	"videocodec: delete first\n");
212	} else {
213	prev->next = a->next;
214	dprintk(4,
215	"videocodec: delete middle\n");
216	}
217	module_put(a->codec->owner);
218	kfree(a->codec);
219	kfree(a);
220	h->attached -= 1;
221	return 0;
222	}
223	prev = a;
224	a = a->next;
225	}
226	h = h->next;
227	}
228
229	dprintk(1, KERN_ERR "videocodec_detach: given codec not found!\n");
230	return -EINVAL;
231	}
232
233	int
234	videocodec_register (const struct videocodec *codec)
235	{
236	struct codec_list ptr, h = codeclist_top;
237
238	if (!codec) {
239	dprintk(1, KERN_ERR "videocodec_register: no data!\n");
240	return -EINVAL;
241	}
242
243	dprintk(2,
244	"videocodec: register '%s', type: %x, flags %lx, magic %lx\n",
245	codec->name, codec->type, codec->flags, codec->magic);
246
7408187d	247	ptr = kzalloc(sizeof(struct codec_list), GFP_KERNEL);
1da177e4 LT	248	if (!ptr) {
	249	dprintk(1, KERN_ERR "videocodec_register: no memory\n");
	250	return -ENOMEM;
	251	}
1da177e4 LT	252	ptr->codec = codec;
	253
	254	if (!h) {
	255	codeclist_top = ptr;
	256	dprintk(4, "videocodec: hooked in as first element\n");
	257	} else {
	258	while (h->next)
	259	h = h->next; // find the end
	260	h->next = ptr;
	261	dprintk(4, "videocodec: hooked in after '%s'\n",
	262	h->codec->name);
	263	}
	264
	265	return 0;
	266	}
	267
	268	int
	269	videocodec_unregister (const struct videocodec *codec)
	270	{
	271	struct codec_list prev = NULL, h = codeclist_top;
	272
	273	if (!codec) {
	274	dprintk(1, KERN_ERR "videocodec_unregister: no data!\n");
	275	return -EINVAL;
	276	}
	277
	278	dprintk(2,
	279	"videocodec: unregister '%s', type: %x, flags %lx, magic %lx\n",
	280	codec->name, codec->type, codec->flags, codec->magic);
	281
	282	if (!h) {
	283	dprintk(1,
	284	KERN_ERR
	285	"videocodec_unregister: no device left...\n");
	286	return -ENXIO;
	287	}
	288
	289	while (h) {
	290	if (codec == h->codec) {
	291	if (h->attached) {
	292	dprintk(1,
	293	KERN_ERR
	294	"videocodec: '%s' is used\n",
	295	h->codec->name);
	296	return -EBUSY;
	297	}
	298	dprintk(3, "videocodec: unregister '%s' is ok.\n",
	299	h->codec->name);
	300	if (prev == NULL) {
	301	codeclist_top = h->next;
	302	dprintk(4,
	303	"videocodec: delete first element\n");
	304	} else {
	305	prev->next = h->next;
	306	dprintk(4,
	307	"videocodec: delete middle element\n");
	308	}
	309	kfree(h);
	310	return 0;
	311	}
	312	prev = h;
	313	h = h->next;
	314	}
	315
316	dprintk(1,
317	KERN_ERR
318	"videocodec_unregister: given codec not found!\n");
319	return -EINVAL;
320	}
321
322	#ifdef CONFIG_PROC_FS
9faa2d75	323	static int proc_videocodecs_show(struct seq_file m, void v)
1da177e4 LT	324	{
	325	struct codec_list *h = codeclist_top;
	326	struct attached_list *a;
1da177e4	327
9faa2d75 AD	328	seq_printf(m, "<S>lave or attached <M>aster name type flags magic ");
9faa2d75 AD	329	seq_printf(m, "(connected as)\n");
1da177e4 LT	330
	331	h = codeclist_top;
	332	while (h) {
9faa2d75	333	seq_printf(m, "S %32s %04x %08lx %08lx (TEMPLATE)\n",
1da177e4 LT	334	h->codec->name, h->codec->type,
	335	h->codec->flags, h->codec->magic);
	336	a = h->list;
	337	while (a) {
9faa2d75	338	seq_printf(m, "M %32s %04x %08lx %08lx (%s)\n",
1da177e4 LT	339	a->codec->master_data->name,
	340	a->codec->master_data->type,
	341	a->codec->master_data->flags,
	342	a->codec->master_data->magic,
	343	a->codec->name);
	344	a = a->next;
	345	}
	346	h = h->next;
	347	}
	348
9faa2d75	349	return 0;
1da177e4 LT	350	}
1da177e4 LT	351
9faa2d75	352	static int proc_videocodecs_open(struct inode inode, struct file file)
1da177e4	353	{
9faa2d75	354	return single_open(file, proc_videocodecs_show, NULL);
1da177e4	355	}
9faa2d75 AD	356
	357	static const struct file_operations videocodecs_proc_fops = {
	358	.owner = THIS_MODULE,
	359	.open = proc_videocodecs_open,
	360	.read = seq_read,
	361	.llseek = seq_lseek,
	362	.release = single_release,
	363	};
1da177e4 LT	364	#endif
	365
	366	/* ===================== */
	367	/* hook in driver module */
	368	/* ===================== */
	369	static int __init
	370	videocodec_init (void)
	371	{
	372	#ifdef CONFIG_PROC_FS
	373	static struct proc_dir_entry *videocodec_proc_entry;
	374	#endif
	375
	376	printk(KERN_INFO "Linux video codec intermediate layer: %s\n",
	377	VIDEOCODEC_VERSION);
	378
	379	#ifdef CONFIG_PROC_FS
9faa2d75 AD	380	videocodec_proc_entry = proc_create("videocodecs", 0, NULL, &videocodecs_proc_fops);
9faa2d75 AD	381	if (!videocodec_proc_entry) {
1da177e4 LT	382	dprintk(1, KERN_ERR "videocodec: can't init procfs.\n");
	383	}
	384	#endif
	385	return 0;
	386	}
	387
	388	static void __exit
	389	videocodec_exit (void)
	390	{
	391	#ifdef CONFIG_PROC_FS
	392	remove_proc_entry("videocodecs", NULL);
1da177e4 LT	393	#endif
	394	}
	395
	396	EXPORT_SYMBOL(videocodec_attach);
	397	EXPORT_SYMBOL(videocodec_detach);
	398	EXPORT_SYMBOL(videocodec_register);
	399	EXPORT_SYMBOL(videocodec_unregister);
	400
	401	module_init(videocodec_init);
	402	module_exit(videocodec_exit);
	403
	404	MODULE_AUTHOR("Wolfgang Scherr <scherr@net4you.at>");
	405	MODULE_DESCRIPTION("Intermediate API module for video codecs "
	406	VIDEOCODEC_VERSION);
	407	MODULE_LICENSE("GPL");