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