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