shell: add dai_list and dma_status commands

Add two read-only introspection commands to the SOF shell:

- 'sof dai_list' iterates dai_get_device_list() and prints, per DAI,
  the Zephyr device name, decoded type (ssp/dmic/hda/alh/uaol/sai/
  esai/...), index, current channel count, sample rate, format and
  word size from dai_config_get(), plus per-direction fifo address,
  fifo depth, DMA handshake id and stream id from
  dai_get_properties().

- 'sof dma_status [dma_idx [chan]]' walks dma_info_get()->dma_array
  to list every SOF-registered DMAC (id, channel count, busy count,
  caps/devs bitmasks, base, Zephyr device name) and uses
  sof_dma_get_status() for per-channel state (busy, direction,
  pending/free bytes, read/write positions, total_copied).

Two new Kconfigs (default y, depend on SHELL && ZEPHYR_NATIVE_DRIVERS):
  CONFIG_SOF_SHELL_DAI_LIST
  CONFIG_SOF_SHELL_DMA_STATUS

Pairs with 'sof pipeline_state' for diagnosing P2M/M2P paths without
host-side debug.

Signed-off-by: Liam Girdwood <liam.r.girdwood@linux.intel.com>

Author: lrgirdwo

zephyr/Kconfig

@@ -561,6 +561,42 @@ config SOF_SHELL_PERF_STATUS
 	  reset_performance_counters(); 'stop'/'pause' just update the
 	  state) - useful for taking before/after snapshots without IPC.
 
+config SOF_SHELL_DAI_LIST
+	bool "DAI introspection command"
+	default y
+	depends on SHELL && ZEPHYR_NATIVE_DRIVERS
+	help
+	  Enables 'sof dai_list' which iterates dai_get_device_list()
+	  and prints, per DAI, the Zephyr device name, decoded type
+	  (ssp/dmic/hda/alh/uaol/sai/esai/...), index, current channel
+	  count, sample rate, format and word size from
+	  dai_config_get(), plus per-direction fifo address, fifo depth,
+	  DMA handshake id and stream id from dai_get_properties().
+
+	  Useful for verifying which DAIs were registered for a topology
+	  without going through host-side debug.
+
+config SOF_SHELL_DMA_STATUS
+	bool "DMA controller / channel status command"
+	default y
+	depends on SHELL && ZEPHYR_NATIVE_DRIVERS
+	help
+	  Enables 'sof dma_status [dma_idx [chan]]':
+
+	    'sof dma_status'                  - list every DMA controller
+	                                        registered with SOF (id,
+	                                        channel count, busy count,
+	                                        caps/devs bitmasks, base,
+	                                        Zephyr device name).
+	    'sof dma_status <dma_idx>'        - per-channel status for one
+	                                        controller.
+	    'sof dma_status <dma_idx> <chan>' - status for one channel.
+
+	  Per-channel status comes from sof_dma_get_status() (Zephyr
+	  dma_get_status()) and shows busy/idle, direction, pending and
+	  free bytes, read/write positions and total_copied. Pairs well
+	  with 'sof dai_list' for diagnosing P2M/M2P paths.
+
 endmenu # SOF shell commands
 
 config SOF_VREGIONS

zephyr/shell.md

@@ -76,8 +76,8 @@ debug or testing. Items get ticked off as commands land on `topic/shell`.
 | Power management | `pm_state`, `pm_force <state>`, `pg_status`, `idle_stats` | TODO |
 | Cache | `dcache_flush <addr> <size>`, `dcache_inv`, `icache_inv` | TODO |
 | Watchdog | `wdt_status`, `wdt_kick`, `wdt_disable` | TODO |
-| DAI / link control | `dai_list`, `dai_status <type> <idx>`, `dai_trigger`, `dai_loopback` | TODO |
-| DMA | `dma_list`, `dma_chan_status <dma> <chan>`, `dma_stop` | TODO |
+| **DAI / link control** | `dai_list`, `dai_status <type> <idx>`, `dai_trigger`, `dai_loopback` | **DONE (task 7)** &mdash; `dai_list` covers introspection; trigger/loopback deferred (writeable, needs careful tplg coordination). |
+| **DMA** | `dma_list`, `dma_chan_status <dma> <chan>`, `dma_stop` | **DONE (task 7)** &mdash; `dma_status` covers list+per-channel. `dma_stop` deferred (would corrupt active stream). |
 
 ### Debug
 
@@ -115,7 +115,7 @@ debug or testing. Items get ticked off as commands land on `topic/shell`.
 4. **`log_status` / `mtrace_dump`** &mdash; DONE.
 5. **`mailbox_hex` / `dbgwin_dump`** &mdash; DONE (was originally `crash_log`/`bt`; pivoted because SOF panic.c isn't built on Zephyr and `bt` of a running CPU from itself isn't meaningful).
 6. **`perf_status`** &mdash; DONE.
-7. `dai_list` / `dma_chan_status` &mdash; link/DMA blind spot.
+7. **`dai_list` / `dma_status`** &mdash; DONE.
 8. `kctl_get/set` &mdash; today only doable via tplg/IPC.
 
 ---
@@ -349,3 +349,46 @@ debug or testing. Items get ticked off as commands land on `topic/shell`.
   one row per occupied slot.
 - Zephyr already provides `kernel cpu_load` and `kernel threads`;
   `cpu_load` was therefore not duplicated here.
+
+## Task 7 &mdash; `dai_list` / `dma_status`
+
+### Commands
+
+| Command | Description |
+|---|---|
+| `sof dai_list` | Iterate `dai_get_device_list()` and print, per DAI, the Zephyr device name, decoded type (ssp/dmic/hda/alh/uaol/sai/esai/...), index, current channel count, sample rate, format and word size, plus per-direction fifo address, fifo depth, DMA handshake id and stream id. |
+| `sof dma_status` | List every SOF DMA controller (`dma_info_get()`), with id, channel count, busy count, caps/devs bitmasks, base address and Zephyr device name. |
+| `sof dma_status <dma>` | Walk all channels of one controller, calling `sof_dma_get_status()` on each. |
+| `sof dma_status <dma> <chan>` | Status of a single channel: busy/idle, direction, pending/free bytes, read/write positions, total_copied. |
+
+### Implementation
+
+- `dai_list` uses `dai_get_device_list()` from
+  [src/include/sof/lib/dai-zephyr.h](src/include/sof/lib/dai-zephyr.h)
+  and the Zephyr DAI API
+  (`dai_config_get()`, `dai_get_properties()`); it falls back to
+  TX-only or RX-only `config_get()` when `DAI_DIR_BOTH` is not
+  supported by a driver.
+- `dma_status` walks `sof_get()->dma_info->dma_array[]` (via
+  `dma_info_get()` from
+  [zephyr/include/sof/lib/dma.h](zephyr/include/sof/lib/dma.h))
+  and calls `sof_dma_get_status()` per channel; this re-uses the
+  same Zephyr `dma_get_status()` path the DSP itself uses, so the
+  numbers exactly match runtime audio state.
+- Two new Kconfigs (default `y`, both depend on
+  `ZEPHYR_NATIVE_DRIVERS`):
+  - `CONFIG_SOF_SHELL_DAI_LIST`
+  - `CONFIG_SOF_SHELL_DMA_STATUS`
+- Shell commands in [zephyr/sof_shell.c](zephyr/sof_shell.c).
+
+### Notes / follow-ups
+
+- Read-only on purpose. `dai_trigger`, `dai_loopback`, `dma_stop`
+  were intentionally not added in this pass &mdash; they would corrupt
+  in-flight streams and require coordination with topology / IPC
+  state machines. Pair with the existing `pipeline_state` (gated by
+  `CONFIG_SOF_SHELL_PIPELINE_OPS`) for stream control.
+- `dma_status` only iterates SOF-registered DMACs. Zephyr also
+  ships its own `dma` shell when `CONFIG_DMA_SHELL=y`, but that one
+  walks Zephyr DMA devices and exposes raw register pokes, so the
+  two are complementary.

zephyr/sof_shell.c

@@ -2236,6 +2236,197 @@ __cold static int cmd_sof_perf_status(const struct shell *sh,
 
 #endif /* CONFIG_SOF_SHELL_PERF_STATUS */
 
+#if CONFIG_SOF_SHELL_DAI_LIST || CONFIG_SOF_SHELL_DMA_STATUS
+#include <sof/lib/dai.h>
+#include <zephyr/drivers/dai.h>
+#include <zephyr/drivers/dma.h>
+#endif
+
+#if CONFIG_SOF_SHELL_DAI_LIST
+
+static const char *zephyr_dai_type_str(int t)
+{
+	switch (t) {
+	case DAI_LEGACY_I2S:	return "i2s";
+	case DAI_INTEL_SSP:	return "ssp";
+	case DAI_INTEL_DMIC:	return "dmic";
+	case DAI_INTEL_HDA:	return "hda";
+	case DAI_INTEL_ALH:	return "alh";
+	case DAI_IMX_SAI:	return "sai";
+	case DAI_IMX_ESAI:	return "esai";
+	case DAI_AMD_BT:	return "amd_bt";
+	case DAI_AMD_SP:	return "amd_sp";
+	case DAI_AMD_DMIC:	return "amd_dmic";
+	case DAI_MEDIATEK_AFE:	return "mtk_afe";
+	case DAI_INTEL_SSP_NHLT:  return "ssp_nhlt";
+	case DAI_INTEL_DMIC_NHLT: return "dmic_nhlt";
+	case DAI_INTEL_HDA_NHLT:  return "hda_nhlt";
+	case DAI_INTEL_ALH_NHLT:  return "alh_nhlt";
+	case DAI_IMX_MICFIL:	return "micfil";
+	case DAI_INTEL_UAOL:	return "uaol";
+	case DAI_AMD_SDW:	return "amd_sdw";
+	default:		return "?";
+	}
+}
+
+__cold static int cmd_sof_dai_list(const struct shell *sh,
+				   size_t argc, char *argv[])
+{
+	const struct device **list;
+	size_t count = 0;
+	int i;
+
+	list = dai_get_device_list(&count);
+	if (!list || !count) {
+		shell_print(sh, "No DAIs registered");
+		return 0;
+	}
+
+	shell_print(sh, "%zu DAI(s) registered:", count);
+	shell_print(sh, "  idx  name                       type        index  channels  rate     fmt    word");
+	for (i = 0; i < count; i++) {
+		const struct device *dev = list[i];
+		struct dai_config cfg = {0};
+		const struct dai_properties *props;
+
+		if (dai_config_get(dev, &cfg, DAI_DIR_BOTH)) {
+			/* try TX-only then RX-only */
+			if (dai_config_get(dev, &cfg, DAI_DIR_TX) &&
+			    dai_config_get(dev, &cfg, DAI_DIR_RX)) {
+				shell_print(sh, "  %3d  %-26s  (config_get failed)",
+					    i, dev->name ? dev->name : "?");
+				continue;
+			}
+		}
+
+		shell_print(sh,
+			    "  %3d  %-26s  %-10s  %5u  %8u  %7u  0x%04x %4u",
+			    i, dev->name ? dev->name : "?",
+			    zephyr_dai_type_str(cfg.type), cfg.dai_index,
+			    cfg.channels, cfg.rate, cfg.format, cfg.word_size);
+
+		props = dai_get_properties(dev, DAI_DIR_TX, 0);
+		if (props)
+			shell_print(sh,
+				    "        TX: fifo 0x%08x depth %u hs %u stream %d",
+				    props->fifo_address, props->fifo_depth,
+				    props->dma_hs_id, props->stream_id);
+		props = dai_get_properties(dev, DAI_DIR_RX, 0);
+		if (props)
+			shell_print(sh,
+				    "        RX: fifo 0x%08x depth %u hs %u stream %d",
+				    props->fifo_address, props->fifo_depth,
+				    props->dma_hs_id, props->stream_id);
+	}
+
+	return 0;
+}
+
+#endif /* CONFIG_SOF_SHELL_DAI_LIST */
+
+#if CONFIG_SOF_SHELL_DMA_STATUS
+
+static const char *dma_dir_str(enum dma_channel_direction d)
+{
+	switch (d) {
+	case MEMORY_TO_MEMORY:	return "M2M";
+	case MEMORY_TO_PERIPHERAL: return "M2P";
+	case PERIPHERAL_TO_MEMORY: return "P2M";
+	case PERIPHERAL_TO_PERIPHERAL: return "P2P";
+	case HOST_TO_MEMORY:	return "H2M";
+	case MEMORY_TO_HOST:	return "M2H";
+	default:		return "?";
+	}
+}
+
+static void dma_print_one(const struct shell *sh, struct sof_dma *dma,
+			  int dma_idx, int chan)
+{
+	struct dma_status st = {0};
+	int ret = sof_dma_get_status(dma, chan, &st);
+
+	if (ret) {
+		shell_print(sh, "  dma %d ch %d: get_status -> %d",
+			    dma_idx, chan, ret);
+		return;
+	}
+	shell_print(sh,
+		    "  dma %d ch %d: %s dir=%s pending=%u free=%u rd=%u wr=%u total=%llu",
+		    dma_idx, chan, st.busy ? "BUSY" : "idle",
+		    dma_dir_str(st.dir), st.pending_length, st.free,
+		    st.read_position, st.write_position,
+		    (unsigned long long)st.total_copied);
+}
+
+__cold static int cmd_sof_dma_status(const struct shell *sh,
+				     size_t argc, char *argv[])
+{
+	const struct dma_info *info = dma_info_get();
+	struct sof_dma *dma;
+	int i, ch;
+
+	if (!info || !info->num_dmas) {
+		shell_print(sh, "No DMA controllers registered");
+		return 0;
+	}
+
+	if (argc == 1) {
+		shell_print(sh, "%zu DMA controller(s):", info->num_dmas);
+		shell_print(sh, "  idx  id  channels  busy  caps     devs     base");
+		for (i = 0; i < info->num_dmas; i++) {
+			dma = &info->dma_array[i];
+			shell_print(sh,
+				    "  %3d  %2u  %8u  %4u  0x%04x   0x%04x   0x%08x  (%s)",
+				    i, dma->plat_data.id,
+				    dma->plat_data.channels,
+				    (unsigned int)atomic_get(&dma->num_channels_busy),
+				    dma->plat_data.caps,
+				    dma->plat_data.devs,
+				    dma->plat_data.base,
+				    dma->z_dev && dma->z_dev->name ?
+					dma->z_dev->name : "?");
+		}
+		shell_print(sh,
+			    "Usage: sof dma_status <dma_idx> [chan]  (omit chan to walk all)");
+		return 0;
+	}
+
+	{
+		char *end = NULL;
+		long idx = strtol(argv[1], &end, 0);
+
+		if (end == argv[1] || idx < 0 || idx >= (long)info->num_dmas) {
+			shell_print(sh, "Bad DMA index (0..%zu)",
+				    info->num_dmas - 1);
+			return -EINVAL;
+		}
+		dma = &info->dma_array[idx];
+
+		if (argc > 2) {
+			ch = strtol(argv[2], &end, 0);
+			if (end == argv[2] || ch < 0 ||
+			    ch >= (int)dma->plat_data.channels) {
+				shell_print(sh, "Bad channel (0..%u)",
+					    dma->plat_data.channels - 1);
+				return -EINVAL;
+			}
+			dma_print_one(sh, dma, (int)idx, ch);
+			return 0;
+		}
+
+		shell_print(sh, "DMA %ld (%s): %u channels",
+			    idx, dma->z_dev && dma->z_dev->name ?
+				 dma->z_dev->name : "?",
+			    dma->plat_data.channels);
+		for (ch = 0; ch < (int)dma->plat_data.channels; ch++)
+			dma_print_one(sh, dma, (int)idx, ch);
+	}
+
+	return 0;
+}
+
+#endif /* CONFIG_SOF_SHELL_DMA_STATUS */
+
 SHELL_STATIC_SUBCMD_SET_CREATE(sof_commands,
 	SHELL_CMD(test_inject_sched_gap, NULL,
 		  "Inject a gap to audio scheduling\n",
@@ -2443,6 +2634,20 @@ SHELL_STATIC_SUBCMD_SET_CREATE(sof_commands,
 		  cmd_sof_perf_status, 1, 1),
 #endif
 
+#if CONFIG_SOF_SHELL_DAI_LIST
+	SHELL_CMD(dai_list, NULL,
+		  "List all registered DAIs (name, type, channels, rate, "
+		  "fifo, hs)\n",
+		  cmd_sof_dai_list),
+#endif
+
+#if CONFIG_SOF_SHELL_DMA_STATUS
+	SHELL_CMD_ARG(dma_status, NULL,
+		  "List DMA controllers, or per-channel status: "
+		  "[dma_idx] [chan]\n",
+		  cmd_sof_dma_status, 1, 2),
+#endif
+
 	SHELL_SUBCMD_SET_END
 );