drivers/isdn/mISDN/dsp_pipeline.c

   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>
  28 #include <linux/slab.h>
  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);
  59         int i;
  60         char *p = buf;
  61
  62         *buf = 0;
  63         for (i = 0; i < elem->num_args; i++)
  64                 p += sprintf(p, "Name:        %s\n%s%s%sDescription: %s\n\n",
  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
  71         return p - buf;
  72 }
  73
  74 static struct device_attribute element_attributes[] = {
  75         __ATTR(args, 0444, attr_show_args, NULL),
  76 };
  77
  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
  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
  95         entry = kzalloc(sizeof(struct dsp_element_entry), GFP_ATOMIC);
  96         if (!entry)
  97                 return -ENOMEM;
  98
  99         entry->elem = elem;
 100
 101         entry->dev.class = elements_class;
 102         entry->dev.release = mISDN_dsp_dev_release;
 103         dev_set_drvdata(&entry->dev, elem);
 104         dev_set_name(&entry->dev, elem->name);
 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         }
 111         list_add_tail(&entry->list, &dsp_elements);
 112
 113         for (i = 0; i < ARRAY_SIZE(element_attributes); ++i) {
 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                 }
 121         }
 122
 123 #ifdef PIPELINE_DEBUG
 124         printk(KERN_DEBUG "%s: %s registered\n", __func__, elem->name);
 125 #endif
 126
 127         return 0;
 128
 129 err2:
 130         device_unregister(&entry->dev);
 131         return ret;
 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) {
 147                         device_unregister(&entry->dev);
 148 #ifdef PIPELINE_DEBUG
 149                         printk(KERN_DEBUG "%s: %s unregistered\n",
 150                                 __func__, elem->name);
 151 #endif
 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
 188 #ifdef PIPELINE_DEBUG
 189         printk(KERN_DEBUG "%s: dsp pipeline module exited\n", __func__);
 190 #endif
 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
 256         dup = kmalloc(len + 1, GFP_ATOMIC);
 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)
 266                         args = NULL;
 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
 273                                         dsp_pipeline_entry), GFP_ATOMIC);
 274                                 if (!pipeline_entry) {
 275                                         printk(KERN_ERR "%s: failed to add "
 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 {
 303                                                 printk(KERN_ERR "%s: failed "
 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 {
 318                         printk(KERN_ERR "%s: element not found, skipping: "
 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
 350 void dsp_pipeline_process_rx(struct dsp_pipeline *pipeline, u8 *data, int len,
 351         unsigned int txlen)
 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)
 360                         entry->elem->process_rx(entry->p, data, len, txlen);
 361 }
 362
 363