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