1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // Copyright(c) 2019-2022 Intel Corporation. All rights reserved.
4 //
5 // Author: Cezary Rojewski <cezary.rojewski@intel.com>
6 //
7 // SOF client support:
8 //  Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
9 //  Peter Ujfalusi <peter.ujfalusi@linux.intel.com>
10 //
11 
12 #include <linux/debugfs.h>
13 #include <linux/module.h>
14 #include <linux/pm_runtime.h>
15 #include <linux/string_helpers.h>
16 #include <linux/stddef.h>
17 
18 #include <sound/soc.h>
19 #include <sound/sof/header.h>
20 #include "sof-client.h"
21 #include "sof-client-probes.h"
22 
23 #define SOF_PROBES_SUSPEND_DELAY_MS 3000
24 /* only extraction supported for now */
25 #define SOF_PROBES_NUM_DAI_LINKS 1
26 
27 #define SOF_PROBES_INVALID_NODE_ID UINT_MAX
28 
29 static bool __read_mostly sof_probes_enabled;
30 module_param_named(enable, sof_probes_enabled, bool, 0444);
31 MODULE_PARM_DESC(enable, "Enable SOF probes support");
32 
33 static int sof_probes_compr_startup(struct snd_compr_stream *cstream,
34 				    struct snd_soc_dai *dai)
35 {
36 	struct snd_soc_card *card = snd_soc_component_get_drvdata(dai->component);
37 	struct sof_client_dev *cdev = snd_soc_card_get_drvdata(card);
38 	struct sof_probes_priv *priv = cdev->data;
39 	const struct sof_probes_host_ops *ops = priv->host_ops;
40 	int ret;
41 
42 	if (sof_client_get_fw_state(cdev) == SOF_FW_CRASHED)
43 		return -ENODEV;
44 
45 	ret = sof_client_core_module_get(cdev);
46 	if (ret)
47 		return ret;
48 
49 	ret = ops->startup(cdev, cstream, dai, &priv->extractor_stream_tag);
50 	if (ret) {
51 		dev_err(dai->dev, "Failed to startup probe stream: %d\n", ret);
52 		priv->extractor_stream_tag = SOF_PROBES_INVALID_NODE_ID;
53 		sof_client_core_module_put(cdev);
54 	}
55 
56 	return ret;
57 }
58 
59 static int sof_probes_compr_shutdown(struct snd_compr_stream *cstream,
60 				     struct snd_soc_dai *dai)
61 {
62 	struct snd_soc_card *card = snd_soc_component_get_drvdata(dai->component);
63 	struct sof_client_dev *cdev = snd_soc_card_get_drvdata(card);
64 	struct sof_probes_priv *priv = cdev->data;
65 	const struct sof_probes_host_ops *ops = priv->host_ops;
66 	const struct sof_probes_ipc_ops *ipc = priv->ipc_ops;
67 	struct sof_probe_point_desc *desc;
68 	size_t num_desc;
69 	int i, ret;
70 
71 	/* disconnect all probe points */
72 	ret = ipc->points_info(cdev, &desc, &num_desc);
73 	if (ret < 0) {
74 		dev_err(dai->dev, "Failed to get probe points: %d\n", ret);
75 		goto exit;
76 	}
77 
78 	for (i = 0; i < num_desc; i++)
79 		ipc->points_remove(cdev, &desc[i].buffer_id, 1);
80 	kfree(desc);
81 
82 exit:
83 	ret = ipc->deinit(cdev);
84 	if (ret < 0)
85 		dev_err(dai->dev, "Failed to deinit probe: %d\n", ret);
86 
87 	priv->extractor_stream_tag = SOF_PROBES_INVALID_NODE_ID;
88 	snd_compr_free_pages(cstream);
89 
90 	ret = ops->shutdown(cdev, cstream, dai);
91 
92 	sof_client_core_module_put(cdev);
93 
94 	return ret;
95 }
96 
97 static int sof_probes_compr_set_params(struct snd_compr_stream *cstream,
98 				       struct snd_compr_params *params,
99 				       struct snd_soc_dai *dai)
100 {
101 	struct snd_soc_card *card = snd_soc_component_get_drvdata(dai->component);
102 	struct sof_client_dev *cdev = snd_soc_card_get_drvdata(card);
103 	struct snd_compr_runtime *rtd = cstream->runtime;
104 	struct sof_probes_priv *priv = cdev->data;
105 	const struct sof_probes_host_ops *ops = priv->host_ops;
106 	const struct sof_probes_ipc_ops *ipc = priv->ipc_ops;
107 	int ret;
108 
109 	cstream->dma_buffer.dev.type = SNDRV_DMA_TYPE_DEV_SG;
110 	cstream->dma_buffer.dev.dev = sof_client_get_dma_dev(cdev);
111 	ret = snd_compr_malloc_pages(cstream, rtd->buffer_size);
112 	if (ret < 0)
113 		return ret;
114 
115 	ret = ops->set_params(cdev, cstream, params, dai);
116 	if (ret)
117 		return ret;
118 
119 	ret = ipc->init(cdev, priv->extractor_stream_tag, rtd->dma_bytes);
120 	if (ret < 0) {
121 		dev_err(dai->dev, "Failed to init probe: %d\n", ret);
122 		return ret;
123 	}
124 
125 	return 0;
126 }
127 
128 static int sof_probes_compr_trigger(struct snd_compr_stream *cstream, int cmd,
129 				    struct snd_soc_dai *dai)
130 {
131 	struct snd_soc_card *card = snd_soc_component_get_drvdata(dai->component);
132 	struct sof_client_dev *cdev = snd_soc_card_get_drvdata(card);
133 	struct sof_probes_priv *priv = cdev->data;
134 	const struct sof_probes_host_ops *ops = priv->host_ops;
135 
136 	return ops->trigger(cdev, cstream, cmd, dai);
137 }
138 
139 static int sof_probes_compr_pointer(struct snd_compr_stream *cstream,
140 				    struct snd_compr_tstamp *tstamp,
141 				    struct snd_soc_dai *dai)
142 {
143 	struct snd_soc_card *card = snd_soc_component_get_drvdata(dai->component);
144 	struct sof_client_dev *cdev = snd_soc_card_get_drvdata(card);
145 	struct sof_probes_priv *priv = cdev->data;
146 	const struct sof_probes_host_ops *ops = priv->host_ops;
147 
148 	return ops->pointer(cdev, cstream, tstamp, dai);
149 }
150 
151 static const struct snd_soc_cdai_ops sof_probes_compr_ops = {
152 	.startup = sof_probes_compr_startup,
153 	.shutdown = sof_probes_compr_shutdown,
154 	.set_params = sof_probes_compr_set_params,
155 	.trigger = sof_probes_compr_trigger,
156 	.pointer = sof_probes_compr_pointer,
157 };
158 
159 static int sof_probes_compr_copy(struct snd_soc_component *component,
160 				 struct snd_compr_stream *cstream,
161 				 char __user *buf, size_t count)
162 {
163 	struct snd_compr_runtime *rtd = cstream->runtime;
164 	unsigned int offset, n;
165 	void *ptr;
166 	int ret;
167 
168 	if (count > rtd->buffer_size)
169 		count = rtd->buffer_size;
170 
171 	div_u64_rem(rtd->total_bytes_transferred, rtd->buffer_size, &offset);
172 	ptr = rtd->dma_area + offset;
173 	n = rtd->buffer_size - offset;
174 
175 	if (count < n) {
176 		ret = copy_to_user(buf, ptr, count);
177 	} else {
178 		ret = copy_to_user(buf, ptr, n);
179 		ret += copy_to_user(buf + n, rtd->dma_area, count - n);
180 	}
181 
182 	if (ret)
183 		return count - ret;
184 	return count;
185 }
186 
187 static const struct snd_compress_ops sof_probes_compressed_ops = {
188 	.copy = sof_probes_compr_copy,
189 };
190 
191 static ssize_t sof_probes_dfs_points_read(struct file *file, char __user *to,
192 					  size_t count, loff_t *ppos)
193 {
194 	struct sof_client_dev *cdev = file->private_data;
195 	struct sof_probes_priv *priv = cdev->data;
196 	struct device *dev = &cdev->auxdev.dev;
197 	struct sof_probe_point_desc *desc;
198 	const struct sof_probes_ipc_ops *ipc = priv->ipc_ops;
199 	int remaining, offset;
200 	size_t num_desc;
201 	char *buf;
202 	int i, ret, err;
203 
204 	if (priv->extractor_stream_tag == SOF_PROBES_INVALID_NODE_ID) {
205 		dev_warn(dev, "no extractor stream running\n");
206 		return -ENOENT;
207 	}
208 
209 	buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
210 	if (!buf)
211 		return -ENOMEM;
212 
213 	ret = pm_runtime_resume_and_get(dev);
214 	if (ret < 0 && ret != -EACCES) {
215 		dev_err_ratelimited(dev, "debugfs read failed to resume %d\n", ret);
216 		goto exit;
217 	}
218 
219 	ret = ipc->points_info(cdev, &desc, &num_desc);
220 	if (ret < 0)
221 		goto pm_error;
222 
223 	for (i = 0; i < num_desc; i++) {
224 		offset = strlen(buf);
225 		remaining = PAGE_SIZE - offset;
226 		ret = snprintf(buf + offset, remaining,
227 			       "Id: %#010x  Purpose: %u  Node id: %#x\n",
228 				desc[i].buffer_id, desc[i].purpose, desc[i].stream_tag);
229 		if (ret < 0 || ret >= remaining) {
230 			/* truncate the output buffer at the last full line */
231 			buf[offset] = '\0';
232 			break;
233 		}
234 	}
235 
236 	ret = simple_read_from_buffer(to, count, ppos, buf, strlen(buf));
237 
238 	kfree(desc);
239 
240 pm_error:
241 	pm_runtime_mark_last_busy(dev);
242 	err = pm_runtime_put_autosuspend(dev);
243 	if (err < 0)
244 		dev_err_ratelimited(dev, "debugfs read failed to idle %d\n", err);
245 
246 exit:
247 	kfree(buf);
248 	return ret;
249 }
250 
251 static ssize_t
252 sof_probes_dfs_points_write(struct file *file, const char __user *from,
253 			    size_t count, loff_t *ppos)
254 {
255 	struct sof_client_dev *cdev = file->private_data;
256 	struct sof_probes_priv *priv = cdev->data;
257 	const struct sof_probes_ipc_ops *ipc = priv->ipc_ops;
258 	struct device *dev = &cdev->auxdev.dev;
259 	struct sof_probe_point_desc *desc;
260 	u32 num_elems, *array;
261 	size_t bytes;
262 	int ret, err;
263 
264 	if (priv->extractor_stream_tag == SOF_PROBES_INVALID_NODE_ID) {
265 		dev_warn(dev, "no extractor stream running\n");
266 		return -ENOENT;
267 	}
268 
269 	ret = parse_int_array_user(from, count, (int **)&array);
270 	if (ret < 0)
271 		return ret;
272 
273 	num_elems = *array;
274 	bytes = sizeof(*array) * num_elems;
275 	if (bytes % sizeof(*desc)) {
276 		ret = -EINVAL;
277 		goto exit;
278 	}
279 
280 	desc = (struct sof_probe_point_desc *)&array[1];
281 
282 	ret = pm_runtime_resume_and_get(dev);
283 	if (ret < 0 && ret != -EACCES) {
284 		dev_err_ratelimited(dev, "debugfs write failed to resume %d\n", ret);
285 		goto exit;
286 	}
287 
288 	ret = ipc->points_add(cdev, desc, bytes / sizeof(*desc));
289 	if (!ret)
290 		ret = count;
291 
292 	pm_runtime_mark_last_busy(dev);
293 	err = pm_runtime_put_autosuspend(dev);
294 	if (err < 0)
295 		dev_err_ratelimited(dev, "debugfs write failed to idle %d\n", err);
296 exit:
297 	kfree(array);
298 	return ret;
299 }
300 
301 static const struct file_operations sof_probes_points_fops = {
302 	.open = simple_open,
303 	.read = sof_probes_dfs_points_read,
304 	.write = sof_probes_dfs_points_write,
305 	.llseek = default_llseek,
306 
307 	.owner = THIS_MODULE,
308 };
309 
310 static ssize_t
311 sof_probes_dfs_points_remove_write(struct file *file, const char __user *from,
312 				   size_t count, loff_t *ppos)
313 {
314 	struct sof_client_dev *cdev = file->private_data;
315 	struct sof_probes_priv *priv = cdev->data;
316 	const struct sof_probes_ipc_ops *ipc = priv->ipc_ops;
317 	struct device *dev = &cdev->auxdev.dev;
318 	int ret, err;
319 	u32 *array;
320 
321 	if (priv->extractor_stream_tag == SOF_PROBES_INVALID_NODE_ID) {
322 		dev_warn(dev, "no extractor stream running\n");
323 		return -ENOENT;
324 	}
325 
326 	ret = parse_int_array_user(from, count, (int **)&array);
327 	if (ret < 0)
328 		return ret;
329 
330 	ret = pm_runtime_resume_and_get(dev);
331 	if (ret < 0) {
332 		dev_err_ratelimited(dev, "debugfs write failed to resume %d\n", ret);
333 		goto exit;
334 	}
335 
336 	ret = ipc->points_remove(cdev, &array[1], array[0]);
337 	if (!ret)
338 		ret = count;
339 
340 	pm_runtime_mark_last_busy(dev);
341 	err = pm_runtime_put_autosuspend(dev);
342 	if (err < 0)
343 		dev_err_ratelimited(dev, "debugfs write failed to idle %d\n", err);
344 exit:
345 	kfree(array);
346 	return ret;
347 }
348 
349 static const struct file_operations sof_probes_points_remove_fops = {
350 	.open = simple_open,
351 	.write = sof_probes_dfs_points_remove_write,
352 	.llseek = default_llseek,
353 
354 	.owner = THIS_MODULE,
355 };
356 
357 static const struct snd_soc_dai_ops sof_probes_dai_ops = {
358 	.compress_new = snd_soc_new_compress,
359 };
360 
361 static struct snd_soc_dai_driver sof_probes_dai_drv[] = {
362 {
363 	.name = "Probe Extraction CPU DAI",
364 	.ops  = &sof_probes_dai_ops,
365 	.cops = &sof_probes_compr_ops,
366 	.capture = {
367 		.stream_name = "Probe Extraction",
368 		.channels_min = 1,
369 		.channels_max = 8,
370 		.rates = SNDRV_PCM_RATE_48000,
371 		.rate_min = 48000,
372 		.rate_max = 48000,
373 	},
374 },
375 };
376 
377 static const struct snd_soc_component_driver sof_probes_component = {
378 	.name = "sof-probes-component",
379 	.compress_ops = &sof_probes_compressed_ops,
380 	.module_get_upon_open = 1,
381 	.legacy_dai_naming = 1,
382 };
383 
384 SND_SOC_DAILINK_DEF(dummy, DAILINK_COMP_ARRAY(COMP_DUMMY()));
385 
386 static int sof_probes_client_probe(struct auxiliary_device *auxdev,
387 				   const struct auxiliary_device_id *id)
388 {
389 	struct sof_client_dev *cdev = auxiliary_dev_to_sof_client_dev(auxdev);
390 	struct dentry *dfsroot = sof_client_get_debugfs_root(cdev);
391 	struct device *dev = &auxdev->dev;
392 	struct snd_soc_dai_link_component platform_component[] = {
393 		{
394 			.name = dev_name(dev),
395 		}
396 	};
397 	struct snd_soc_card *card;
398 	struct sof_probes_priv *priv;
399 	struct snd_soc_dai_link_component *cpus;
400 	struct sof_probes_host_ops *ops;
401 	struct snd_soc_dai_link *links;
402 	int ret;
403 
404 	/* do not set up the probes support if it is not enabled */
405 	if (!sof_probes_enabled)
406 		return -ENXIO;
407 
408 	ops = dev_get_platdata(dev);
409 	if (!ops) {
410 		dev_err(dev, "missing platform data\n");
411 		return -ENODEV;
412 	}
413 	if (!ops->startup || !ops->shutdown || !ops->set_params || !ops->trigger ||
414 	    !ops->pointer) {
415 		dev_err(dev, "missing platform callback(s)\n");
416 		return -ENODEV;
417 	}
418 
419 	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
420 	if (!priv)
421 		return -ENOMEM;
422 
423 	priv->host_ops = ops;
424 
425 	switch (sof_client_get_ipc_type(cdev)) {
426 #ifdef CONFIG_SND_SOC_SOF_INTEL_IPC4
427 	case SOF_INTEL_IPC4:
428 		priv->ipc_ops = &ipc4_probe_ops;
429 		break;
430 #endif
431 #ifdef CONFIG_SND_SOC_SOF_IPC3
432 	case SOF_IPC:
433 		priv->ipc_ops = &ipc3_probe_ops;
434 		break;
435 #endif
436 	default:
437 		dev_err(dev, "Matching IPC ops not found.");
438 		return -ENODEV;
439 	}
440 
441 	cdev->data = priv;
442 
443 	/* register probes component driver and dai */
444 	ret = devm_snd_soc_register_component(dev, &sof_probes_component,
445 					      sof_probes_dai_drv,
446 					      ARRAY_SIZE(sof_probes_dai_drv));
447 	if (ret < 0) {
448 		dev_err(dev, "failed to register SOF probes DAI driver %d\n", ret);
449 		return ret;
450 	}
451 
452 	/* set client data */
453 	priv->extractor_stream_tag = SOF_PROBES_INVALID_NODE_ID;
454 
455 	/* create read-write probes_points debugfs entry */
456 	priv->dfs_points = debugfs_create_file("probe_points", 0644, dfsroot,
457 					       cdev, &sof_probes_points_fops);
458 
459 	/* create read-write probe_points_remove debugfs entry */
460 	priv->dfs_points_remove = debugfs_create_file("probe_points_remove", 0644,
461 						      dfsroot, cdev,
462 						      &sof_probes_points_remove_fops);
463 
464 	links = devm_kcalloc(dev, SOF_PROBES_NUM_DAI_LINKS, sizeof(*links), GFP_KERNEL);
465 	cpus = devm_kcalloc(dev, SOF_PROBES_NUM_DAI_LINKS, sizeof(*cpus), GFP_KERNEL);
466 	if (!links || !cpus) {
467 		debugfs_remove(priv->dfs_points);
468 		debugfs_remove(priv->dfs_points_remove);
469 		return -ENOMEM;
470 	}
471 
472 	/* extraction DAI link */
473 	links[0].name = "Compress Probe Capture";
474 	links[0].id = 0;
475 	links[0].cpus = &cpus[0];
476 	links[0].num_cpus = 1;
477 	links[0].cpus->dai_name = "Probe Extraction CPU DAI";
478 	links[0].codecs = dummy;
479 	links[0].num_codecs = 1;
480 	links[0].platforms = platform_component;
481 	links[0].num_platforms = ARRAY_SIZE(platform_component);
482 	links[0].nonatomic = 1;
483 
484 	card = &priv->card;
485 
486 	card->dev = dev;
487 	card->name = "sof-probes";
488 	card->owner = THIS_MODULE;
489 	card->num_links = SOF_PROBES_NUM_DAI_LINKS;
490 	card->dai_link = links;
491 
492 	/* set idle_bias_off to prevent the core from resuming the card->dev */
493 	card->dapm.idle_bias_off = true;
494 
495 	snd_soc_card_set_drvdata(card, cdev);
496 
497 	ret = devm_snd_soc_register_card(dev, card);
498 	if (ret < 0) {
499 		debugfs_remove(priv->dfs_points);
500 		debugfs_remove(priv->dfs_points_remove);
501 		dev_err(dev, "Probes card register failed %d\n", ret);
502 		return ret;
503 	}
504 
505 	/* enable runtime PM */
506 	pm_runtime_set_autosuspend_delay(dev, SOF_PROBES_SUSPEND_DELAY_MS);
507 	pm_runtime_use_autosuspend(dev);
508 	pm_runtime_enable(dev);
509 	pm_runtime_mark_last_busy(dev);
510 	pm_runtime_idle(dev);
511 
512 	return 0;
513 }
514 
515 static void sof_probes_client_remove(struct auxiliary_device *auxdev)
516 {
517 	struct sof_client_dev *cdev = auxiliary_dev_to_sof_client_dev(auxdev);
518 	struct sof_probes_priv *priv = cdev->data;
519 
520 	if (!sof_probes_enabled)
521 		return;
522 
523 	pm_runtime_disable(&auxdev->dev);
524 	debugfs_remove(priv->dfs_points);
525 	debugfs_remove(priv->dfs_points_remove);
526 }
527 
528 static const struct auxiliary_device_id sof_probes_client_id_table[] = {
529 	{ .name = "snd_sof.hda-probes", },
530 	{ .name = "snd_sof.acp-probes", },
531 	{},
532 };
533 MODULE_DEVICE_TABLE(auxiliary, sof_probes_client_id_table);
534 
535 /* driver name will be set based on KBUILD_MODNAME */
536 static struct auxiliary_driver sof_probes_client_drv = {
537 	.probe = sof_probes_client_probe,
538 	.remove = sof_probes_client_remove,
539 
540 	.id_table = sof_probes_client_id_table,
541 };
542 
543 module_auxiliary_driver(sof_probes_client_drv);
544 
545 MODULE_DESCRIPTION("SOF Probes Client Driver");
546 MODULE_LICENSE("GPL v2");
547 MODULE_IMPORT_NS(SND_SOC_SOF_CLIENT);
548