1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) 2 // 3 // This file is provided under a dual BSD/GPLv2 license. When using or 4 // redistributing this file, you may do so under either license. 5 // 6 // Copyright(c) 2018 Intel Corporation. All rights reserved. 7 // 8 // Author: Liam Girdwood <liam.r.girdwood@linux.intel.com> 9 // 10 // Generic debug routines used to export DSP MMIO and memories to userspace 11 // for firmware debugging. 12 // 13 14 #include <linux/debugfs.h> 15 #include <linux/io.h> 16 #include <linux/pm_runtime.h> 17 #include <sound/sof/ext_manifest.h> 18 #include <sound/sof/debug.h> 19 #include "sof-priv.h" 20 #include "ops.h" 21 22 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_PROBES) 23 #include "probe.h" 24 25 /** 26 * strsplit_u32 - Split string into sequence of u32 tokens 27 * @buf: String to split into tokens. 28 * @delim: String containing delimiter characters. 29 * @tkns: Returned u32 sequence pointer. 30 * @num_tkns: Returned number of tokens obtained. 31 */ 32 static int 33 strsplit_u32(char **buf, const char *delim, u32 **tkns, size_t *num_tkns) 34 { 35 char *s; 36 u32 *data, *tmp; 37 size_t count = 0; 38 size_t cap = 32; 39 int ret = 0; 40 41 *tkns = NULL; 42 *num_tkns = 0; 43 data = kcalloc(cap, sizeof(*data), GFP_KERNEL); 44 if (!data) 45 return -ENOMEM; 46 47 while ((s = strsep(buf, delim)) != NULL) { 48 ret = kstrtouint(s, 0, data + count); 49 if (ret) 50 goto exit; 51 if (++count >= cap) { 52 cap *= 2; 53 tmp = krealloc(data, cap * sizeof(*data), GFP_KERNEL); 54 if (!tmp) { 55 ret = -ENOMEM; 56 goto exit; 57 } 58 data = tmp; 59 } 60 } 61 62 if (!count) 63 goto exit; 64 *tkns = kmemdup(data, count * sizeof(*data), GFP_KERNEL); 65 if (*tkns == NULL) { 66 ret = -ENOMEM; 67 goto exit; 68 } 69 *num_tkns = count; 70 71 exit: 72 kfree(data); 73 return ret; 74 } 75 76 static int tokenize_input(const char __user *from, size_t count, 77 loff_t *ppos, u32 **tkns, size_t *num_tkns) 78 { 79 char *buf; 80 int ret; 81 82 buf = kmalloc(count + 1, GFP_KERNEL); 83 if (!buf) 84 return -ENOMEM; 85 86 ret = simple_write_to_buffer(buf, count, ppos, from, count); 87 if (ret != count) { 88 ret = ret >= 0 ? -EIO : ret; 89 goto exit; 90 } 91 92 buf[count] = '\0'; 93 ret = strsplit_u32((char **)&buf, ",", tkns, num_tkns); 94 exit: 95 kfree(buf); 96 return ret; 97 } 98 99 static ssize_t probe_points_read(struct file *file, 100 char __user *to, size_t count, loff_t *ppos) 101 { 102 struct snd_sof_dfsentry *dfse = file->private_data; 103 struct snd_sof_dev *sdev = dfse->sdev; 104 struct sof_probe_point_desc *desc; 105 size_t num_desc, len = 0; 106 char *buf; 107 int i, ret; 108 109 if (sdev->extractor_stream_tag == SOF_PROBE_INVALID_NODE_ID) { 110 dev_warn(sdev->dev, "no extractor stream running\n"); 111 return -ENOENT; 112 } 113 114 buf = kzalloc(PAGE_SIZE, GFP_KERNEL); 115 if (!buf) 116 return -ENOMEM; 117 118 ret = sof_ipc_probe_points_info(sdev, &desc, &num_desc); 119 if (ret < 0) 120 goto exit; 121 122 for (i = 0; i < num_desc; i++) { 123 ret = snprintf(buf + len, PAGE_SIZE - len, 124 "Id: %#010x Purpose: %d Node id: %#x\n", 125 desc[i].buffer_id, desc[i].purpose, desc[i].stream_tag); 126 if (ret < 0) 127 goto free_desc; 128 len += ret; 129 } 130 131 ret = simple_read_from_buffer(to, count, ppos, buf, len); 132 free_desc: 133 kfree(desc); 134 exit: 135 kfree(buf); 136 return ret; 137 } 138 139 static ssize_t probe_points_write(struct file *file, 140 const char __user *from, size_t count, loff_t *ppos) 141 { 142 struct snd_sof_dfsentry *dfse = file->private_data; 143 struct snd_sof_dev *sdev = dfse->sdev; 144 struct sof_probe_point_desc *desc; 145 size_t num_tkns, bytes; 146 u32 *tkns; 147 int ret; 148 149 if (sdev->extractor_stream_tag == SOF_PROBE_INVALID_NODE_ID) { 150 dev_warn(sdev->dev, "no extractor stream running\n"); 151 return -ENOENT; 152 } 153 154 ret = tokenize_input(from, count, ppos, &tkns, &num_tkns); 155 if (ret < 0) 156 return ret; 157 bytes = sizeof(*tkns) * num_tkns; 158 if (!num_tkns || (bytes % sizeof(*desc))) { 159 ret = -EINVAL; 160 goto exit; 161 } 162 163 desc = (struct sof_probe_point_desc *)tkns; 164 ret = sof_ipc_probe_points_add(sdev, 165 desc, bytes / sizeof(*desc)); 166 if (!ret) 167 ret = count; 168 exit: 169 kfree(tkns); 170 return ret; 171 } 172 173 static const struct file_operations probe_points_fops = { 174 .open = simple_open, 175 .read = probe_points_read, 176 .write = probe_points_write, 177 .llseek = default_llseek, 178 }; 179 180 static ssize_t probe_points_remove_write(struct file *file, 181 const char __user *from, size_t count, loff_t *ppos) 182 { 183 struct snd_sof_dfsentry *dfse = file->private_data; 184 struct snd_sof_dev *sdev = dfse->sdev; 185 size_t num_tkns; 186 u32 *tkns; 187 int ret; 188 189 if (sdev->extractor_stream_tag == SOF_PROBE_INVALID_NODE_ID) { 190 dev_warn(sdev->dev, "no extractor stream running\n"); 191 return -ENOENT; 192 } 193 194 ret = tokenize_input(from, count, ppos, &tkns, &num_tkns); 195 if (ret < 0) 196 return ret; 197 if (!num_tkns) { 198 ret = -EINVAL; 199 goto exit; 200 } 201 202 ret = sof_ipc_probe_points_remove(sdev, tkns, num_tkns); 203 if (!ret) 204 ret = count; 205 exit: 206 kfree(tkns); 207 return ret; 208 } 209 210 static const struct file_operations probe_points_remove_fops = { 211 .open = simple_open, 212 .write = probe_points_remove_write, 213 .llseek = default_llseek, 214 }; 215 216 static int snd_sof_debugfs_probe_item(struct snd_sof_dev *sdev, 217 const char *name, mode_t mode, 218 const struct file_operations *fops) 219 { 220 struct snd_sof_dfsentry *dfse; 221 222 dfse = devm_kzalloc(sdev->dev, sizeof(*dfse), GFP_KERNEL); 223 if (!dfse) 224 return -ENOMEM; 225 226 dfse->type = SOF_DFSENTRY_TYPE_BUF; 227 dfse->sdev = sdev; 228 229 debugfs_create_file(name, mode, sdev->debugfs_root, dfse, fops); 230 /* add to dfsentry list */ 231 list_add(&dfse->list, &sdev->dfsentry_list); 232 233 return 0; 234 } 235 #endif 236 237 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_IPC_FLOOD_TEST) 238 #define MAX_IPC_FLOOD_DURATION_MS 1000 239 #define MAX_IPC_FLOOD_COUNT 10000 240 #define IPC_FLOOD_TEST_RESULT_LEN 512 241 242 static int sof_debug_ipc_flood_test(struct snd_sof_dev *sdev, 243 struct snd_sof_dfsentry *dfse, 244 bool flood_duration_test, 245 unsigned long ipc_duration_ms, 246 unsigned long ipc_count) 247 { 248 struct sof_ipc_cmd_hdr hdr; 249 struct sof_ipc_reply reply; 250 u64 min_response_time = U64_MAX; 251 ktime_t start, end, test_end; 252 u64 avg_response_time = 0; 253 u64 max_response_time = 0; 254 u64 ipc_response_time; 255 int i = 0; 256 int ret; 257 258 /* configure test IPC */ 259 hdr.cmd = SOF_IPC_GLB_TEST_MSG | SOF_IPC_TEST_IPC_FLOOD; 260 hdr.size = sizeof(hdr); 261 262 /* set test end time for duration flood test */ 263 if (flood_duration_test) 264 test_end = ktime_get_ns() + ipc_duration_ms * NSEC_PER_MSEC; 265 266 /* send test IPC's */ 267 while (1) { 268 start = ktime_get(); 269 ret = sof_ipc_tx_message(sdev->ipc, hdr.cmd, &hdr, hdr.size, 270 &reply, sizeof(reply)); 271 end = ktime_get(); 272 273 if (ret < 0) 274 break; 275 276 /* compute min and max response times */ 277 ipc_response_time = ktime_to_ns(ktime_sub(end, start)); 278 min_response_time = min(min_response_time, ipc_response_time); 279 max_response_time = max(max_response_time, ipc_response_time); 280 281 /* sum up response times */ 282 avg_response_time += ipc_response_time; 283 i++; 284 285 /* test complete? */ 286 if (flood_duration_test) { 287 if (ktime_to_ns(end) >= test_end) 288 break; 289 } else { 290 if (i == ipc_count) 291 break; 292 } 293 } 294 295 if (ret < 0) 296 dev_err(sdev->dev, 297 "error: ipc flood test failed at %d iterations\n", i); 298 299 /* return if the first IPC fails */ 300 if (!i) 301 return ret; 302 303 /* compute average response time */ 304 do_div(avg_response_time, i); 305 306 /* clear previous test output */ 307 memset(dfse->cache_buf, 0, IPC_FLOOD_TEST_RESULT_LEN); 308 309 if (flood_duration_test) { 310 dev_dbg(sdev->dev, "IPC Flood test duration: %lums\n", 311 ipc_duration_ms); 312 snprintf(dfse->cache_buf, IPC_FLOOD_TEST_RESULT_LEN, 313 "IPC Flood test duration: %lums\n", ipc_duration_ms); 314 } 315 316 dev_dbg(sdev->dev, 317 "IPC Flood count: %d, Avg response time: %lluns\n", 318 i, avg_response_time); 319 dev_dbg(sdev->dev, "Max response time: %lluns\n", 320 max_response_time); 321 dev_dbg(sdev->dev, "Min response time: %lluns\n", 322 min_response_time); 323 324 /* format output string */ 325 snprintf(dfse->cache_buf + strlen(dfse->cache_buf), 326 IPC_FLOOD_TEST_RESULT_LEN - strlen(dfse->cache_buf), 327 "IPC Flood count: %d\nAvg response time: %lluns\n", 328 i, avg_response_time); 329 330 snprintf(dfse->cache_buf + strlen(dfse->cache_buf), 331 IPC_FLOOD_TEST_RESULT_LEN - strlen(dfse->cache_buf), 332 "Max response time: %lluns\nMin response time: %lluns\n", 333 max_response_time, min_response_time); 334 335 return ret; 336 } 337 #endif 338 339 static ssize_t sof_dfsentry_write(struct file *file, const char __user *buffer, 340 size_t count, loff_t *ppos) 341 { 342 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_IPC_FLOOD_TEST) 343 struct snd_sof_dfsentry *dfse = file->private_data; 344 struct snd_sof_dev *sdev = dfse->sdev; 345 unsigned long ipc_duration_ms = 0; 346 bool flood_duration_test = false; 347 unsigned long ipc_count = 0; 348 struct dentry *dentry; 349 int err; 350 #endif 351 size_t size; 352 char *string; 353 int ret; 354 355 string = kzalloc(count+1, GFP_KERNEL); 356 if (!string) 357 return -ENOMEM; 358 359 size = simple_write_to_buffer(string, count, ppos, buffer, count); 360 ret = size; 361 362 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_IPC_FLOOD_TEST) 363 /* 364 * write op is only supported for ipc_flood_count or 365 * ipc_flood_duration_ms debugfs entries atm. 366 * ipc_flood_count floods the DSP with the number of IPC's specified. 367 * ipc_duration_ms test floods the DSP for the time specified 368 * in the debugfs entry. 369 */ 370 dentry = file->f_path.dentry; 371 if (strcmp(dentry->d_name.name, "ipc_flood_count") && 372 strcmp(dentry->d_name.name, "ipc_flood_duration_ms")) { 373 ret = -EINVAL; 374 goto out; 375 } 376 377 if (!strcmp(dentry->d_name.name, "ipc_flood_duration_ms")) 378 flood_duration_test = true; 379 380 /* test completion criterion */ 381 if (flood_duration_test) 382 ret = kstrtoul(string, 0, &ipc_duration_ms); 383 else 384 ret = kstrtoul(string, 0, &ipc_count); 385 if (ret < 0) 386 goto out; 387 388 /* limit max duration/ipc count for flood test */ 389 if (flood_duration_test) { 390 if (!ipc_duration_ms) { 391 ret = size; 392 goto out; 393 } 394 395 /* find the minimum. min() is not used to avoid warnings */ 396 if (ipc_duration_ms > MAX_IPC_FLOOD_DURATION_MS) 397 ipc_duration_ms = MAX_IPC_FLOOD_DURATION_MS; 398 } else { 399 if (!ipc_count) { 400 ret = size; 401 goto out; 402 } 403 404 /* find the minimum. min() is not used to avoid warnings */ 405 if (ipc_count > MAX_IPC_FLOOD_COUNT) 406 ipc_count = MAX_IPC_FLOOD_COUNT; 407 } 408 409 ret = pm_runtime_get_sync(sdev->dev); 410 if (ret < 0 && ret != -EACCES) { 411 dev_err_ratelimited(sdev->dev, 412 "error: debugfs write failed to resume %d\n", 413 ret); 414 pm_runtime_put_noidle(sdev->dev); 415 goto out; 416 } 417 418 /* flood test */ 419 ret = sof_debug_ipc_flood_test(sdev, dfse, flood_duration_test, 420 ipc_duration_ms, ipc_count); 421 422 pm_runtime_mark_last_busy(sdev->dev); 423 err = pm_runtime_put_autosuspend(sdev->dev); 424 if (err < 0) 425 dev_err_ratelimited(sdev->dev, 426 "error: debugfs write failed to idle %d\n", 427 err); 428 429 /* return size if test is successful */ 430 if (ret >= 0) 431 ret = size; 432 out: 433 #endif 434 kfree(string); 435 return ret; 436 } 437 438 static ssize_t sof_dfsentry_read(struct file *file, char __user *buffer, 439 size_t count, loff_t *ppos) 440 { 441 struct snd_sof_dfsentry *dfse = file->private_data; 442 struct snd_sof_dev *sdev = dfse->sdev; 443 loff_t pos = *ppos; 444 size_t size_ret; 445 int skip = 0; 446 int size; 447 u8 *buf; 448 449 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_IPC_FLOOD_TEST) 450 struct dentry *dentry; 451 452 dentry = file->f_path.dentry; 453 if ((!strcmp(dentry->d_name.name, "ipc_flood_count") || 454 !strcmp(dentry->d_name.name, "ipc_flood_duration_ms")) && 455 dfse->cache_buf) { 456 if (*ppos) 457 return 0; 458 459 count = strlen(dfse->cache_buf); 460 size_ret = copy_to_user(buffer, dfse->cache_buf, count); 461 if (size_ret) 462 return -EFAULT; 463 464 *ppos += count; 465 return count; 466 } 467 #endif 468 size = dfse->size; 469 470 /* validate position & count */ 471 if (pos < 0) 472 return -EINVAL; 473 if (pos >= size || !count) 474 return 0; 475 /* find the minimum. min() is not used since it adds sparse warnings */ 476 if (count > size - pos) 477 count = size - pos; 478 479 /* align io read start to u32 multiple */ 480 pos = ALIGN_DOWN(pos, 4); 481 482 /* intermediate buffer size must be u32 multiple */ 483 size = ALIGN(count, 4); 484 485 /* if start position is unaligned, read extra u32 */ 486 if (unlikely(pos != *ppos)) { 487 skip = *ppos - pos; 488 if (pos + size + 4 < dfse->size) 489 size += 4; 490 } 491 492 buf = kzalloc(size, GFP_KERNEL); 493 if (!buf) 494 return -ENOMEM; 495 496 if (dfse->type == SOF_DFSENTRY_TYPE_IOMEM) { 497 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_ENABLE_DEBUGFS_CACHE) 498 /* 499 * If the DSP is active: copy from IO. 500 * If the DSP is suspended: 501 * - Copy from IO if the memory is always accessible. 502 * - Otherwise, copy from cached buffer. 503 */ 504 if (pm_runtime_active(sdev->dev) || 505 dfse->access_type == SOF_DEBUGFS_ACCESS_ALWAYS) { 506 memcpy_fromio(buf, dfse->io_mem + pos, size); 507 } else { 508 dev_info(sdev->dev, 509 "Copying cached debugfs data\n"); 510 memcpy(buf, dfse->cache_buf + pos, size); 511 } 512 #else 513 /* if the DSP is in D3 */ 514 if (!pm_runtime_active(sdev->dev) && 515 dfse->access_type == SOF_DEBUGFS_ACCESS_D0_ONLY) { 516 dev_err(sdev->dev, 517 "error: debugfs entry cannot be read in DSP D3\n"); 518 kfree(buf); 519 return -EINVAL; 520 } 521 522 memcpy_fromio(buf, dfse->io_mem + pos, size); 523 #endif 524 } else { 525 memcpy(buf, ((u8 *)(dfse->buf) + pos), size); 526 } 527 528 /* copy to userspace */ 529 size_ret = copy_to_user(buffer, buf + skip, count); 530 531 kfree(buf); 532 533 /* update count & position if copy succeeded */ 534 if (size_ret) 535 return -EFAULT; 536 537 *ppos = pos + count; 538 539 return count; 540 } 541 542 static const struct file_operations sof_dfs_fops = { 543 .open = simple_open, 544 .read = sof_dfsentry_read, 545 .llseek = default_llseek, 546 .write = sof_dfsentry_write, 547 }; 548 549 /* create FS entry for debug files that can expose DSP memories, registers */ 550 int snd_sof_debugfs_io_item(struct snd_sof_dev *sdev, 551 void __iomem *base, size_t size, 552 const char *name, 553 enum sof_debugfs_access_type access_type) 554 { 555 struct snd_sof_dfsentry *dfse; 556 557 if (!sdev) 558 return -EINVAL; 559 560 dfse = devm_kzalloc(sdev->dev, sizeof(*dfse), GFP_KERNEL); 561 if (!dfse) 562 return -ENOMEM; 563 564 dfse->type = SOF_DFSENTRY_TYPE_IOMEM; 565 dfse->io_mem = base; 566 dfse->size = size; 567 dfse->sdev = sdev; 568 dfse->access_type = access_type; 569 570 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_ENABLE_DEBUGFS_CACHE) 571 /* 572 * allocate cache buffer that will be used to save the mem window 573 * contents prior to suspend 574 */ 575 if (access_type == SOF_DEBUGFS_ACCESS_D0_ONLY) { 576 dfse->cache_buf = devm_kzalloc(sdev->dev, size, GFP_KERNEL); 577 if (!dfse->cache_buf) 578 return -ENOMEM; 579 } 580 #endif 581 582 debugfs_create_file(name, 0444, sdev->debugfs_root, dfse, 583 &sof_dfs_fops); 584 585 /* add to dfsentry list */ 586 list_add(&dfse->list, &sdev->dfsentry_list); 587 588 return 0; 589 } 590 EXPORT_SYMBOL_GPL(snd_sof_debugfs_io_item); 591 592 /* create FS entry for debug files to expose kernel memory */ 593 int snd_sof_debugfs_buf_item(struct snd_sof_dev *sdev, 594 void *base, size_t size, 595 const char *name, mode_t mode) 596 { 597 struct snd_sof_dfsentry *dfse; 598 599 if (!sdev) 600 return -EINVAL; 601 602 dfse = devm_kzalloc(sdev->dev, sizeof(*dfse), GFP_KERNEL); 603 if (!dfse) 604 return -ENOMEM; 605 606 dfse->type = SOF_DFSENTRY_TYPE_BUF; 607 dfse->buf = base; 608 dfse->size = size; 609 dfse->sdev = sdev; 610 611 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_IPC_FLOOD_TEST) 612 /* 613 * cache_buf is unused for SOF_DFSENTRY_TYPE_BUF debugfs entries. 614 * So, use it to save the results of the last IPC flood test. 615 */ 616 dfse->cache_buf = devm_kzalloc(sdev->dev, IPC_FLOOD_TEST_RESULT_LEN, 617 GFP_KERNEL); 618 if (!dfse->cache_buf) 619 return -ENOMEM; 620 #endif 621 622 debugfs_create_file(name, mode, sdev->debugfs_root, dfse, 623 &sof_dfs_fops); 624 /* add to dfsentry list */ 625 list_add(&dfse->list, &sdev->dfsentry_list); 626 627 return 0; 628 } 629 EXPORT_SYMBOL_GPL(snd_sof_debugfs_buf_item); 630 631 static int memory_info_update(struct snd_sof_dev *sdev, char *buf, size_t buff_size) 632 { 633 struct sof_ipc_cmd_hdr msg = { 634 .size = sizeof(struct sof_ipc_cmd_hdr), 635 .cmd = SOF_IPC_GLB_DEBUG | SOF_IPC_DEBUG_MEM_USAGE, 636 }; 637 struct sof_ipc_dbg_mem_usage *reply; 638 int len; 639 int ret; 640 int i; 641 642 reply = kmalloc(SOF_IPC_MSG_MAX_SIZE, GFP_KERNEL); 643 if (!reply) 644 return -ENOMEM; 645 646 ret = pm_runtime_get_sync(sdev->dev); 647 if (ret < 0 && ret != -EACCES) { 648 pm_runtime_put_noidle(sdev->dev); 649 dev_err(sdev->dev, "error: enabling device failed: %d\n", ret); 650 goto error; 651 } 652 653 ret = sof_ipc_tx_message(sdev->ipc, msg.cmd, &msg, msg.size, reply, SOF_IPC_MSG_MAX_SIZE); 654 pm_runtime_mark_last_busy(sdev->dev); 655 pm_runtime_put_autosuspend(sdev->dev); 656 if (ret < 0 || reply->rhdr.error < 0) { 657 ret = min(ret, reply->rhdr.error); 658 dev_err(sdev->dev, "error: reading memory info failed, %d\n", ret); 659 goto error; 660 } 661 662 if (struct_size(reply, elems, reply->num_elems) != reply->rhdr.hdr.size) { 663 dev_err(sdev->dev, "error: invalid memory info ipc struct size, %d\n", 664 reply->rhdr.hdr.size); 665 ret = -EINVAL; 666 goto error; 667 } 668 669 for (i = 0, len = 0; i < reply->num_elems; i++) { 670 ret = snprintf(buf + len, buff_size - len, "zone %d.%d used %#8x free %#8x\n", 671 reply->elems[i].zone, reply->elems[i].id, 672 reply->elems[i].used, reply->elems[i].free); 673 if (ret < 0) 674 goto error; 675 len += ret; 676 } 677 678 ret = len; 679 error: 680 kfree(reply); 681 return ret; 682 } 683 684 static ssize_t memory_info_read(struct file *file, char __user *to, size_t count, loff_t *ppos) 685 { 686 struct snd_sof_dfsentry *dfse = file->private_data; 687 struct snd_sof_dev *sdev = dfse->sdev; 688 int data_length; 689 690 /* read memory info from FW only once for each file read */ 691 if (!*ppos) { 692 dfse->buf_data_size = 0; 693 data_length = memory_info_update(sdev, dfse->buf, dfse->size); 694 if (data_length < 0) 695 return data_length; 696 dfse->buf_data_size = data_length; 697 } 698 699 return simple_read_from_buffer(to, count, ppos, dfse->buf, dfse->buf_data_size); 700 } 701 702 static int memory_info_open(struct inode *inode, struct file *file) 703 { 704 struct snd_sof_dfsentry *dfse = inode->i_private; 705 struct snd_sof_dev *sdev = dfse->sdev; 706 707 file->private_data = dfse; 708 709 /* allocate buffer memory only in first open run, to save memory when unused */ 710 if (!dfse->buf) { 711 dfse->buf = devm_kmalloc(sdev->dev, PAGE_SIZE, GFP_KERNEL); 712 if (!dfse->buf) 713 return -ENOMEM; 714 dfse->size = PAGE_SIZE; 715 } 716 717 return 0; 718 } 719 720 static const struct file_operations memory_info_fops = { 721 .open = memory_info_open, 722 .read = memory_info_read, 723 .llseek = default_llseek, 724 }; 725 726 int snd_sof_dbg_memory_info_init(struct snd_sof_dev *sdev) 727 { 728 struct snd_sof_dfsentry *dfse; 729 730 dfse = devm_kzalloc(sdev->dev, sizeof(*dfse), GFP_KERNEL); 731 if (!dfse) 732 return -ENOMEM; 733 734 /* don't allocate buffer before first usage, to save memory when unused */ 735 dfse->type = SOF_DFSENTRY_TYPE_BUF; 736 dfse->sdev = sdev; 737 738 debugfs_create_file("memory_info", 0444, sdev->debugfs_root, dfse, &memory_info_fops); 739 740 /* add to dfsentry list */ 741 list_add(&dfse->list, &sdev->dfsentry_list); 742 return 0; 743 } 744 EXPORT_SYMBOL_GPL(snd_sof_dbg_memory_info_init); 745 746 int snd_sof_dbg_init(struct snd_sof_dev *sdev) 747 { 748 const struct snd_sof_dsp_ops *ops = sof_ops(sdev); 749 const struct snd_sof_debugfs_map *map; 750 int i; 751 int err; 752 753 /* use "sof" as top level debugFS dir */ 754 sdev->debugfs_root = debugfs_create_dir("sof", NULL); 755 756 /* init dfsentry list */ 757 INIT_LIST_HEAD(&sdev->dfsentry_list); 758 759 /* create debugFS files for platform specific MMIO/DSP memories */ 760 for (i = 0; i < ops->debug_map_count; i++) { 761 map = &ops->debug_map[i]; 762 763 err = snd_sof_debugfs_io_item(sdev, sdev->bar[map->bar] + 764 map->offset, map->size, 765 map->name, map->access_type); 766 /* errors are only due to memory allocation, not debugfs */ 767 if (err < 0) 768 return err; 769 } 770 771 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_PROBES) 772 err = snd_sof_debugfs_probe_item(sdev, "probe_points", 773 0644, &probe_points_fops); 774 if (err < 0) 775 return err; 776 err = snd_sof_debugfs_probe_item(sdev, "probe_points_remove", 777 0200, &probe_points_remove_fops); 778 if (err < 0) 779 return err; 780 #endif 781 782 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_IPC_FLOOD_TEST) 783 /* create read-write ipc_flood_count debugfs entry */ 784 err = snd_sof_debugfs_buf_item(sdev, NULL, 0, 785 "ipc_flood_count", 0666); 786 787 /* errors are only due to memory allocation, not debugfs */ 788 if (err < 0) 789 return err; 790 791 /* create read-write ipc_flood_duration_ms debugfs entry */ 792 err = snd_sof_debugfs_buf_item(sdev, NULL, 0, 793 "ipc_flood_duration_ms", 0666); 794 795 /* errors are only due to memory allocation, not debugfs */ 796 if (err < 0) 797 return err; 798 #endif 799 800 return 0; 801 } 802 EXPORT_SYMBOL_GPL(snd_sof_dbg_init); 803 804 void snd_sof_free_debug(struct snd_sof_dev *sdev) 805 { 806 debugfs_remove_recursive(sdev->debugfs_root); 807 } 808 EXPORT_SYMBOL_GPL(snd_sof_free_debug); 809 810 void snd_sof_handle_fw_exception(struct snd_sof_dev *sdev) 811 { 812 if (IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_RETAIN_DSP_CONTEXT) || 813 (sof_core_debug & SOF_DBG_RETAIN_CTX)) { 814 /* should we prevent DSP entering D3 ? */ 815 dev_info(sdev->dev, "info: preventing DSP entering D3 state to preserve context\n"); 816 pm_runtime_get_noresume(sdev->dev); 817 } 818 819 /* dump vital information to the logs */ 820 snd_sof_dsp_dbg_dump(sdev, SOF_DBG_DUMP_REGS | SOF_DBG_DUMP_MBOX); 821 snd_sof_ipc_dump(sdev); 822 snd_sof_trace_notify_for_error(sdev); 823 } 824 EXPORT_SYMBOL(snd_sof_handle_fw_exception); 825