[linux-2.6-block.git] / drivers / isdn / mISDN / dsp_pipeline.c

/*
 * dsp_pipeline.c: pipelined audio processing
 *
 * Copyright (C) 2007, Nadi Sarrar
 *
 * Nadi Sarrar <nadi@beronet.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, 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., 59
 * Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/string.h>
#include <linux/mISDNif.h>
#include <linux/mISDNdsp.h>
#include "dsp.h"
#include "dsp_hwec.h"

/* uncomment for debugging */
/*#define PIPELINE_DEBUG*/

struct dsp_pipeline_entry {
	struct mISDN_dsp_element *elem;
	void                *p;
	struct list_head     list;
};
struct dsp_element_entry {
	struct mISDN_dsp_element *elem;
	struct device	     dev;
	struct list_head     list;
};

static LIST_HEAD(dsp_elements);

/* sysfs */
static struct class *elements_class;

static ssize_t
attr_show_args(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct mISDN_dsp_element *elem = dev_get_drvdata(dev);
	int i;
	char *p = buf;

	*buf = 0;
	for (i = 0; i < elem->num_args; i++)
		p += sprintf(p, "Name:        %s\n%s%s%sDescription: %s\n\n",
			  elem->args[i].name,
			  elem->args[i].def ? "Default:     " : "",
			  elem->args[i].def ? elem->args[i].def : "",
			  elem->args[i].def ? "\n" : "",
			  elem->args[i].desc);

	return p - buf;
}

static struct device_attribute element_attributes[] = {
	__ATTR(args, 0444, attr_show_args, NULL),
};

static void
mISDN_dsp_dev_release(struct device *dev)
{
	struct dsp_element_entry *entry =
		container_of(dev, struct dsp_element_entry, dev);
	list_del(&entry->list);
	kfree(entry);
}

int mISDN_dsp_element_register(struct mISDN_dsp_element *elem)
{
	struct dsp_element_entry *entry;
	int ret, i;

	if (!elem)
		return -EINVAL;

	entry = kzalloc(sizeof(struct dsp_element_entry), GFP_ATOMIC);
	if (!entry)
		return -ENOMEM;

	entry->elem = elem;

	entry->dev.class = elements_class;
	entry->dev.release = mISDN_dsp_dev_release;
	dev_set_drvdata(&entry->dev, elem);
	dev_set_name(&entry->dev, elem->name);
	ret = device_register(&entry->dev);
	if (ret) {
		printk(KERN_ERR "%s: failed to register %s\n",
			__func__, elem->name);
		goto err1;
	}
	list_add_tail(&entry->list, &dsp_elements);

	for (i = 0; i < ARRAY_SIZE(element_attributes); ++i) {
		ret = device_create_file(&entry->dev,
				&element_attributes[i]);
		if (ret) {
			printk(KERN_ERR "%s: failed to create device file\n",
				__func__);
			goto err2;
		}
	}

#ifdef PIPELINE_DEBUG
	printk(KERN_DEBUG "%s: %s registered\n", __func__, elem->name);
#endif

	return 0;

err2:
	device_unregister(&entry->dev);
	return ret;
err1:
	kfree(entry);
	return ret;
}
EXPORT_SYMBOL(mISDN_dsp_element_register);

void mISDN_dsp_element_unregister(struct mISDN_dsp_element *elem)
{
	struct dsp_element_entry *entry, *n;

	if (!elem)
		return;

	list_for_each_entry_safe(entry, n, &dsp_elements, list)
		if (entry->elem == elem) {
			device_unregister(&entry->dev);
#ifdef PIPELINE_DEBUG
			printk(KERN_DEBUG "%s: %s unregistered\n",
				__func__, elem->name);
#endif
			return;
		}
	printk(KERN_ERR "%s: element %s not in list.\n", __func__, elem->name);
}
EXPORT_SYMBOL(mISDN_dsp_element_unregister);

int dsp_pipeline_module_init(void)
{
	elements_class = class_create(THIS_MODULE, "dsp_pipeline");
	if (IS_ERR(elements_class))
		return PTR_ERR(elements_class);

#ifdef PIPELINE_DEBUG
	printk(KERN_DEBUG "%s: dsp pipeline module initialized\n", __func__);
#endif

	dsp_hwec_init();

	return 0;
}

void dsp_pipeline_module_exit(void)
{
	struct dsp_element_entry *entry, *n;

	dsp_hwec_exit();

	class_destroy(elements_class);

	list_for_each_entry_safe(entry, n, &dsp_elements, list) {
		list_del(&entry->list);
		printk(KERN_WARNING "%s: element was still registered: %s\n",
			__func__, entry->elem->name);
		kfree(entry);
	}

#ifdef PIPELINE_DEBUG
	printk(KERN_DEBUG "%s: dsp pipeline module exited\n", __func__);
#endif
}

int dsp_pipeline_init(struct dsp_pipeline *pipeline)
{
	if (!pipeline)
		return -EINVAL;

	INIT_LIST_HEAD(&pipeline->list);

#ifdef PIPELINE_DEBUG
	printk(KERN_DEBUG "%s: dsp pipeline ready\n", __func__);
#endif

	return 0;
}

static inline void _dsp_pipeline_destroy(struct dsp_pipeline *pipeline)
{
	struct dsp_pipeline_entry *entry, *n;

	list_for_each_entry_safe(entry, n, &pipeline->list, list) {
		list_del(&entry->list);
		if (entry->elem == dsp_hwec)
			dsp_hwec_disable(container_of(pipeline, struct dsp,
				pipeline));
		else
			entry->elem->free(entry->p);
		kfree(entry);
	}
}

void dsp_pipeline_destroy(struct dsp_pipeline *pipeline)
{

	if (!pipeline)
		return;

	_dsp_pipeline_destroy(pipeline);

#ifdef PIPELINE_DEBUG
	printk(KERN_DEBUG "%s: dsp pipeline destroyed\n", __func__);
#endif
}

int dsp_pipeline_build(struct dsp_pipeline *pipeline, const char *cfg)
{
	int len, incomplete = 0, found = 0;
	char *dup, *tok, *name, *args;
	struct dsp_element_entry *entry, *n;
	struct dsp_pipeline_entry *pipeline_entry;
	struct mISDN_dsp_element *elem;

	if (!pipeline)
		return -EINVAL;

	if (!list_empty(&pipeline->list))
		_dsp_pipeline_destroy(pipeline);

	if (!cfg)
		return 0;

	len = strlen(cfg);
	if (!len)
		return 0;

	dup = kmalloc(len + 1, GFP_ATOMIC);
	if (!dup)
		return 0;
	strcpy(dup, cfg);
	while ((tok = strsep(&dup, "|"))) {
		if (!strlen(tok))
			continue;
		name = strsep(&tok, "(");
		args = strsep(&tok, ")");
		if (args && !*args)
			args = NULL;

		list_for_each_entry_safe(entry, n, &dsp_elements, list)
			if (!strcmp(entry->elem->name, name)) {
				elem = entry->elem;

				pipeline_entry = kmalloc(sizeof(struct
					dsp_pipeline_entry), GFP_ATOMIC);
				if (!pipeline_entry) {
					printk(KERN_ERR "%s: failed to add "
					    "entry to pipeline: %s (out of "
					    "memory)\n", __func__, elem->name);
					incomplete = 1;
					goto _out;
				}
				pipeline_entry->elem = elem;

				if (elem == dsp_hwec) {
					/* This is a hack to make the hwec
					   available as a pipeline module */
					dsp_hwec_enable(container_of(pipeline,
						struct dsp, pipeline), args);
					list_add_tail(&pipeline_entry->list,
						&pipeline->list);
				} else {
					pipeline_entry->p = elem->new(args);
					if (pipeline_entry->p) {
						list_add_tail(&pipeline_entry->
							list, &pipeline->list);
#ifdef PIPELINE_DEBUG
						printk(KERN_DEBUG "%s: created "
						    "instance of %s%s%s\n",
						    __func__, name, args ?
						    " with args " : "", args ?
						    args : "");
#endif
					} else {
						printk(KERN_ERR "%s: failed "
						  "to add entry to pipeline: "
						  "%s (new() returned NULL)\n",
						  __func__, elem->name);
						kfree(pipeline_entry);
						incomplete = 1;
					}
				}
				found = 1;
				break;
			}

		if (found)
			found = 0;
		else {
			printk(KERN_ERR "%s: element not found, skipping: "
				"%s\n", __func__, name);
			incomplete = 1;
		}
	}

_out:
	if (!list_empty(&pipeline->list))
		pipeline->inuse = 1;
	else
		pipeline->inuse = 0;

#ifdef PIPELINE_DEBUG
	printk(KERN_DEBUG "%s: dsp pipeline built%s: %s\n",
		__func__, incomplete ? " incomplete" : "", cfg);
#endif
	kfree(dup);
	return 0;
}

void dsp_pipeline_process_tx(struct dsp_pipeline *pipeline, u8 *data, int len)
{
	struct dsp_pipeline_entry *entry;

	if (!pipeline)
		return;

	list_for_each_entry(entry, &pipeline->list, list)
		if (entry->elem->process_tx)
			entry->elem->process_tx(entry->p, data, len);
}

void dsp_pipeline_process_rx(struct dsp_pipeline *pipeline, u8 *data, int len,
	unsigned int txlen)
{
	struct dsp_pipeline_entry *entry;

	if (!pipeline)
		return;

	list_for_each_entry_reverse(entry, &pipeline->list, list)
		if (entry->elem->process_rx)
			entry->elem->process_rx(entry->p, data, len, txlen);
}
Commit	Line	Data
960366cf KK	1	/*
	2	* dsp_pipeline.c: pipelined audio processing
	3	*
	4	* Copyright (C) 2007, Nadi Sarrar
	5	*
	6	* Nadi Sarrar <nadi@beronet.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the Free
	10	* Software Foundation; either version 2 of the License, or (at your option)
	11	* any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful, but WITHOUT
	14	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	15	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	16	* more details.
	17	*
	18	* You should have received a copy of the GNU General Public License along with
	19	* this program; if not, write to the Free Software Foundation, Inc., 59
	20	* Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	21	*
	22	* The full GNU General Public License is included in this distribution in the
	23	* file called LICENSE.
	24	*
	25	*/
	26
	27	#include <linux/kernel.h>
5a0e3ad6	28	#include <linux/slab.h>
960366cf KK	29	#include <linux/list.h>
	30	#include <linux/string.h>
	31	#include <linux/mISDNif.h>
	32	#include <linux/mISDNdsp.h>
	33	#include "dsp.h"
	34	#include "dsp_hwec.h"
	35
	36	/* uncomment for debugging */
	37	/#define PIPELINE_DEBUG/
	38
	39	struct dsp_pipeline_entry {
	40	struct mISDN_dsp_element *elem;
	41	void *p;
	42	struct list_head list;
	43	};
	44	struct dsp_element_entry {
	45	struct mISDN_dsp_element *elem;
	46	struct device dev;
	47	struct list_head list;
	48	};
	49
	50	static LIST_HEAD(dsp_elements);
	51
	52	/* sysfs */
	53	static struct class *elements_class;
	54
	55	static ssize_t
	56	attr_show_args(struct device dev, struct device_attribute attr, char *buf)
	57	{
	58	struct mISDN_dsp_element *elem = dev_get_drvdata(dev);
1ce1513f KK	59	int i;
1ce1513f KK	60	char *p = buf;
960366cf KK	61
960366cf KK	62	*buf = 0;
1ce1513f KK	63	for (i = 0; i < elem->num_args; i++)
1ce1513f KK	64	p += sprintf(p, "Name: %s\n%s%s%sDescription: %s\n\n",
960366cf KK	65	elem->args[i].name,
	66	elem->args[i].def ? "Default: " : "",
	67	elem->args[i].def ? elem->args[i].def : "",
	68	elem->args[i].def ? "\n" : "",
	69	elem->args[i].desc);
	70
1ce1513f	71	return p - buf;
960366cf KK	72	}
	73
	74	static struct device_attribute element_attributes[] = {
	75	__ATTR(args, 0444, attr_show_args, NULL),
	76	};
	77
808a14a1 AE	78	static void
	79	mISDN_dsp_dev_release(struct device *dev)
	80	{
	81	struct dsp_element_entry *entry =
	82	container_of(dev, struct dsp_element_entry, dev);
	83	list_del(&entry->list);
	84	kfree(entry);
	85	}
	86
960366cf KK	87	int mISDN_dsp_element_register(struct mISDN_dsp_element *elem)
	88	{
	89	struct dsp_element_entry *entry;
	90	int ret, i;
	91
	92	if (!elem)
	93	return -EINVAL;
	94
400fd978	95	entry = kzalloc(sizeof(struct dsp_element_entry), GFP_ATOMIC);
960366cf KK	96	if (!entry)
	97	return -ENOMEM;
	98
	99	entry->elem = elem;
	100
	101	entry->dev.class = elements_class;
808a14a1	102	entry->dev.release = mISDN_dsp_dev_release;
960366cf	103	dev_set_drvdata(&entry->dev, elem);
0162f382	104	dev_set_name(&entry->dev, elem->name);
960366cf KK	105	ret = device_register(&entry->dev);
	106	if (ret) {
	107	printk(KERN_ERR "%s: failed to register %s\n",
	108	__func__, elem->name);
	109	goto err1;
	110	}
808a14a1	111	list_add_tail(&entry->list, &dsp_elements);
960366cf	112
21c150a6	113	for (i = 0; i < ARRAY_SIZE(element_attributes); ++i) {
960366cf KK	114	ret = device_create_file(&entry->dev,
	115	&element_attributes[i]);
	116	if (ret) {
	117	printk(KERN_ERR "%s: failed to create device file\n",
	118	__func__);
	119	goto err2;
	120	}
21c150a6	121	}
960366cf	122
808a14a1	123	#ifdef PIPELINE_DEBUG
960366cf	124	printk(KERN_DEBUG "%s: %s registered\n", __func__, elem->name);
808a14a1	125	#endif
960366cf KK	126
	127	return 0;
	128
	129	err2:
	130	device_unregister(&entry->dev);
808a14a1	131	return ret;
960366cf KK	132	err1:
	133	kfree(entry);
	134	return ret;
	135	}
	136	EXPORT_SYMBOL(mISDN_dsp_element_register);
	137
	138	void mISDN_dsp_element_unregister(struct mISDN_dsp_element *elem)
	139	{
	140	struct dsp_element_entry entry, n;
	141
	142	if (!elem)
	143	return;
	144
	145	list_for_each_entry_safe(entry, n, &dsp_elements, list)
	146	if (entry->elem == elem) {
960366cf	147	device_unregister(&entry->dev);
808a14a1	148	#ifdef PIPELINE_DEBUG
960366cf KK	149	printk(KERN_DEBUG "%s: %s unregistered\n",
960366cf KK	150	__func__, elem->name);
808a14a1	151	#endif
960366cf KK	152	return;
	153	}
	154	printk(KERN_ERR "%s: element %s not in list.\n", __func__, elem->name);
	155	}
	156	EXPORT_SYMBOL(mISDN_dsp_element_unregister);
	157
	158	int dsp_pipeline_module_init(void)
	159	{
	160	elements_class = class_create(THIS_MODULE, "dsp_pipeline");
	161	if (IS_ERR(elements_class))
	162	return PTR_ERR(elements_class);
	163
	164	#ifdef PIPELINE_DEBUG
	165	printk(KERN_DEBUG "%s: dsp pipeline module initialized\n", __func__);
	166	#endif
	167
	168	dsp_hwec_init();
	169
	170	return 0;
	171	}
	172
	173	void dsp_pipeline_module_exit(void)
	174	{
	175	struct dsp_element_entry entry, n;
	176
	177	dsp_hwec_exit();
	178
	179	class_destroy(elements_class);
	180
	181	list_for_each_entry_safe(entry, n, &dsp_elements, list) {
	182	list_del(&entry->list);
	183	printk(KERN_WARNING "%s: element was still registered: %s\n",
	184	__func__, entry->elem->name);
	185	kfree(entry);
	186	}
	187
808a14a1	188	#ifdef PIPELINE_DEBUG
960366cf	189	printk(KERN_DEBUG "%s: dsp pipeline module exited\n", __func__);
808a14a1	190	#endif
960366cf KK	191	}
	192
	193	int dsp_pipeline_init(struct dsp_pipeline *pipeline)
	194	{
	195	if (!pipeline)
	196	return -EINVAL;
	197
	198	INIT_LIST_HEAD(&pipeline->list);
	199
	200	#ifdef PIPELINE_DEBUG
	201	printk(KERN_DEBUG "%s: dsp pipeline ready\n", __func__);
	202	#endif
	203
	204	return 0;
	205	}
	206
	207	static inline void _dsp_pipeline_destroy(struct dsp_pipeline *pipeline)
	208	{
	209	struct dsp_pipeline_entry entry, n;
	210
	211	list_for_each_entry_safe(entry, n, &pipeline->list, list) {
	212	list_del(&entry->list);
	213	if (entry->elem == dsp_hwec)
	214	dsp_hwec_disable(container_of(pipeline, struct dsp,
	215	pipeline));
	216	else
	217	entry->elem->free(entry->p);
	218	kfree(entry);
	219	}
	220	}
	221
	222	void dsp_pipeline_destroy(struct dsp_pipeline *pipeline)
	223	{
	224
	225	if (!pipeline)
	226	return;
	227
	228	_dsp_pipeline_destroy(pipeline);
	229
	230	#ifdef PIPELINE_DEBUG
	231	printk(KERN_DEBUG "%s: dsp pipeline destroyed\n", __func__);
	232	#endif
	233	}
	234
	235	int dsp_pipeline_build(struct dsp_pipeline pipeline, const char cfg)
	236	{
	237	int len, incomplete = 0, found = 0;
	238	char dup, tok, name, args;
	239	struct dsp_element_entry entry, n;
	240	struct dsp_pipeline_entry *pipeline_entry;
	241	struct mISDN_dsp_element *elem;
	242
	243	if (!pipeline)
	244	return -EINVAL;
	245
	246	if (!list_empty(&pipeline->list))
	247	_dsp_pipeline_destroy(pipeline);
	248
	249	if (!cfg)
	250	return 0;
	251
	252	len = strlen(cfg);
	253	if (!len)
	254	return 0;
255
400fd978	256	dup = kmalloc(len + 1, GFP_ATOMIC);
960366cf KK	257	if (!dup)
	258	return 0;
	259	strcpy(dup, cfg);
	260	while ((tok = strsep(&dup, "\|"))) {
	261	if (!strlen(tok))
	262	continue;
	263	name = strsep(&tok, "(");
	264	args = strsep(&tok, ")");
	265	if (args && !*args)
bcf91745	266	args = NULL;
960366cf KK	267
	268	list_for_each_entry_safe(entry, n, &dsp_elements, list)
	269	if (!strcmp(entry->elem->name, name)) {
	270	elem = entry->elem;
	271
	272	pipeline_entry = kmalloc(sizeof(struct
400fd978	273	dsp_pipeline_entry), GFP_ATOMIC);
960366cf	274	if (!pipeline_entry) {
808a14a1	275	printk(KERN_ERR "%s: failed to add "
960366cf KK	276	"entry to pipeline: %s (out of "
	277	"memory)\n", __func__, elem->name);
	278	incomplete = 1;
	279	goto _out;
	280	}
	281	pipeline_entry->elem = elem;
	282
	283	if (elem == dsp_hwec) {
	284	/* This is a hack to make the hwec
	285	available as a pipeline module */
	286	dsp_hwec_enable(container_of(pipeline,
	287	struct dsp, pipeline), args);
	288	list_add_tail(&pipeline_entry->list,
	289	&pipeline->list);
	290	} else {
	291	pipeline_entry->p = elem->new(args);
	292	if (pipeline_entry->p) {
	293	list_add_tail(&pipeline_entry->
	294	list, &pipeline->list);
	295	#ifdef PIPELINE_DEBUG
	296	printk(KERN_DEBUG "%s: created "
	297	"instance of %s%s%s\n",
	298	__func__, name, args ?
	299	" with args " : "", args ?
	300	args : "");
	301	#endif
	302	} else {
808a14a1	303	printk(KERN_ERR "%s: failed "
960366cf KK	304	"to add entry to pipeline: "
	305	"%s (new() returned NULL)\n",
	306	__func__, elem->name);
	307	kfree(pipeline_entry);
	308	incomplete = 1;
	309	}
	310	}
	311	found = 1;
	312	break;
	313	}
	314
	315	if (found)
	316	found = 0;
	317	else {
808a14a1	318	printk(KERN_ERR "%s: element not found, skipping: "
960366cf KK	319	"%s\n", __func__, name);
	320	incomplete = 1;
	321	}
	322	}
	323
	324	_out:
	325	if (!list_empty(&pipeline->list))
	326	pipeline->inuse = 1;
	327	else
	328	pipeline->inuse = 0;
	329
	330	#ifdef PIPELINE_DEBUG
	331	printk(KERN_DEBUG "%s: dsp pipeline built%s: %s\n",
	332	__func__, incomplete ? " incomplete" : "", cfg);
	333	#endif
	334	kfree(dup);
	335	return 0;
	336	}
	337
	338	void dsp_pipeline_process_tx(struct dsp_pipeline pipeline, u8 data, int len)
	339	{
	340	struct dsp_pipeline_entry *entry;
	341
	342	if (!pipeline)
	343	return;
	344
	345	list_for_each_entry(entry, &pipeline->list, list)
	346	if (entry->elem->process_tx)
	347	entry->elem->process_tx(entry->p, data, len);
	348	}
	349
7cfa153d AE	350	void dsp_pipeline_process_rx(struct dsp_pipeline pipeline, u8 data, int len,
7cfa153d AE	351	unsigned int txlen)
960366cf KK	352	{
	353	struct dsp_pipeline_entry *entry;
	354
	355	if (!pipeline)
	356	return;
	357
	358	list_for_each_entry_reverse(entry, &pipeline->list, list)
	359	if (entry->elem->process_rx)
7cfa153d	360	entry->elem->process_rx(entry->p, data, len, txlen);
960366cf KK	361	}
	362
	363