sof/sof-client.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 //
   3 // Copyright(c) 2022 Intel Corporation. All rights reserved.
   4 //
   5 // Authors: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
   6 //          Peter Ujfalusi <peter.ujfalusi@linux.intel.com>
   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_suspend_clients(struct snd_sof_dev *sdev, pm_message_t state)
 269 {
 270         struct auxiliary_driver *adrv;
 271         struct sof_client_dev *cdev;
 272
 273         mutex_lock(&sdev->ipc_client_mutex);
 274
 275         list_for_each_entry(cdev, &sdev->ipc_client_list, list) {
 276                 /* Skip devices without loaded driver */
 277                 if (!cdev->auxdev.dev.driver)
 278                         continue;
 279
 280                 adrv = to_auxiliary_drv(cdev->auxdev.dev.driver);
 281                 if (adrv->suspend)
 282                         adrv->suspend(&cdev->auxdev, state);
 283         }
 284
 285         mutex_unlock(&sdev->ipc_client_mutex);
 286
 287         return 0;
 288 }
 289 EXPORT_SYMBOL_NS_GPL(sof_suspend_clients, SND_SOC_SOF_CLIENT);
 290
 291 int sof_resume_clients(struct snd_sof_dev *sdev)
 292 {
 293         struct auxiliary_driver *adrv;
 294         struct sof_client_dev *cdev;
 295
 296         mutex_lock(&sdev->ipc_client_mutex);
 297
 298         list_for_each_entry(cdev, &sdev->ipc_client_list, list) {
 299                 /* Skip devices without loaded driver */
 300                 if (!cdev->auxdev.dev.driver)
 301                         continue;
 302
 303                 adrv = to_auxiliary_drv(cdev->auxdev.dev.driver);
 304                 if (adrv->resume)
 305                         adrv->resume(&cdev->auxdev);
 306         }
 307
 308         mutex_unlock(&sdev->ipc_client_mutex);
 309
 310         return 0;
 311 }
 312 EXPORT_SYMBOL_NS_GPL(sof_resume_clients, SND_SOC_SOF_CLIENT);
 313
 314 struct dentry *sof_client_get_debugfs_root(struct sof_client_dev *cdev)
 315 {
 316         return cdev->sdev->debugfs_root;
 317 }
 318 EXPORT_SYMBOL_NS_GPL(sof_client_get_debugfs_root, SND_SOC_SOF_CLIENT);
 319
 320 /* DMA buffer allocation in client drivers must use the core SOF device */
 321 struct device *sof_client_get_dma_dev(struct sof_client_dev *cdev)
 322 {
 323         return cdev->sdev->dev;
 324 }
 325 EXPORT_SYMBOL_NS_GPL(sof_client_get_dma_dev, SND_SOC_SOF_CLIENT);
 326
 327 const struct sof_ipc_fw_version *sof_client_get_fw_version(struct sof_client_dev *cdev)
 328 {
 329         struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev);
 330
 331         return &sdev->fw_ready.version;
 332 }
 333 EXPORT_SYMBOL_NS_GPL(sof_client_get_fw_version, SND_SOC_SOF_CLIENT);
 334
 335 size_t sof_client_get_ipc_max_payload_size(struct sof_client_dev *cdev)
 336 {
 337         struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev);
 338
 339         return sdev->ipc->max_payload_size;
 340 }
 341 EXPORT_SYMBOL_NS_GPL(sof_client_get_ipc_max_payload_size, SND_SOC_SOF_CLIENT);
 342
 343 enum sof_ipc_type sof_client_get_ipc_type(struct sof_client_dev *cdev)
 344 {
 345         struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev);
 346
 347         return sdev->pdata->ipc_type;
 348 }
 349 EXPORT_SYMBOL_NS_GPL(sof_client_get_ipc_type, SND_SOC_SOF_CLIENT);
 350
 351 /* module refcount management of SOF core */
 352 int sof_client_core_module_get(struct sof_client_dev *cdev)
 353 {
 354         struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev);
 355
 356         if (!try_module_get(sdev->dev->driver->owner))
 357                 return -ENODEV;
 358
 359         return 0;
 360 }
 361 EXPORT_SYMBOL_NS_GPL(sof_client_core_module_get, SND_SOC_SOF_CLIENT);
 362
 363 void sof_client_core_module_put(struct sof_client_dev *cdev)
 364 {
 365         struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev);
 366
 367         module_put(sdev->dev->driver->owner);
 368 }
 369 EXPORT_SYMBOL_NS_GPL(sof_client_core_module_put, SND_SOC_SOF_CLIENT);
 370
 371 /* IPC event handling */
 372 void sof_client_ipc_rx_dispatcher(struct snd_sof_dev *sdev, void *msg_buf)
 373 {
 374         struct sof_ipc_event_entry *event;
 375         u32 msg_type;
 376
 377         if (sdev->pdata->ipc_type == SOF_IPC) {
 378                 struct sof_ipc_cmd_hdr *hdr = msg_buf;
 379
 380                 msg_type = hdr->cmd & SOF_GLB_TYPE_MASK;
 381         } else if (sdev->pdata->ipc_type == SOF_INTEL_IPC4) {
 382                 struct sof_ipc4_msg *msg = msg_buf;
 383
 384                 msg_type = SOF_IPC4_NOTIFICATION_TYPE_GET(msg->primary);
 385         } else {
 386                 dev_dbg_once(sdev->dev, "Not supported IPC version: %d\n",
 387                              sdev->pdata->ipc_type);
 388                 return;
 389         }
 390
 391         mutex_lock(&sdev->client_event_handler_mutex);
 392
 393         list_for_each_entry(event, &sdev->ipc_rx_handler_list, list) {
 394                 if (event->ipc_msg_type == msg_type)
 395                         event->callback(event->cdev, msg_buf);
 396         }
 397
 398         mutex_unlock(&sdev->client_event_handler_mutex);
 399 }
 400
 401 int sof_client_register_ipc_rx_handler(struct sof_client_dev *cdev,
 402                                        u32 ipc_msg_type,
 403                                        sof_client_event_callback callback)
 404 {
 405         struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev);
 406         struct sof_ipc_event_entry *event;
 407
 408         if (!callback)
 409                 return -EINVAL;
 410
 411         if (cdev->sdev->pdata->ipc_type == SOF_IPC) {
 412                 if (!(ipc_msg_type & SOF_GLB_TYPE_MASK))
 413                         return -EINVAL;
 414         } else if (cdev->sdev->pdata->ipc_type == SOF_INTEL_IPC4) {
 415                 if (!(ipc_msg_type & SOF_IPC4_NOTIFICATION_TYPE_MASK))
 416                         return -EINVAL;
 417         } else {
 418                 dev_warn(sdev->dev, "%s: Not supported IPC version: %d\n",
 419                          __func__, sdev->pdata->ipc_type);
 420                 return -EINVAL;
 421         }
 422
 423         event = kmalloc(sizeof(*event), GFP_KERNEL);
 424         if (!event)
 425                 return -ENOMEM;
 426
 427         event->ipc_msg_type = ipc_msg_type;
 428         event->cdev = cdev;
 429         event->callback = callback;
 430
 431         /* add to list of SOF client devices */
 432         mutex_lock(&sdev->client_event_handler_mutex);
 433         list_add(&event->list, &sdev->ipc_rx_handler_list);
 434         mutex_unlock(&sdev->client_event_handler_mutex);
 435
 436         return 0;
 437 }
 438 EXPORT_SYMBOL_NS_GPL(sof_client_register_ipc_rx_handler, SND_SOC_SOF_CLIENT);
 439
 440 void sof_client_unregister_ipc_rx_handler(struct sof_client_dev *cdev,
 441                                           u32 ipc_msg_type)
 442 {
 443         struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev);
 444         struct sof_ipc_event_entry *event;
 445
 446         mutex_lock(&sdev->client_event_handler_mutex);
 447
 448         list_for_each_entry(event, &sdev->ipc_rx_handler_list, list) {
 449                 if (event->cdev == cdev && event->ipc_msg_type == ipc_msg_type) {
 450                         list_del(&event->list);
 451                         kfree(event);
 452                         break;
 453                 }
 454         }
 455
 456         mutex_unlock(&sdev->client_event_handler_mutex);
 457 }
 458 EXPORT_SYMBOL_NS_GPL(sof_client_unregister_ipc_rx_handler, SND_SOC_SOF_CLIENT);
 459
 460 /*DSP state notification and query */
 461 void sof_client_fw_state_dispatcher(struct snd_sof_dev *sdev)
 462 {
 463         struct sof_state_event_entry *event;
 464
 465         mutex_lock(&sdev->client_event_handler_mutex);
 466
 467         list_for_each_entry(event, &sdev->fw_state_handler_list, list)
 468                 event->callback(event->cdev, sdev->fw_state);
 469
 470         mutex_unlock(&sdev->client_event_handler_mutex);
 471 }
 472
 473 int sof_client_register_fw_state_handler(struct sof_client_dev *cdev,
 474                                          sof_client_fw_state_callback callback)
 475 {
 476         struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev);
 477         struct sof_state_event_entry *event;
 478
 479         if (!callback)
 480                 return -EINVAL;
 481
 482         event = kmalloc(sizeof(*event), GFP_KERNEL);
 483         if (!event)
 484                 return -ENOMEM;
 485
 486         event->cdev = cdev;
 487         event->callback = callback;
 488
 489         /* add to list of SOF client devices */
 490         mutex_lock(&sdev->client_event_handler_mutex);
 491         list_add(&event->list, &sdev->fw_state_handler_list);
 492         mutex_unlock(&sdev->client_event_handler_mutex);
 493
 494         return 0;
 495 }
 496 EXPORT_SYMBOL_NS_GPL(sof_client_register_fw_state_handler, SND_SOC_SOF_CLIENT);
 497
 498 void sof_client_unregister_fw_state_handler(struct sof_client_dev *cdev)
 499 {
 500         struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev);
 501         struct sof_state_event_entry *event;
 502
 503         mutex_lock(&sdev->client_event_handler_mutex);
 504
 505         list_for_each_entry(event, &sdev->fw_state_handler_list, list) {
 506                 if (event->cdev == cdev) {
 507                         list_del(&event->list);
 508                         kfree(event);
 509                         break;
 510                 }
 511         }
 512
 513         mutex_unlock(&sdev->client_event_handler_mutex);
 514 }
 515 EXPORT_SYMBOL_NS_GPL(sof_client_unregister_fw_state_handler, SND_SOC_SOF_CLIENT);
 516
 517 enum sof_fw_state sof_client_get_fw_state(struct sof_client_dev *cdev)
 518 {
 519         struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev);
 520
 521         return sdev->fw_state;
 522 }
 523 EXPORT_SYMBOL_NS_GPL(sof_client_get_fw_state, SND_SOC_SOF_CLIENT);