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