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 
364