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 struct class *elements_class; 35 36 static ssize_t 37 attr_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 55 static struct device_attribute element_attributes[] = { 56 __ATTR(args, 0444, attr_show_args, NULL), 57 }; 58 59 static void 60 mISDN_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 68 int 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 107 err2: 108 device_unregister(&entry->dev); 109 return ret; 110 err1: 111 put_device(&entry->dev); 112 return ret; 113 } 114 EXPORT_SYMBOL(mISDN_dsp_element_register); 115 116 void 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 } 130 EXPORT_SYMBOL(mISDN_dsp_element_unregister); 131 132 int dsp_pipeline_module_init(void) 133 { 134 elements_class = class_create(THIS_MODULE, "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 143 void 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 159 int 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 169 static 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 184 void dsp_pipeline_destroy(struct dsp_pipeline *pipeline) 185 { 186 187 if (!pipeline) 188 return; 189 190 _dsp_pipeline_destroy(pipeline); 191 } 192 193 int 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 273 void 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 285 void 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 } 297