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 <linux/export.h>
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);
60 	int i;
61 	char *p = buf;
62 
63 	*buf = 0;
64 	for (i = 0; i < elem->num_args; i++)
65 		p += sprintf(p, "Name:        %s\n%s%s%sDescription: %s\n\n",
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);
71 
72 	return p - buf;
73 }
74 
75 static struct device_attribute element_attributes[] = {
76 	__ATTR(args, 0444, attr_show_args, NULL),
77 };
78 
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 
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 
96 	entry = kzalloc(sizeof(struct dsp_element_entry), GFP_ATOMIC);
97 	if (!entry)
98 		return -ENOMEM;
99 
100 	entry->elem = elem;
101 
102 	entry->dev.class = elements_class;
103 	entry->dev.release = mISDN_dsp_dev_release;
104 	dev_set_drvdata(&entry->dev, elem);
105 	dev_set_name(&entry->dev, "%s", elem->name);
106 	ret = device_register(&entry->dev);
107 	if (ret) {
108 		printk(KERN_ERR "%s: failed to register %s\n",
109 		       __func__, elem->name);
110 		goto err1;
111 	}
112 	list_add_tail(&entry->list, &dsp_elements);
113 
114 	for (i = 0; i < ARRAY_SIZE(element_attributes); ++i) {
115 		ret = device_create_file(&entry->dev,
116 					 &element_attributes[i]);
117 		if (ret) {
118 			printk(KERN_ERR "%s: failed to create device file\n",
119 			       __func__);
120 			goto err2;
121 		}
122 	}
123 
124 #ifdef PIPELINE_DEBUG
125 	printk(KERN_DEBUG "%s: %s registered\n", __func__, elem->name);
126 #endif
127 
128 	return 0;
129 
130 err2:
131 	device_unregister(&entry->dev);
132 	return ret;
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) {
148 			device_unregister(&entry->dev);
149 #ifdef PIPELINE_DEBUG
150 			printk(KERN_DEBUG "%s: %s unregistered\n",
151 			       __func__, elem->name);
152 #endif
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",
185 		       __func__, entry->elem->name);
186 		kfree(entry);
187 	}
188 
189 #ifdef PIPELINE_DEBUG
190 	printk(KERN_DEBUG "%s: dsp pipeline module exited\n", __func__);
191 #endif
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,
216 						      pipeline));
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 
257 	dup = kmalloc(len + 1, GFP_ATOMIC);
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)
267 			args = NULL;
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
274 								dsp_pipeline_entry), GFP_ATOMIC);
275 				if (!pipeline_entry) {
276 					printk(KERN_ERR "%s: failed to add "
277 					       "entry to pipeline: %s (out of "
278 					       "memory)\n", __func__, elem->name);
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,
288 								     struct dsp, pipeline), args);
289 					list_add_tail(&pipeline_entry->list,
290 						      &pipeline->list);
291 				} else {
292 					pipeline_entry->p = elem->new(args);
293 					if (pipeline_entry->p) {
294 						list_add_tail(&pipeline_entry->
295 							      list, &pipeline->list);
296 #ifdef PIPELINE_DEBUG
297 						printk(KERN_DEBUG "%s: created "
298 						       "instance of %s%s%s\n",
299 						       __func__, name, args ?
300 						       " with args " : "", args ?
301 						       args : "");
302 #endif
303 					} else {
304 						printk(KERN_ERR "%s: failed "
305 						       "to add entry to pipeline: "
306 						       "%s (new() returned NULL)\n",
307 						       __func__, elem->name);
308 						kfree(pipeline_entry);
309 						incomplete = 1;
310 					}
311 				}
312 				found = 1;
313 				break;
314 			}
315 
316 		if (found)
317 			found = 0;
318 		else {
319 			printk(KERN_ERR "%s: element not found, skipping: "
320 			       "%s\n", __func__, name);
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",
333 	       __func__, incomplete ? " incomplete" : "", cfg);
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 
351 void dsp_pipeline_process_rx(struct dsp_pipeline *pipeline, u8 *data, int len,
352 			     unsigned int txlen)
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)
361 			entry->elem->process_rx(entry->p, data, len, txlen);
362 }
363