xref: /linux/sound/soc/sof/sof-client-ipc-flood-test.c (revision 55d0969c451159cff86949b38c39171cab962069)
1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // Copyright(c) 2022 Intel Corporation
4 //
5 // Authors: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
6 //	    Peter Ujfalusi <peter.ujfalusi@linux.intel.com>
7 //
8 
9 #include <linux/auxiliary_bus.h>
10 #include <linux/completion.h>
11 #include <linux/debugfs.h>
12 #include <linux/ktime.h>
13 #include <linux/mod_devicetable.h>
14 #include <linux/module.h>
15 #include <linux/pm_runtime.h>
16 #include <linux/slab.h>
17 #include <linux/uaccess.h>
18 #include <sound/sof/header.h>
19 
20 #include "sof-client.h"
21 
22 #define MAX_IPC_FLOOD_DURATION_MS	1000
23 #define MAX_IPC_FLOOD_COUNT		10000
24 #define IPC_FLOOD_TEST_RESULT_LEN	512
25 #define SOF_IPC_CLIENT_SUSPEND_DELAY_MS	3000
26 
27 #define DEBUGFS_IPC_FLOOD_COUNT		"ipc_flood_count"
28 #define DEBUGFS_IPC_FLOOD_DURATION	"ipc_flood_duration_ms"
29 
30 struct sof_ipc_flood_priv {
31 	struct dentry *dfs_root;
32 	struct dentry *dfs_link[2];
33 	char *buf;
34 };
35 
36 static int sof_ipc_flood_dfs_open(struct inode *inode, struct file *file)
37 {
38 	struct sof_client_dev *cdev = inode->i_private;
39 	int ret;
40 
41 	if (sof_client_get_fw_state(cdev) == SOF_FW_CRASHED)
42 		return -ENODEV;
43 
44 	ret = debugfs_file_get(file->f_path.dentry);
45 	if (unlikely(ret))
46 		return ret;
47 
48 	ret = simple_open(inode, file);
49 	if (ret)
50 		debugfs_file_put(file->f_path.dentry);
51 
52 	return ret;
53 }
54 
55 /*
56  * helper function to perform the flood test. Only one of the two params, ipc_duration_ms
57  * or ipc_count, will be non-zero and will determine the type of test
58  */
59 static int sof_debug_ipc_flood_test(struct sof_client_dev *cdev,
60 				    bool flood_duration_test,
61 				    unsigned long ipc_duration_ms,
62 				    unsigned long ipc_count)
63 {
64 	struct sof_ipc_flood_priv *priv = cdev->data;
65 	struct device *dev = &cdev->auxdev.dev;
66 	struct sof_ipc_cmd_hdr hdr;
67 	u64 min_response_time = U64_MAX;
68 	ktime_t start, end, test_end;
69 	u64 avg_response_time = 0;
70 	u64 max_response_time = 0;
71 	u64 ipc_response_time;
72 	int i = 0;
73 	int ret;
74 
75 	/* configure test IPC */
76 	hdr.cmd = SOF_IPC_GLB_TEST_MSG | SOF_IPC_TEST_IPC_FLOOD;
77 	hdr.size = sizeof(hdr);
78 
79 	/* set test end time for duration flood test */
80 	if (flood_duration_test)
81 		test_end = ktime_get_ns() + ipc_duration_ms * NSEC_PER_MSEC;
82 
83 	/* send test IPC's */
84 	while (1) {
85 		start = ktime_get();
86 		ret = sof_client_ipc_tx_message_no_reply(cdev, &hdr);
87 		end = ktime_get();
88 
89 		if (ret < 0)
90 			break;
91 
92 		/* compute min and max response times */
93 		ipc_response_time = ktime_to_ns(ktime_sub(end, start));
94 		min_response_time = min(min_response_time, ipc_response_time);
95 		max_response_time = max(max_response_time, ipc_response_time);
96 
97 		/* sum up response times */
98 		avg_response_time += ipc_response_time;
99 		i++;
100 
101 		/* test complete? */
102 		if (flood_duration_test) {
103 			if (ktime_to_ns(end) >= test_end)
104 				break;
105 		} else {
106 			if (i == ipc_count)
107 				break;
108 		}
109 	}
110 
111 	if (ret < 0)
112 		dev_err(dev, "ipc flood test failed at %d iterations\n", i);
113 
114 	/* return if the first IPC fails */
115 	if (!i)
116 		return ret;
117 
118 	/* compute average response time */
119 	do_div(avg_response_time, i);
120 
121 	/* clear previous test output */
122 	memset(priv->buf, 0, IPC_FLOOD_TEST_RESULT_LEN);
123 
124 	if (!ipc_count) {
125 		dev_dbg(dev, "IPC Flood test duration: %lums\n", ipc_duration_ms);
126 		snprintf(priv->buf, IPC_FLOOD_TEST_RESULT_LEN,
127 			 "IPC Flood test duration: %lums\n", ipc_duration_ms);
128 	}
129 
130 	dev_dbg(dev, "IPC Flood count: %d, Avg response time: %lluns\n",
131 		i, avg_response_time);
132 	dev_dbg(dev, "Max response time: %lluns\n", max_response_time);
133 	dev_dbg(dev, "Min response time: %lluns\n", min_response_time);
134 
135 	/* format output string and save test results */
136 	snprintf(priv->buf + strlen(priv->buf),
137 		 IPC_FLOOD_TEST_RESULT_LEN - strlen(priv->buf),
138 		 "IPC Flood count: %d\nAvg response time: %lluns\n",
139 		 i, avg_response_time);
140 
141 	snprintf(priv->buf + strlen(priv->buf),
142 		 IPC_FLOOD_TEST_RESULT_LEN - strlen(priv->buf),
143 		 "Max response time: %lluns\nMin response time: %lluns\n",
144 		 max_response_time, min_response_time);
145 
146 	return ret;
147 }
148 
149 /*
150  * Writing to the debugfs entry initiates the IPC flood test based on
151  * the IPC count or the duration specified by the user.
152  */
153 static ssize_t sof_ipc_flood_dfs_write(struct file *file, const char __user *buffer,
154 				       size_t count, loff_t *ppos)
155 {
156 	struct sof_client_dev *cdev = file->private_data;
157 	struct device *dev = &cdev->auxdev.dev;
158 	unsigned long ipc_duration_ms = 0;
159 	bool flood_duration_test = false;
160 	unsigned long ipc_count = 0;
161 	struct dentry *dentry;
162 	int err;
163 	char *string;
164 	int ret;
165 
166 	if (*ppos != 0)
167 		return -EINVAL;
168 
169 	string = kzalloc(count + 1, GFP_KERNEL);
170 	if (!string)
171 		return -ENOMEM;
172 
173 	if (copy_from_user(string, buffer, count)) {
174 		ret = -EFAULT;
175 		goto out;
176 	}
177 
178 	/*
179 	 * write op is only supported for ipc_flood_count or
180 	 * ipc_flood_duration_ms debugfs entries atm.
181 	 * ipc_flood_count floods the DSP with the number of IPC's specified.
182 	 * ipc_duration_ms test floods the DSP for the time specified
183 	 * in the debugfs entry.
184 	 */
185 	dentry = file->f_path.dentry;
186 	if (strcmp(dentry->d_name.name, DEBUGFS_IPC_FLOOD_COUNT) &&
187 	    strcmp(dentry->d_name.name, DEBUGFS_IPC_FLOOD_DURATION)) {
188 		ret = -EINVAL;
189 		goto out;
190 	}
191 
192 	if (!strcmp(dentry->d_name.name, DEBUGFS_IPC_FLOOD_DURATION))
193 		flood_duration_test = true;
194 
195 	/* test completion criterion */
196 	if (flood_duration_test)
197 		ret = kstrtoul(string, 0, &ipc_duration_ms);
198 	else
199 		ret = kstrtoul(string, 0, &ipc_count);
200 	if (ret < 0)
201 		goto out;
202 
203 	/* limit max duration/ipc count for flood test */
204 	if (flood_duration_test) {
205 		if (!ipc_duration_ms) {
206 			ret = count;
207 			goto out;
208 		}
209 
210 		/* find the minimum. min() is not used to avoid warnings */
211 		if (ipc_duration_ms > MAX_IPC_FLOOD_DURATION_MS)
212 			ipc_duration_ms = MAX_IPC_FLOOD_DURATION_MS;
213 	} else {
214 		if (!ipc_count) {
215 			ret = count;
216 			goto out;
217 		}
218 
219 		/* find the minimum. min() is not used to avoid warnings */
220 		if (ipc_count > MAX_IPC_FLOOD_COUNT)
221 			ipc_count = MAX_IPC_FLOOD_COUNT;
222 	}
223 
224 	ret = pm_runtime_resume_and_get(dev);
225 	if (ret < 0 && ret != -EACCES) {
226 		dev_err_ratelimited(dev, "debugfs write failed to resume %d\n", ret);
227 		goto out;
228 	}
229 
230 	/* flood test */
231 	ret = sof_debug_ipc_flood_test(cdev, flood_duration_test,
232 				       ipc_duration_ms, ipc_count);
233 
234 	pm_runtime_mark_last_busy(dev);
235 	err = pm_runtime_put_autosuspend(dev);
236 	if (err < 0)
237 		dev_err_ratelimited(dev, "debugfs write failed to idle %d\n", err);
238 
239 	/* return count if test is successful */
240 	if (ret >= 0)
241 		ret = count;
242 out:
243 	kfree(string);
244 	return ret;
245 }
246 
247 /* return the result of the last IPC flood test */
248 static ssize_t sof_ipc_flood_dfs_read(struct file *file, char __user *buffer,
249 				      size_t count, loff_t *ppos)
250 {
251 	struct sof_client_dev *cdev = file->private_data;
252 	struct sof_ipc_flood_priv *priv = cdev->data;
253 	size_t size_ret;
254 
255 	struct dentry *dentry;
256 
257 	dentry = file->f_path.dentry;
258 	if (!strcmp(dentry->d_name.name, DEBUGFS_IPC_FLOOD_COUNT) ||
259 	    !strcmp(dentry->d_name.name, DEBUGFS_IPC_FLOOD_DURATION)) {
260 		if (*ppos)
261 			return 0;
262 
263 		count = min_t(size_t, count, strlen(priv->buf));
264 		size_ret = copy_to_user(buffer, priv->buf, count);
265 		if (size_ret)
266 			return -EFAULT;
267 
268 		*ppos += count;
269 		return count;
270 	}
271 	return count;
272 }
273 
274 static int sof_ipc_flood_dfs_release(struct inode *inode, struct file *file)
275 {
276 	debugfs_file_put(file->f_path.dentry);
277 
278 	return 0;
279 }
280 
281 static const struct file_operations sof_ipc_flood_fops = {
282 	.open = sof_ipc_flood_dfs_open,
283 	.read = sof_ipc_flood_dfs_read,
284 	.llseek = default_llseek,
285 	.write = sof_ipc_flood_dfs_write,
286 	.release = sof_ipc_flood_dfs_release,
287 
288 	.owner = THIS_MODULE,
289 };
290 
291 /*
292  * The IPC test client creates a couple of debugfs entries that will be used
293  * flood tests. Users can write to these entries to execute the IPC flood test
294  * by specifying either the number of IPCs to flood the DSP with or the duration
295  * (in ms) for which the DSP should be flooded with test IPCs. At the
296  * end of each test, the average, min and max response times are reported back.
297  * The results of the last flood test can be accessed by reading the debugfs
298  * entries.
299  */
300 static int sof_ipc_flood_probe(struct auxiliary_device *auxdev,
301 			       const struct auxiliary_device_id *id)
302 {
303 	struct sof_client_dev *cdev = auxiliary_dev_to_sof_client_dev(auxdev);
304 	struct dentry *debugfs_root = sof_client_get_debugfs_root(cdev);
305 	struct device *dev = &auxdev->dev;
306 	struct sof_ipc_flood_priv *priv;
307 
308 	/* allocate memory for client data */
309 	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
310 	if (!priv)
311 		return -ENOMEM;
312 
313 	priv->buf = devm_kmalloc(dev, IPC_FLOOD_TEST_RESULT_LEN, GFP_KERNEL);
314 	if (!priv->buf)
315 		return -ENOMEM;
316 
317 	cdev->data = priv;
318 
319 	/* create debugfs root folder with device name under parent SOF dir */
320 	priv->dfs_root = debugfs_create_dir(dev_name(dev), debugfs_root);
321 	if (!IS_ERR_OR_NULL(priv->dfs_root)) {
322 		/* create read-write ipc_flood_count debugfs entry */
323 		debugfs_create_file(DEBUGFS_IPC_FLOOD_COUNT, 0644, priv->dfs_root,
324 				    cdev, &sof_ipc_flood_fops);
325 
326 		/* create read-write ipc_flood_duration_ms debugfs entry */
327 		debugfs_create_file(DEBUGFS_IPC_FLOOD_DURATION, 0644,
328 				    priv->dfs_root, cdev, &sof_ipc_flood_fops);
329 
330 		if (auxdev->id == 0) {
331 			/*
332 			 * Create symlinks for backwards compatibility to the
333 			 * first IPC flood test instance
334 			 */
335 			char target[100];
336 
337 			snprintf(target, 100, "%s/" DEBUGFS_IPC_FLOOD_COUNT,
338 				 dev_name(dev));
339 			priv->dfs_link[0] =
340 				debugfs_create_symlink(DEBUGFS_IPC_FLOOD_COUNT,
341 						       debugfs_root, target);
342 
343 			snprintf(target, 100, "%s/" DEBUGFS_IPC_FLOOD_DURATION,
344 				 dev_name(dev));
345 			priv->dfs_link[1] =
346 				debugfs_create_symlink(DEBUGFS_IPC_FLOOD_DURATION,
347 						       debugfs_root, target);
348 		}
349 	}
350 
351 	/* enable runtime PM */
352 	pm_runtime_set_autosuspend_delay(dev, SOF_IPC_CLIENT_SUSPEND_DELAY_MS);
353 	pm_runtime_use_autosuspend(dev);
354 	pm_runtime_enable(dev);
355 	pm_runtime_mark_last_busy(dev);
356 	pm_runtime_idle(dev);
357 
358 	return 0;
359 }
360 
361 static void sof_ipc_flood_remove(struct auxiliary_device *auxdev)
362 {
363 	struct sof_client_dev *cdev = auxiliary_dev_to_sof_client_dev(auxdev);
364 	struct sof_ipc_flood_priv *priv = cdev->data;
365 
366 	pm_runtime_disable(&auxdev->dev);
367 
368 	if (auxdev->id == 0) {
369 		debugfs_remove(priv->dfs_link[0]);
370 		debugfs_remove(priv->dfs_link[1]);
371 	}
372 
373 	debugfs_remove_recursive(priv->dfs_root);
374 }
375 
376 static const struct auxiliary_device_id sof_ipc_flood_client_id_table[] = {
377 	{ .name = "snd_sof.ipc_flood" },
378 	{},
379 };
380 MODULE_DEVICE_TABLE(auxiliary, sof_ipc_flood_client_id_table);
381 
382 /*
383  * No need for driver pm_ops as the generic pm callbacks in the auxiliary bus
384  * type are enough to ensure that the parent SOF device resumes to bring the DSP
385  * back to D0.
386  * Driver name will be set based on KBUILD_MODNAME.
387  */
388 static struct auxiliary_driver sof_ipc_flood_client_drv = {
389 	.probe = sof_ipc_flood_probe,
390 	.remove = sof_ipc_flood_remove,
391 
392 	.id_table = sof_ipc_flood_client_id_table,
393 };
394 
395 module_auxiliary_driver(sof_ipc_flood_client_drv);
396 
397 MODULE_LICENSE("GPL");
398 MODULE_DESCRIPTION("SOF IPC Flood Test Client Driver");
399 MODULE_IMPORT_NS(SND_SOC_SOF_CLIENT);
400