![Karsten Keil](/assets/img/avatar_default.png)
Remove code rewriting a buffer by itself. This fix bug 12970 on bugzilla.kernel.org. Signed-off-by: Karsten Keil <keil@b1-systems.de>
363 lines
8.2 KiB
C
363 lines
8.2 KiB
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/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);
|
|
}
|
|
|
|
|