| 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 <[email protected]> |
| 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,fillcolor=white" |
| 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. "[email protected]" |
| 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 "${@}" |