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