1 #!/bin/sh
2 # SPDX-License-Identifier: GPL-2.0
3 #
4 # Generate a graph of the current DAPM state for an audio card
5 #
6 # Copyright 2024 Bootlin
7 # Author: Luca Ceresoli <luca.ceresol@bootlin.com>
8
9 set -eu
10
11 STYLE_COMPONENT_ON="color=dodgerblue;style=bold"
12 STYLE_COMPONENT_OFF="color=gray40;style=filled;fillcolor=gray90"
13 STYLE_NODE_ON="shape=box,style=bold,color=green4"
14 STYLE_NODE_OFF="shape=box,style=filled,color=gray30,fillcolor=gray95"
15
16 # Print usage and exit
17 #
18 # $1 = exit return value
19 # $2 = error string (required if $1 != 0)
20 usage()
21 {
22 if [ "${1}" -ne 0 ]; then
23 echo "${2}" >&2
24 fi
25
26 echo "
27 Generate a graph of the current DAPM state for an audio card.
28
29 The DAPM state can be obtained via debugfs for a card on the local host or
30 a remote target, or from a local copy of the debugfs tree for the card.
31
32 Usage:
33 $(basename $0) [options] -c CARD - Local sound card
34 $(basename $0) [options] -c CARD -r REMOTE_TARGET - Card on remote system
35 $(basename $0) [options] -d STATE_DIR - Local directory
36
37 Options:
38 -c CARD Sound card to get DAPM state of
39 -r REMOTE_TARGET Get DAPM state from REMOTE_TARGET via SSH and SCP
40 instead of using a local sound card
41 -d STATE_DIR Get DAPM state from a local copy of a debugfs tree
42 -o OUT_FILE Output file (default: dapm.dot)
43 -D Show verbose debugging info
44 -h Print this help and exit
45
46 The output format is implied by the extension of OUT_FILE:
47
48 * Use the .dot extension to generate a text graph representation in
49 graphviz dot syntax.
50 * Any other extension is assumed to be a format supported by graphviz for
51 rendering, e.g. 'png', 'svg', and will produce both the .dot file and a
52 picture from it. This requires the 'dot' program from the graphviz
53 package.
54 "
55
56 exit ${1}
57 }
58
59 # Connect to a remote target via SSH, collect all DAPM files from debufs
60 # into a tarball and get the tarball via SCP into $3/dapm.tar
61 #
62 # $1 = target as used by ssh and scp, e.g. "root@192.168.1.1"
63 # $2 = sound card name
64 # $3 = temp dir path (present on the host, created on the target)
65 # $4 = local directory to extract the tarball into
66 #
67 # Requires an ssh+scp server, find and tar+gz on the target
68 #
69 # Note: the tarball is needed because plain 'scp -r' from debugfs would
70 # copy only empty files
71 grab_remote_files()
72 {
73 echo "Collecting DAPM state from ${1}"
74 dbg_echo "Collected DAPM state in ${3}"
75
76 ssh "${1}" "
77 set -eu &&
78 cd \"/sys/kernel/debug/asoc/${2}\" &&
79 find * -type d -exec mkdir -p ${3}/dapm-tree/{} \; &&
80 find * -type f -exec cp \"{}\" \"${3}/dapm-tree/{}\" \; &&
81 cd ${3}/dapm-tree &&
82 tar cf ${3}/dapm.tar ."
83 scp -q "${1}:${3}/dapm.tar" "${3}"
84
85 mkdir -p "${4}"
86 tar xf "${tmp_dir}/dapm.tar" -C "${4}"
87 }
88
89 # Parse a widget file and generate graph description in graphviz dot format
90 #
91 # Skips any file named "bias_level".
92 #
93 # $1 = temporary work dir
94 # $2 = component name
95 # $3 = widget filename
96 process_dapm_widget()
97 {
98 local tmp_dir="${1}"
99 local c_name="${2}"
100 local w_file="${3}"
101 local dot_file="${tmp_dir}/main.dot"
102 local links_file="${tmp_dir}/links.dot"
103
104 local w_name="$(basename "${w_file}")"
105 local w_tag="${c_name}_${w_name}"
106
107 if [ "${w_name}" = "bias_level" ]; then
108 return 0
109 fi
110
111 dbg_echo " + Widget: ${w_name}"
112
113 cat "${w_file}" | (
114 read line
115
116 if echo "${line}" | grep -q ': On '
117 then local node_style="${STYLE_NODE_ON}"
118 else local node_style="${STYLE_NODE_OFF}"
119 fi
120
121 local w_type=""
122 while read line; do
123 # Collect widget type if present
124 if echo "${line}" | grep -q '^widget-type '; then
125 local w_type_raw="$(echo "$line" | cut -d ' ' -f 2)"
126 dbg_echo " - Widget type: ${w_type_raw}"
127
128 # Note: escaping '\n' is tricky to get working with both
129 # bash and busybox ash, so use a '%' here and replace it
130 # later
131 local w_type="%n[${w_type_raw}]"
132 fi
133
134 # Collect any links. We could use "in" links or "out" links,
135 # let's use "in" links
136 if echo "${line}" | grep -q '^in '; then
137 local w_route=$(echo "$line" | awk -F\" '{print $2}')
138 local w_src=$(echo "$line" |
139 awk -F\" '{print $6 "_" $4}' |
140 sed 's/^(null)_/ROOT_/')
141 dbg_echo " - Input route from: ${w_src}"
142 dbg_echo " - Route: ${w_route}"
143 local w_edge_attrs=""
144 if [ "${w_route}" != "static" ]; then
145 w_edge_attrs=" [label=\"${w_route}\"]"
146 fi
147 echo " \"${w_src}\" -> \"$w_tag\"${w_edge_attrs}" >> "${links_file}"
148 fi
149 done
150
151 echo " \"${w_tag}\" [label=\"${w_name}${w_type}\",${node_style}]" |
152 tr '%' '\\' >> "${dot_file}"
153 )
154 }
155
156 # Parse the DAPM tree for a sound card component and generate graph
157 # description in graphviz dot format
158 #
159 # $1 = temporary work dir
160 # $2 = component directory
161 # $3 = "ROOT" for the root card directory, empty otherwise
162 process_dapm_component()
163 {
164 local tmp_dir="${1}"
165 local c_dir="${2}"
166 local c_name="${3}"
167 local is_component=0
168 local dot_file="${tmp_dir}/main.dot"
169 local links_file="${tmp_dir}/links.dot"
170 local c_attribs=""
171
172 if [ -z "${c_name}" ]; then
173 is_component=1
174
175 # Extract directory name into component name:
176 # "./cs42l51.0-004a/dapm" -> "cs42l51.0-004a"
177 c_name="$(basename $(dirname "${c_dir}"))"
178 fi
179
180 dbg_echo " * Component: ${c_name}"
181
182 if [ ${is_component} = 1 ]; then
183 if [ -f "${c_dir}/bias_level" ]; then
184 c_onoff=$(sed -n -e 1p "${c_dir}/bias_level" | awk '{print $1}')
185 dbg_echo " - bias_level: ${c_onoff}"
186 if [ "$c_onoff" = "On" ]; then
187 c_attribs="${STYLE_COMPONENT_ON}"
188 elif [ "$c_onoff" = "Off" ]; then
189 c_attribs="${STYLE_COMPONENT_OFF}"
190 fi
191 fi
192
193 echo "" >> "${dot_file}"
194 echo " subgraph \"${c_name}\" {" >> "${dot_file}"
195 echo " cluster = true" >> "${dot_file}"
196 echo " label = \"${c_name}\"" >> "${dot_file}"
197 echo " ${c_attribs}" >> "${dot_file}"
198 fi
199
200 # Create empty file to ensure it will exist in all cases
201 >"${links_file}"
202
203 # Iterate over widgets in the component dir
204 for w_file in ${c_dir}/*; do
205 process_dapm_widget "${tmp_dir}" "${c_name}" "${w_file}"
206 done
207
208 if [ ${is_component} = 1 ]; then
209 echo " }" >> "${dot_file}"
210 fi
211
212 cat "${links_file}" >> "${dot_file}"
213 }
214
215 # Parse the DAPM tree for a sound card and generate graph description in
216 # graphviz dot format
217 #
218 # $1 = temporary work dir
219 # $2 = directory tree with DAPM state (either in debugfs or a mirror)
220 process_dapm_tree()
221 {
222 local tmp_dir="${1}"
223 local dapm_dir="${2}"
224 local dot_file="${tmp_dir}/main.dot"
225
226 echo "digraph G {" > "${dot_file}"
227 echo " fontname=\"sans-serif\"" >> "${dot_file}"
228 echo " node [fontname=\"sans-serif\"]" >> "${dot_file}"
229 echo " edge [fontname=\"sans-serif\"]" >> "${dot_file}"
230
231 # Process root directory (no component)
232 process_dapm_component "${tmp_dir}" "${dapm_dir}/dapm" "ROOT"
233
234 # Iterate over components
235 for c_dir in "${dapm_dir}"/*/dapm
236 do
237 process_dapm_component "${tmp_dir}" "${c_dir}" ""
238 done
239
240 echo "}" >> "${dot_file}"
241 }
242
243 main()
244 {
245 # Parse command line
246 local out_file="dapm.dot"
247 local card_name=""
248 local remote_target=""
249 local dapm_tree=""
250 local dbg_on=""
251 while getopts "c:r:d:o:Dh" arg; do
252 case $arg in
253 c) card_name="${OPTARG}" ;;
254 r) remote_target="${OPTARG}" ;;
255 d) dapm_tree="${OPTARG}" ;;
256 o) out_file="${OPTARG}" ;;
257 D) dbg_on="1" ;;
258 h) usage 0 ;;
259 *) usage 1 ;;
260 esac
261 done
262 shift $(($OPTIND - 1))
263
264 if [ -n "${dapm_tree}" ]; then
265 if [ -n "${card_name}${remote_target}" ]; then
266 usage 1 "Cannot use -c and -r with -d"
267 fi
268 echo "Using local tree: ${dapm_tree}"
269 elif [ -n "${remote_target}" ]; then
270 if [ -z "${card_name}" ]; then
271 usage 1 "-r requires -c"
272 fi
273 echo "Using card ${card_name} from remote target ${remote_target}"
274 elif [ -n "${card_name}" ]; then
275 echo "Using local card: ${card_name}"
276 else
277 usage 1 "Please choose mode using -c, -r or -d"
278 fi
279
280 # Define logging function
281 if [ "${dbg_on}" ]; then
282 dbg_echo() {
283 echo "$*" >&2
284 }
285 else
286 dbg_echo() {
287 :
288 }
289 fi
290
291 # Filename must have a dot in order the infer the format from the
292 # extension
293 if ! echo "${out_file}" | grep -qE '\.'; then
294 echo "Missing extension in output filename ${out_file}" >&2
295 usage
296 exit 1
297 fi
298
299 local out_fmt="${out_file##*.}"
300 local dot_file="${out_file%.*}.dot"
301
302 dbg_echo "dot file: $dot_file"
303 dbg_echo "Output file: $out_file"
304 dbg_echo "Output format: $out_fmt"
305
306 tmp_dir="$(mktemp -d /tmp/$(basename $0).XXXXXX)"
307 trap "{ rm -fr ${tmp_dir}; }" INT TERM EXIT
308
309 if [ -z "${dapm_tree}" ]
310 then
311 dapm_tree="/sys/kernel/debug/asoc/${card_name}"
312 fi
313 if [ -n "${remote_target}" ]; then
314 dapm_tree="${tmp_dir}/dapm-tree"
315 grab_remote_files "${remote_target}" "${card_name}" "${tmp_dir}" "${dapm_tree}"
316 fi
317 # In all cases now ${dapm_tree} contains the DAPM state
318
319 process_dapm_tree "${tmp_dir}" "${dapm_tree}"
320 cp "${tmp_dir}/main.dot" "${dot_file}"
321
322 if [ "${out_file}" != "${dot_file}" ]; then
323 dot -T"${out_fmt}" "${dot_file}" -o "${out_file}"
324 fi
325
326 echo "Generated file ${out_file}"
327 }
328
329 main "${@}"
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.