Add mISDN DSP

Enable support for digital audio processing capability.
This module may be used for special applications that require
cross connecting of bchannels, conferencing, dtmf decoding
echo cancelation, tone generation, and Blowfish encryption and
decryption.
It may use hardware features if available.

Signed-off-by: Karsten Keil <kkeil@suse.de>

1 files changed, 348 insertions, 0 deletions

diff --git a/drivers/isdn/mISDN/dsp_pipeline.c b/drivers/isdn/mISDN/dsp_pipeline.c
new file mode 100644
index 000000000000..850260ab57d0
--- /dev/null
+++ b/drivers/isdn/mISDN/dsp_pipeline.c
@@ -0,0 +1,348 @@
+/*
+ * 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);
+        ssize_t len = 0;
+        int i = 0;
+
+        *buf = 0;
+        for (; i < elem->num_args; ++i)
+                len = sprintf(buf, "%sName:        %s\n%s%s%sDescription: %s\n"
+                        "\n", buf,
+                          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 len;
+}
+
+static struct device_attribute element_attributes[] = {
+        __ATTR(args, 0444, attr_show_args, NULL),
+};
+
+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_KERNEL);
+        if (!entry)
+                return -ENOMEM;
+
+        entry->elem = elem;
+
+        entry->dev.class = elements_class;
+        dev_set_drvdata(&entry->dev, elem);
+        snprintf(entry->dev.bus_id, BUS_ID_SIZE, elem->name);
+        ret = device_register(&entry->dev);
+        if (ret) {
+                printk(KERN_ERR "%s: failed to register %s\n",
+                        __func__, elem->name);
+                goto err1;
+        }
+
+        for (i = 0; i < (sizeof(element_attributes)
+                / sizeof(struct device_attribute)); ++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;
+                }
+
+        list_add_tail(&entry->list, &dsp_elements);
+
+        printk(KERN_DEBUG "%s: %s registered\n", __func__, elem->name);
+
+        return 0;
+
+err2:
+        device_unregister(&entry->dev);
+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) {
+                        list_del(&entry->list);
+                        device_unregister(&entry->dev);
+                        kfree(entry);
+                        printk(KERN_DEBUG "%s: %s unregistered\n",
+                                __func__, elem->name);
+                        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);
+        }
+
+        printk(KERN_DEBUG "%s: dsp pipeline module exited\n", __func__);
+}
+
+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_KERNEL);
+        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 = 0;
+
+                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_KERNEL);
+                                if (!pipeline_entry) {
+                                        printk(KERN_DEBUG "%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_DEBUG "%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_DEBUG "%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)
+{
+        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);
+}
+
+