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