1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // Copyright(c) 2022 Intel Corporation 4 // 5 // Author: Peter Ujfalusi <peter.ujfalusi@linux.intel.com> 6 // 7 8 #include <linux/auxiliary_bus.h> 9 #include <linux/completion.h> 10 #include <linux/debugfs.h> 11 #include <linux/ktime.h> 12 #include <linux/module.h> 13 #include <linux/pm_runtime.h> 14 #include <linux/slab.h> 15 #include <linux/uaccess.h> 16 #include <sound/sof/header.h> 17 #include <sound/sof/ipc4/header.h> 18 19 #include "sof-client.h" 20 21 #define SOF_IPC_CLIENT_SUSPEND_DELAY_MS 3000 22 23 struct sof_msg_inject_priv { 24 struct dentry *dfs_file; 25 size_t max_msg_size; 26 enum sof_ipc_type ipc_type; 27 28 void *tx_buffer; 29 void *rx_buffer; 30 }; 31 32 static int sof_msg_inject_dfs_open(struct inode *inode, struct file *file) 33 { 34 struct sof_client_dev *cdev = inode->i_private; 35 int ret; 36 37 if (sof_client_get_fw_state(cdev) == SOF_FW_CRASHED) 38 return -ENODEV; 39 40 ret = debugfs_file_get(file->f_path.dentry); 41 if (unlikely(ret)) 42 return ret; 43 44 ret = simple_open(inode, file); 45 if (ret) 46 debugfs_file_put(file->f_path.dentry); 47 48 return ret; 49 } 50 51 static ssize_t sof_msg_inject_dfs_read(struct file *file, char __user *buffer, 52 size_t count, loff_t *ppos) 53 { 54 struct sof_client_dev *cdev = file->private_data; 55 struct sof_msg_inject_priv *priv = cdev->data; 56 struct sof_ipc_reply *rhdr = priv->rx_buffer; 57 58 if (!rhdr->hdr.size || !count || *ppos) 59 return 0; 60 61 if (count > rhdr->hdr.size) 62 count = rhdr->hdr.size; 63 64 if (copy_to_user(buffer, priv->rx_buffer, count)) 65 return -EFAULT; 66 67 *ppos += count; 68 return count; 69 } 70 71 static ssize_t sof_msg_inject_ipc4_dfs_read(struct file *file, 72 char __user *buffer, 73 size_t count, loff_t *ppos) 74 { 75 struct sof_client_dev *cdev = file->private_data; 76 struct sof_msg_inject_priv *priv = cdev->data; 77 struct sof_ipc4_msg *ipc4_msg = priv->rx_buffer; 78 size_t header_size = sizeof(ipc4_msg->header_u64); 79 size_t remaining; 80 81 if (!ipc4_msg->header_u64 || !count || *ppos) 82 return 0; 83 84 /* we need space for the header at minimum (u64) */ 85 if (count < header_size) 86 return -ENOSPC; 87 88 remaining = header_size; 89 90 /* Only get large config have payload */ 91 if (SOF_IPC4_MSG_IS_MODULE_MSG(ipc4_msg->primary) && 92 (SOF_IPC4_MSG_TYPE_GET(ipc4_msg->primary) == SOF_IPC4_MOD_LARGE_CONFIG_GET)) 93 remaining += ipc4_msg->data_size; 94 95 if (count > remaining) 96 count = remaining; 97 else if (count < remaining) 98 remaining = count; 99 100 /* copy the header first */ 101 if (copy_to_user(buffer, &ipc4_msg->header_u64, header_size)) 102 return -EFAULT; 103 104 *ppos += header_size; 105 remaining -= header_size; 106 107 if (!remaining) 108 return count; 109 110 if (remaining > ipc4_msg->data_size) 111 remaining = ipc4_msg->data_size; 112 113 /* Copy the payload */ 114 if (copy_to_user(buffer + *ppos, ipc4_msg->data_ptr, remaining)) 115 return -EFAULT; 116 117 *ppos += remaining; 118 return count; 119 } 120 121 static int sof_msg_inject_send_message(struct sof_client_dev *cdev) 122 { 123 struct sof_msg_inject_priv *priv = cdev->data; 124 struct device *dev = &cdev->auxdev.dev; 125 int ret, err; 126 127 ret = pm_runtime_resume_and_get(dev); 128 if (ret < 0 && ret != -EACCES) { 129 dev_err_ratelimited(dev, "debugfs write failed to resume %d\n", ret); 130 return ret; 131 } 132 133 ret = sof_client_boot_dsp(cdev); 134 if (!ret) { 135 /* send the message */ 136 ret = sof_client_ipc_tx_message(cdev, priv->tx_buffer, 137 priv->rx_buffer, 138 priv->max_msg_size); 139 if (ret) 140 dev_err(dev, "IPC message send failed: %d\n", ret); 141 } 142 143 err = pm_runtime_put_autosuspend(dev); 144 if (err < 0) 145 dev_err_ratelimited(dev, "debugfs write failed to idle %d\n", err); 146 147 return ret; 148 } 149 150 static ssize_t sof_msg_inject_dfs_write(struct file *file, const char __user *buffer, 151 size_t count, loff_t *ppos) 152 { 153 struct sof_client_dev *cdev = file->private_data; 154 struct sof_msg_inject_priv *priv = cdev->data; 155 ssize_t size; 156 int ret; 157 158 if (*ppos) 159 return 0; 160 161 size = simple_write_to_buffer(priv->tx_buffer, priv->max_msg_size, 162 ppos, buffer, count); 163 if (size < 0) 164 return size; 165 if (size != count) 166 return -EFAULT; 167 168 memset(priv->rx_buffer, 0, priv->max_msg_size); 169 170 ret = sof_msg_inject_send_message(cdev); 171 172 /* return the error code if test failed */ 173 if (ret < 0) 174 size = ret; 175 176 return size; 177 }; 178 179 static ssize_t sof_msg_inject_ipc4_dfs_write(struct file *file, 180 const char __user *buffer, 181 size_t count, loff_t *ppos) 182 { 183 struct sof_client_dev *cdev = file->private_data; 184 struct sof_msg_inject_priv *priv = cdev->data; 185 struct sof_ipc4_msg *ipc4_msg = priv->tx_buffer; 186 size_t data_size; 187 int ret; 188 189 if (*ppos) 190 return 0; 191 192 if (count < sizeof(ipc4_msg->header_u64)) 193 return -EINVAL; 194 195 /* copy the header first */ 196 if (copy_from_user(&ipc4_msg->header_u64, buffer, 197 sizeof(ipc4_msg->header_u64))) 198 return -EFAULT; 199 200 data_size = count - sizeof(ipc4_msg->header_u64); 201 if (data_size > priv->max_msg_size) 202 return -EINVAL; 203 204 /* Copy the payload */ 205 if (copy_from_user(ipc4_msg->data_ptr, 206 buffer + sizeof(ipc4_msg->header_u64), data_size)) 207 return -EFAULT; 208 209 ipc4_msg->data_size = data_size; 210 211 /* Initialize the reply storage */ 212 ipc4_msg = priv->rx_buffer; 213 ipc4_msg->header_u64 = 0; 214 ipc4_msg->data_size = priv->max_msg_size; 215 memset(ipc4_msg->data_ptr, 0, priv->max_msg_size); 216 217 ret = sof_msg_inject_send_message(cdev); 218 219 /* return the error code if test failed */ 220 if (ret < 0) 221 return ret; 222 223 return count; 224 }; 225 226 static int sof_msg_inject_dfs_release(struct inode *inode, struct file *file) 227 { 228 debugfs_file_put(file->f_path.dentry); 229 230 return 0; 231 } 232 233 static const struct file_operations sof_msg_inject_fops = { 234 .open = sof_msg_inject_dfs_open, 235 .read = sof_msg_inject_dfs_read, 236 .write = sof_msg_inject_dfs_write, 237 .llseek = default_llseek, 238 .release = sof_msg_inject_dfs_release, 239 240 .owner = THIS_MODULE, 241 }; 242 243 static const struct file_operations sof_msg_inject_ipc4_fops = { 244 .open = sof_msg_inject_dfs_open, 245 .read = sof_msg_inject_ipc4_dfs_read, 246 .write = sof_msg_inject_ipc4_dfs_write, 247 .llseek = default_llseek, 248 .release = sof_msg_inject_dfs_release, 249 250 .owner = THIS_MODULE, 251 }; 252 253 static int sof_msg_inject_probe(struct auxiliary_device *auxdev, 254 const struct auxiliary_device_id *id) 255 { 256 struct sof_client_dev *cdev = auxiliary_dev_to_sof_client_dev(auxdev); 257 struct dentry *debugfs_root = sof_client_get_debugfs_root(cdev); 258 static const struct file_operations *fops; 259 struct device *dev = &auxdev->dev; 260 struct sof_msg_inject_priv *priv; 261 size_t alloc_size; 262 263 /* allocate memory for client data */ 264 priv = devm_kzalloc(&auxdev->dev, sizeof(*priv), GFP_KERNEL); 265 if (!priv) 266 return -ENOMEM; 267 268 priv->ipc_type = sof_client_get_ipc_type(cdev); 269 priv->max_msg_size = sof_client_get_ipc_max_payload_size(cdev); 270 alloc_size = priv->max_msg_size; 271 272 if (priv->ipc_type == SOF_IPC_TYPE_4) 273 alloc_size += sizeof(struct sof_ipc4_msg); 274 275 priv->tx_buffer = devm_kmalloc(dev, alloc_size, GFP_KERNEL); 276 priv->rx_buffer = devm_kzalloc(dev, alloc_size, GFP_KERNEL); 277 if (!priv->tx_buffer || !priv->rx_buffer) 278 return -ENOMEM; 279 280 if (priv->ipc_type == SOF_IPC_TYPE_4) { 281 struct sof_ipc4_msg *ipc4_msg; 282 283 ipc4_msg = priv->tx_buffer; 284 ipc4_msg->data_ptr = priv->tx_buffer + sizeof(struct sof_ipc4_msg); 285 286 ipc4_msg = priv->rx_buffer; 287 ipc4_msg->data_ptr = priv->rx_buffer + sizeof(struct sof_ipc4_msg); 288 289 fops = &sof_msg_inject_ipc4_fops; 290 } else { 291 fops = &sof_msg_inject_fops; 292 } 293 294 cdev->data = priv; 295 296 priv->dfs_file = debugfs_create_file("ipc_msg_inject", 0644, debugfs_root, 297 cdev, fops); 298 299 /* enable runtime PM */ 300 pm_runtime_set_autosuspend_delay(dev, SOF_IPC_CLIENT_SUSPEND_DELAY_MS); 301 pm_runtime_use_autosuspend(dev); 302 pm_runtime_enable(dev); 303 pm_runtime_mark_last_busy(dev); 304 pm_runtime_idle(dev); 305 306 return 0; 307 } 308 309 static void sof_msg_inject_remove(struct auxiliary_device *auxdev) 310 { 311 struct sof_client_dev *cdev = auxiliary_dev_to_sof_client_dev(auxdev); 312 struct sof_msg_inject_priv *priv = cdev->data; 313 314 pm_runtime_disable(&auxdev->dev); 315 316 debugfs_remove(priv->dfs_file); 317 } 318 319 static const struct auxiliary_device_id sof_msg_inject_client_id_table[] = { 320 { .name = "snd_sof.msg_injector" }, 321 {}, 322 }; 323 MODULE_DEVICE_TABLE(auxiliary, sof_msg_inject_client_id_table); 324 325 /* 326 * No need for driver pm_ops as the generic pm callbacks in the auxiliary bus 327 * type are enough to ensure that the parent SOF device resumes to bring the DSP 328 * back to D0. 329 * Driver name will be set based on KBUILD_MODNAME. 330 */ 331 static struct auxiliary_driver sof_msg_inject_client_drv = { 332 .probe = sof_msg_inject_probe, 333 .remove = sof_msg_inject_remove, 334 335 .id_table = sof_msg_inject_client_id_table, 336 }; 337 338 module_auxiliary_driver(sof_msg_inject_client_drv); 339 340 MODULE_LICENSE("GPL"); 341 MODULE_DESCRIPTION("SOF IPC Message Injector Client Driver"); 342 MODULE_IMPORT_NS("SND_SOC_SOF_CLIENT"); 343