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_IPC4 427 case SOF_IPC_TYPE_4: 428 priv->ipc_ops = &ipc4_probe_ops; 429 break; 430 #endif 431 #ifdef CONFIG_SND_SOC_SOF_IPC3 432 case SOF_IPC_TYPE_3: 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