1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // Copyright(c) 2022 Intel Corporation. All rights reserved. 4 // 5 // Authors: Ranjani Sridharan <[email protected]> 6 // Peter Ujfalusi <[email protected]> 7 // 8 9 #include <linux/debugfs.h> 10 #include <linux/errno.h> 11 #include <linux/list.h> 12 #include <linux/module.h> 13 #include <linux/mutex.h> 14 #include <linux/slab.h> 15 #include "ops.h" 16 #include "sof-client.h" 17 #include "sof-priv.h" 18 19 /** 20 * struct sof_ipc_event_entry - IPC client event description 21 * @ipc_msg_type: IPC msg type of the event the client is interested 22 * @cdev: sof_client_dev of the requesting client 23 * @callback: Callback function of the client 24 * @list: item in SOF core client event list 25 */ 26 struct sof_ipc_event_entry { 27 u32 ipc_msg_type; 28 struct sof_client_dev *cdev; 29 sof_client_event_callback callback; 30 struct list_head list; 31 }; 32 33 /** 34 * struct sof_state_event_entry - DSP panic event subscription entry 35 * @cdev: sof_client_dev of the requesting client 36 * @callback: Callback function of the client 37 * @list: item in SOF core client event list 38 */ 39 struct sof_state_event_entry { 40 struct sof_client_dev *cdev; 41 sof_client_fw_state_callback callback; 42 struct list_head list; 43 }; 44 45 static void sof_client_auxdev_release(struct device *dev) 46 { 47 struct auxiliary_device *auxdev = to_auxiliary_dev(dev); 48 struct sof_client_dev *cdev = auxiliary_dev_to_sof_client_dev(auxdev); 49 50 kfree(cdev->auxdev.dev.platform_data); 51 kfree(cdev); 52 } 53 54 static int sof_client_dev_add_data(struct sof_client_dev *cdev, const void *data, 55 size_t size) 56 { 57 void *d = NULL; 58 59 if (data) { 60 d = kmemdup(data, size, GFP_KERNEL); 61 if (!d) 62 return -ENOMEM; 63 } 64 65 cdev->auxdev.dev.platform_data = d; 66 return 0; 67 } 68 69 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_IPC_FLOOD_TEST) 70 static int sof_register_ipc_flood_test(struct snd_sof_dev *sdev) 71 { 72 int ret = 0; 73 int i; 74 75 for (i = 0; i < CONFIG_SND_SOC_SOF_DEBUG_IPC_FLOOD_TEST_NUM; i++) { 76 ret = sof_client_dev_register(sdev, "ipc_flood", i, NULL, 0); 77 if (ret < 0) 78 break; 79 } 80 81 if (ret) { 82 for (; i >= 0; --i) 83 sof_client_dev_unregister(sdev, "ipc_flood", i); 84 } 85 86 return ret; 87 } 88 89 static void sof_unregister_ipc_flood_test(struct snd_sof_dev *sdev) 90 { 91 int i; 92 93 for (i = 0; i < CONFIG_SND_SOC_SOF_DEBUG_IPC_FLOOD_TEST_NUM; i++) 94 sof_client_dev_unregister(sdev, "ipc_flood", i); 95 } 96 #else 97 static inline int sof_register_ipc_flood_test(struct snd_sof_dev *sdev) 98 { 99 return 0; 100 } 101 102 static inline void sof_unregister_ipc_flood_test(struct snd_sof_dev *sdev) {} 103 #endif /* CONFIG_SND_SOC_SOF_DEBUG_IPC_FLOOD_TEST */ 104 105 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_IPC_MSG_INJECTOR) 106 static int sof_register_ipc_msg_injector(struct snd_sof_dev *sdev) 107 { 108 return sof_client_dev_register(sdev, "msg_injector", 0, NULL, 0); 109 } 110 111 static void sof_unregister_ipc_msg_injector(struct snd_sof_dev *sdev) 112 { 113 sof_client_dev_unregister(sdev, "msg_injector", 0); 114 } 115 #else 116 static inline int sof_register_ipc_msg_injector(struct snd_sof_dev *sdev) 117 { 118 return 0; 119 } 120 121 static inline void sof_unregister_ipc_msg_injector(struct snd_sof_dev *sdev) {} 122 #endif /* CONFIG_SND_SOC_SOF_DEBUG_IPC_MSG_INJECTOR */ 123 124 int sof_register_clients(struct snd_sof_dev *sdev) 125 { 126 int ret; 127 128 /* Register platform independent client devices */ 129 ret = sof_register_ipc_flood_test(sdev); 130 if (ret) { 131 dev_err(sdev->dev, "IPC flood test client registration failed\n"); 132 return ret; 133 } 134 135 ret = sof_register_ipc_msg_injector(sdev); 136 if (ret) { 137 dev_err(sdev->dev, "IPC message injector client registration failed\n"); 138 goto err_msg_injector; 139 } 140 141 /* Platform depndent client device registration */ 142 143 if (sof_ops(sdev) && sof_ops(sdev)->register_ipc_clients) 144 ret = sof_ops(sdev)->register_ipc_clients(sdev); 145 146 if (!ret) 147 return 0; 148 149 sof_unregister_ipc_msg_injector(sdev); 150 151 err_msg_injector: 152 sof_unregister_ipc_flood_test(sdev); 153 154 return ret; 155 } 156 157 void sof_unregister_clients(struct snd_sof_dev *sdev) 158 { 159 if (sof_ops(sdev) && sof_ops(sdev)->unregister_ipc_clients) 160 sof_ops(sdev)->unregister_ipc_clients(sdev); 161 162 sof_unregister_ipc_msg_injector(sdev); 163 sof_unregister_ipc_flood_test(sdev); 164 } 165 166 int sof_client_dev_register(struct snd_sof_dev *sdev, const char *name, u32 id, 167 const void *data, size_t size) 168 { 169 struct auxiliary_device *auxdev; 170 struct sof_client_dev *cdev; 171 int ret; 172 173 cdev = kzalloc(sizeof(*cdev), GFP_KERNEL); 174 if (!cdev) 175 return -ENOMEM; 176 177 cdev->sdev = sdev; 178 auxdev = &cdev->auxdev; 179 auxdev->name = name; 180 auxdev->dev.parent = sdev->dev; 181 auxdev->dev.release = sof_client_auxdev_release; 182 auxdev->id = id; 183 184 ret = sof_client_dev_add_data(cdev, data, size); 185 if (ret < 0) 186 goto err_dev_add_data; 187 188 ret = auxiliary_device_init(auxdev); 189 if (ret < 0) { 190 dev_err(sdev->dev, "failed to initialize client dev %s.%d\n", name, id); 191 goto err_dev_init; 192 } 193 194 ret = auxiliary_device_add(&cdev->auxdev); 195 if (ret < 0) { 196 dev_err(sdev->dev, "failed to add client dev %s.%d\n", name, id); 197 /* 198 * sof_client_auxdev_release() will be invoked to free up memory 199 * allocations through put_device() 200 */ 201 auxiliary_device_uninit(&cdev->auxdev); 202 return ret; 203 } 204 205 /* add to list of SOF client devices */ 206 mutex_lock(&sdev->ipc_client_mutex); 207 list_add(&cdev->list, &sdev->ipc_client_list); 208 mutex_unlock(&sdev->ipc_client_mutex); 209 210 return 0; 211 212 err_dev_init: 213 kfree(cdev->auxdev.dev.platform_data); 214 215 err_dev_add_data: 216 kfree(cdev); 217 218 return ret; 219 } 220 EXPORT_SYMBOL_NS_GPL(sof_client_dev_register, SND_SOC_SOF_CLIENT); 221 222 void sof_client_dev_unregister(struct snd_sof_dev *sdev, const char *name, u32 id) 223 { 224 struct sof_client_dev *cdev; 225 226 mutex_lock(&sdev->ipc_client_mutex); 227 228 /* 229 * sof_client_auxdev_release() will be invoked to free up memory 230 * allocations through put_device() 231 */ 232 list_for_each_entry(cdev, &sdev->ipc_client_list, list) { 233 if (!strcmp(cdev->auxdev.name, name) && cdev->auxdev.id == id) { 234 list_del(&cdev->list); 235 auxiliary_device_delete(&cdev->auxdev); 236 auxiliary_device_uninit(&cdev->auxdev); 237 break; 238 } 239 } 240 241 mutex_unlock(&sdev->ipc_client_mutex); 242 } 243 EXPORT_SYMBOL_NS_GPL(sof_client_dev_unregister, SND_SOC_SOF_CLIENT); 244 245 int sof_client_ipc_tx_message(struct sof_client_dev *cdev, void *ipc_msg, 246 void *reply_data, size_t reply_bytes) 247 { 248 struct sof_ipc_cmd_hdr *hdr = ipc_msg; 249 250 return sof_ipc_tx_message(cdev->sdev->ipc, ipc_msg, hdr->size, 251 reply_data, reply_bytes); 252 } 253 EXPORT_SYMBOL_NS_GPL(sof_client_ipc_tx_message, SND_SOC_SOF_CLIENT); 254 255 int sof_suspend_clients(struct snd_sof_dev *sdev, pm_message_t state) 256 { 257 struct auxiliary_driver *adrv; 258 struct sof_client_dev *cdev; 259 260 mutex_lock(&sdev->ipc_client_mutex); 261 262 list_for_each_entry(cdev, &sdev->ipc_client_list, list) { 263 /* Skip devices without loaded driver */ 264 if (!cdev->auxdev.dev.driver) 265 continue; 266 267 adrv = to_auxiliary_drv(cdev->auxdev.dev.driver); 268 if (adrv->suspend) 269 adrv->suspend(&cdev->auxdev, state); 270 } 271 272 mutex_unlock(&sdev->ipc_client_mutex); 273 274 return 0; 275 } 276 EXPORT_SYMBOL_NS_GPL(sof_suspend_clients, SND_SOC_SOF_CLIENT); 277 278 int sof_resume_clients(struct snd_sof_dev *sdev) 279 { 280 struct auxiliary_driver *adrv; 281 struct sof_client_dev *cdev; 282 283 mutex_lock(&sdev->ipc_client_mutex); 284 285 list_for_each_entry(cdev, &sdev->ipc_client_list, list) { 286 /* Skip devices without loaded driver */ 287 if (!cdev->auxdev.dev.driver) 288 continue; 289 290 adrv = to_auxiliary_drv(cdev->auxdev.dev.driver); 291 if (adrv->resume) 292 adrv->resume(&cdev->auxdev); 293 } 294 295 mutex_unlock(&sdev->ipc_client_mutex); 296 297 return 0; 298 } 299 EXPORT_SYMBOL_NS_GPL(sof_resume_clients, SND_SOC_SOF_CLIENT); 300 301 struct dentry *sof_client_get_debugfs_root(struct sof_client_dev *cdev) 302 { 303 return cdev->sdev->debugfs_root; 304 } 305 EXPORT_SYMBOL_NS_GPL(sof_client_get_debugfs_root, SND_SOC_SOF_CLIENT); 306 307 /* DMA buffer allocation in client drivers must use the core SOF device */ 308 struct device *sof_client_get_dma_dev(struct sof_client_dev *cdev) 309 { 310 return cdev->sdev->dev; 311 } 312 EXPORT_SYMBOL_NS_GPL(sof_client_get_dma_dev, SND_SOC_SOF_CLIENT); 313 314 const struct sof_ipc_fw_version *sof_client_get_fw_version(struct sof_client_dev *cdev) 315 { 316 struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev); 317 318 return &sdev->fw_ready.version; 319 } 320 EXPORT_SYMBOL_NS_GPL(sof_client_get_fw_version, SND_SOC_SOF_CLIENT); 321 322 size_t sof_client_get_ipc_max_payload_size(struct sof_client_dev *cdev) 323 { 324 struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev); 325 326 return sdev->ipc->max_payload_size; 327 } 328 EXPORT_SYMBOL_NS_GPL(sof_client_get_ipc_max_payload_size, SND_SOC_SOF_CLIENT); 329 330 /* module refcount management of SOF core */ 331 int sof_client_core_module_get(struct sof_client_dev *cdev) 332 { 333 struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev); 334 335 if (!try_module_get(sdev->dev->driver->owner)) 336 return -ENODEV; 337 338 return 0; 339 } 340 EXPORT_SYMBOL_NS_GPL(sof_client_core_module_get, SND_SOC_SOF_CLIENT); 341 342 void sof_client_core_module_put(struct sof_client_dev *cdev) 343 { 344 struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev); 345 346 module_put(sdev->dev->driver->owner); 347 } 348 EXPORT_SYMBOL_NS_GPL(sof_client_core_module_put, SND_SOC_SOF_CLIENT); 349 350 /* IPC event handling */ 351 void sof_client_ipc_rx_dispatcher(struct snd_sof_dev *sdev, void *msg_buf) 352 { 353 struct sof_ipc_cmd_hdr *hdr = msg_buf; 354 u32 msg_type = hdr->cmd & SOF_GLB_TYPE_MASK; 355 struct sof_ipc_event_entry *event; 356 357 mutex_lock(&sdev->client_event_handler_mutex); 358 359 list_for_each_entry(event, &sdev->ipc_rx_handler_list, list) { 360 if (event->ipc_msg_type == msg_type) 361 event->callback(event->cdev, msg_buf); 362 } 363 364 mutex_unlock(&sdev->client_event_handler_mutex); 365 } 366 367 int sof_client_register_ipc_rx_handler(struct sof_client_dev *cdev, 368 u32 ipc_msg_type, 369 sof_client_event_callback callback) 370 { 371 struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev); 372 struct sof_ipc_event_entry *event; 373 374 if (!callback || !(ipc_msg_type & SOF_GLB_TYPE_MASK)) 375 return -EINVAL; 376 377 event = kmalloc(sizeof(*event), GFP_KERNEL); 378 if (!event) 379 return -ENOMEM; 380 381 event->ipc_msg_type = ipc_msg_type; 382 event->cdev = cdev; 383 event->callback = callback; 384 385 /* add to list of SOF client devices */ 386 mutex_lock(&sdev->client_event_handler_mutex); 387 list_add(&event->list, &sdev->ipc_rx_handler_list); 388 mutex_unlock(&sdev->client_event_handler_mutex); 389 390 return 0; 391 } 392 EXPORT_SYMBOL_NS_GPL(sof_client_register_ipc_rx_handler, SND_SOC_SOF_CLIENT); 393 394 void sof_client_unregister_ipc_rx_handler(struct sof_client_dev *cdev, 395 u32 ipc_msg_type) 396 { 397 struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev); 398 struct sof_ipc_event_entry *event; 399 400 mutex_lock(&sdev->client_event_handler_mutex); 401 402 list_for_each_entry(event, &sdev->ipc_rx_handler_list, list) { 403 if (event->cdev == cdev && event->ipc_msg_type == ipc_msg_type) { 404 list_del(&event->list); 405 kfree(event); 406 break; 407 } 408 } 409 410 mutex_unlock(&sdev->client_event_handler_mutex); 411 } 412 EXPORT_SYMBOL_NS_GPL(sof_client_unregister_ipc_rx_handler, SND_SOC_SOF_CLIENT); 413 414 /*DSP state notification and query */ 415 void sof_client_fw_state_dispatcher(struct snd_sof_dev *sdev) 416 { 417 struct sof_state_event_entry *event; 418 419 mutex_lock(&sdev->client_event_handler_mutex); 420 421 list_for_each_entry(event, &sdev->fw_state_handler_list, list) 422 event->callback(event->cdev, sdev->fw_state); 423 424 mutex_unlock(&sdev->client_event_handler_mutex); 425 } 426 427 int sof_client_register_fw_state_handler(struct sof_client_dev *cdev, 428 sof_client_fw_state_callback callback) 429 { 430 struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev); 431 struct sof_state_event_entry *event; 432 433 if (!callback) 434 return -EINVAL; 435 436 event = kmalloc(sizeof(*event), GFP_KERNEL); 437 if (!event) 438 return -ENOMEM; 439 440 event->cdev = cdev; 441 event->callback = callback; 442 443 /* add to list of SOF client devices */ 444 mutex_lock(&sdev->client_event_handler_mutex); 445 list_add(&event->list, &sdev->fw_state_handler_list); 446 mutex_unlock(&sdev->client_event_handler_mutex); 447 448 return 0; 449 } 450 EXPORT_SYMBOL_NS_GPL(sof_client_register_fw_state_handler, SND_SOC_SOF_CLIENT); 451 452 void sof_client_unregister_fw_state_handler(struct sof_client_dev *cdev) 453 { 454 struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev); 455 struct sof_state_event_entry *event; 456 457 mutex_lock(&sdev->client_event_handler_mutex); 458 459 list_for_each_entry(event, &sdev->fw_state_handler_list, list) { 460 if (event->cdev == cdev) { 461 list_del(&event->list); 462 kfree(event); 463 break; 464 } 465 } 466 467 mutex_unlock(&sdev->client_event_handler_mutex); 468 } 469 EXPORT_SYMBOL_NS_GPL(sof_client_unregister_fw_state_handler, SND_SOC_SOF_CLIENT); 470 471 enum sof_fw_state sof_client_get_fw_state(struct sof_client_dev *cdev) 472 { 473 struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev); 474 475 return sdev->fw_state; 476 } 477 EXPORT_SYMBOL_NS_GPL(sof_client_get_fw_state, SND_SOC_SOF_CLIENT); 478