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