[mirror_ubuntu-artful-kernel.git] / drivers / media / pci / 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.
 *
 * ------------------------------------------------------------------------
 */

#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 <linux/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;
			}

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