xref: /linux/drivers/isdn/mISDN/dsp_pipeline.c (revision c532de5a67a70f8533d495f8f2aaa9a0491c3ad0)
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 struct dsp_pipeline_entry {
21 	struct mISDN_dsp_element *elem;
22 	void                *p;
23 	struct list_head     list;
24 };
25 struct dsp_element_entry {
26 	struct mISDN_dsp_element *elem;
27 	struct device	     dev;
28 	struct list_head     list;
29 };
30 
31 static LIST_HEAD(dsp_elements);
32 
33 /* sysfs */
34 static const struct class elements_class = {
35 	.name = "dsp_pipeline",
36 };
37 
38 static ssize_t
39 attr_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 
57 static struct device_attribute element_attributes[] = {
58 	__ATTR(args, 0444, attr_show_args, NULL),
59 };
60 
61 static void
62 mISDN_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 
70 int 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 
109 err2:
110 	device_unregister(&entry->dev);
111 	return ret;
112 err1:
113 	put_device(&entry->dev);
114 	return ret;
115 }
116 EXPORT_SYMBOL(mISDN_dsp_element_register);
117 
118 void 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 }
132 EXPORT_SYMBOL(mISDN_dsp_element_unregister);
133 
134 int 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 
147 void 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 
163 int 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 
173 static 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 
188 void dsp_pipeline_destroy(struct dsp_pipeline *pipeline)
189 {
190 
191 	if (!pipeline)
192 		return;
193 
194 	_dsp_pipeline_destroy(pipeline);
195 }
196 
197 int 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 
277 void 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 
289 void 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 }
301