sof/ipc3-control.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
   2 //
   3 // This file is provided under a dual BSD/GPLv2 license.  When using or
   4 // redistributing this file, you may do so under either license.
   5 //
   6 // Copyright(c) 2021 Intel Corporation. All rights reserved.
   7 //
   8 //
   9
  10 #include "sof-priv.h"
  11 #include "sof-audio.h"
  12 #include "ipc3-priv.h"
  13
  14 /* IPC set()/get() for kcontrols. */
  15 static int sof_ipc3_set_get_kcontrol_data(struct snd_sof_control *scontrol, bool set)
  16 {
  17         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scontrol->scomp);
  18         struct sof_ipc_ctrl_data *cdata = scontrol->ipc_control_data;
  19         const struct sof_ipc_ops *iops = sdev->ipc->ops;
  20         enum sof_ipc_ctrl_type ctrl_type;
  21         struct snd_sof_widget *swidget;
  22         bool widget_found = false;
  23         u32 ipc_cmd, msg_bytes;
  24
  25         list_for_each_entry(swidget, &sdev->widget_list, list) {
  26                 if (swidget->comp_id == scontrol->comp_id) {
  27                         widget_found = true;
  28                         break;
  29                 }
  30         }
  31
  32         if (!widget_found) {
  33                 dev_err(sdev->dev, "%s: can't find widget with id %d\n", __func__,
  34                         scontrol->comp_id);
  35                 return -EINVAL;
  36         }
  37
  38         /*
  39          * Volatile controls should always be part of static pipelines and the widget use_count
  40          * would always be > 0 in this case. For the others, just return the cached value if the
  41          * widget is not set up.
  42          */
  43         if (!swidget->use_count)
  44                 return 0;
  45
  46         /*
  47          * Select the IPC cmd and the ctrl_type based on the ctrl_cmd and the
  48          * direction
  49          * Note: SOF_CTRL_TYPE_VALUE_COMP_* is not used and supported currently
  50          *       for ctrl_type
  51          */
  52         if (cdata->cmd == SOF_CTRL_CMD_BINARY) {
  53                 ipc_cmd = set ? SOF_IPC_COMP_SET_DATA : SOF_IPC_COMP_GET_DATA;
  54                 ctrl_type = set ? SOF_CTRL_TYPE_DATA_SET : SOF_CTRL_TYPE_DATA_GET;
  55         } else {
  56                 ipc_cmd = set ? SOF_IPC_COMP_SET_VALUE : SOF_IPC_COMP_GET_VALUE;
  57                 ctrl_type = set ? SOF_CTRL_TYPE_VALUE_CHAN_SET : SOF_CTRL_TYPE_VALUE_CHAN_GET;
  58         }
  59
  60         cdata->rhdr.hdr.cmd = SOF_IPC_GLB_COMP_MSG | ipc_cmd;
  61         cdata->type = ctrl_type;
  62         cdata->comp_id = scontrol->comp_id;
  63         cdata->msg_index = 0;
  64
  65         /* calculate header and data size */
  66         switch (cdata->type) {
  67         case SOF_CTRL_TYPE_VALUE_CHAN_GET:
  68         case SOF_CTRL_TYPE_VALUE_CHAN_SET:
  69                 cdata->num_elems = scontrol->num_channels;
  70
  71                 msg_bytes = scontrol->num_channels *
  72                             sizeof(struct sof_ipc_ctrl_value_chan);
  73                 msg_bytes += sizeof(struct sof_ipc_ctrl_data);
  74                 break;
  75         case SOF_CTRL_TYPE_DATA_GET:
  76         case SOF_CTRL_TYPE_DATA_SET:
  77                 cdata->num_elems = cdata->data->size;
  78
  79                 msg_bytes = cdata->data->size;
  80                 msg_bytes += sizeof(struct sof_ipc_ctrl_data) +
  81                              sizeof(struct sof_abi_hdr);
  82                 break;
  83         default:
  84                 return -EINVAL;
  85         }
  86
  87         cdata->rhdr.hdr.size = msg_bytes;
  88         cdata->elems_remaining = 0;
  89
  90         return iops->set_get_data(sdev, cdata, cdata->rhdr.hdr.size, set);
  91 }
  92
  93 static void snd_sof_refresh_control(struct snd_sof_control *scontrol)
  94 {
  95         struct sof_ipc_ctrl_data *cdata = scontrol->ipc_control_data;
  96         struct snd_soc_component *scomp = scontrol->scomp;
  97         int ret;
  98
  99         if (!scontrol->comp_data_dirty)
 100                 return;
 101
 102         if (!pm_runtime_active(scomp->dev))
 103                 return;
 104
 105         /* set the ABI header values */
 106         cdata->data->magic = SOF_ABI_MAGIC;
 107         cdata->data->abi = SOF_ABI_VERSION;
 108
 109         /* refresh the component data from DSP */
 110         scontrol->comp_data_dirty = false;
 111         ret = sof_ipc3_set_get_kcontrol_data(scontrol, false);
 112         if (ret < 0) {
 113                 dev_err(scomp->dev, "Failed to get control data: %d\n", ret);
 114
 115                 /* Set the flag to re-try next time to get the data */
 116                 scontrol->comp_data_dirty = true;
 117         }
 118 }
 119
 120 static int sof_ipc3_volume_get(struct snd_sof_control *scontrol,
 121                                struct snd_ctl_elem_value *ucontrol)
 122 {
 123         struct sof_ipc_ctrl_data *cdata = scontrol->ipc_control_data;
 124         unsigned int channels = scontrol->num_channels;
 125         unsigned int i;
 126
 127         snd_sof_refresh_control(scontrol);
 128
 129         /* read back each channel */
 130         for (i = 0; i < channels; i++)
 131                 ucontrol->value.integer.value[i] = ipc_to_mixer(cdata->chanv[i].value,
 132                                                                 scontrol->volume_table,
 133                                                                 scontrol->max + 1);
 134
 135         return 0;
 136 }
 137
 138 static bool sof_ipc3_volume_put(struct snd_sof_control *scontrol,
 139                                 struct snd_ctl_elem_value *ucontrol)
 140 {
 141         struct sof_ipc_ctrl_data *cdata = scontrol->ipc_control_data;
 142         struct snd_soc_component *scomp = scontrol->scomp;
 143         unsigned int channels = scontrol->num_channels;
 144         unsigned int i;
 145         bool change = false;
 146
 147         /* update each channel */
 148         for (i = 0; i < channels; i++) {
 149                 u32 value = mixer_to_ipc(ucontrol->value.integer.value[i],
 150                                          scontrol->volume_table, scontrol->max + 1);
 151
 152                 change = change || (value != cdata->chanv[i].value);
 153                 cdata->chanv[i].channel = i;
 154                 cdata->chanv[i].value = value;
 155         }
 156
 157         /* notify DSP of mixer updates */
 158         if (pm_runtime_active(scomp->dev)) {
 159                 int ret = sof_ipc3_set_get_kcontrol_data(scontrol, true);
 160
 161                 if (ret < 0) {
 162                         dev_err(scomp->dev, "Failed to set mixer updates for %s\n",
 163                                 scontrol->name);
 164                         return false;
 165                 }
 166         }
 167
 168         return change;
 169 }
 170
 171 static int sof_ipc3_switch_get(struct snd_sof_control *scontrol,
 172                                struct snd_ctl_elem_value *ucontrol)
 173 {
 174         struct sof_ipc_ctrl_data *cdata = scontrol->ipc_control_data;
 175         unsigned int channels = scontrol->num_channels;
 176         unsigned int i;
 177
 178         snd_sof_refresh_control(scontrol);
 179
 180         /* read back each channel */
 181         for (i = 0; i < channels; i++)
 182                 ucontrol->value.integer.value[i] = cdata->chanv[i].value;
 183
 184         return 0;
 185 }
 186
 187 static bool sof_ipc3_switch_put(struct snd_sof_control *scontrol,
 188                                 struct snd_ctl_elem_value *ucontrol)
 189 {
 190         struct sof_ipc_ctrl_data *cdata = scontrol->ipc_control_data;
 191         struct snd_soc_component *scomp = scontrol->scomp;
 192         unsigned int channels = scontrol->num_channels;
 193         unsigned int i;
 194         bool change = false;
 195         u32 value;
 196
 197         /* update each channel */
 198         for (i = 0; i < channels; i++) {
 199                 value = ucontrol->value.integer.value[i];
 200                 change = change || (value != cdata->chanv[i].value);
 201                 cdata->chanv[i].channel = i;
 202                 cdata->chanv[i].value = value;
 203         }
 204
 205         /* notify DSP of mixer updates */
 206         if (pm_runtime_active(scomp->dev)) {
 207                 int ret = sof_ipc3_set_get_kcontrol_data(scontrol, true);
 208
 209                 if (ret < 0) {
 210                         dev_err(scomp->dev, "Failed to set mixer updates for %s\n",
 211                                 scontrol->name);
 212                         return false;
 213                 }
 214         }
 215
 216         return change;
 217 }
 218
 219 static int sof_ipc3_enum_get(struct snd_sof_control *scontrol,
 220                              struct snd_ctl_elem_value *ucontrol)
 221 {
 222         struct sof_ipc_ctrl_data *cdata = scontrol->ipc_control_data;
 223         unsigned int channels = scontrol->num_channels;
 224         unsigned int i;
 225
 226         snd_sof_refresh_control(scontrol);
 227
 228         /* read back each channel */
 229         for (i = 0; i < channels; i++)
 230                 ucontrol->value.enumerated.item[i] = cdata->chanv[i].value;
 231
 232         return 0;
 233 }
 234
 235 static bool sof_ipc3_enum_put(struct snd_sof_control *scontrol,
 236                               struct snd_ctl_elem_value *ucontrol)
 237 {
 238         struct sof_ipc_ctrl_data *cdata = scontrol->ipc_control_data;
 239         struct snd_soc_component *scomp = scontrol->scomp;
 240         unsigned int channels = scontrol->num_channels;
 241         unsigned int i;
 242         bool change = false;
 243         u32 value;
 244
 245         /* update each channel */
 246         for (i = 0; i < channels; i++) {
 247                 value = ucontrol->value.enumerated.item[i];
 248                 change = change || (value != cdata->chanv[i].value);
 249                 cdata->chanv[i].channel = i;
 250                 cdata->chanv[i].value = value;
 251         }
 252
 253         /* notify DSP of enum updates */
 254         if (pm_runtime_active(scomp->dev)) {
 255                 int ret = sof_ipc3_set_get_kcontrol_data(scontrol, true);
 256
 257                 if (ret < 0) {
 258                         dev_err(scomp->dev, "Failed to set enum updates for %s\n",
 259                                 scontrol->name);
 260                         return false;
 261                 }
 262         }
 263
 264         return change;
 265 }
 266
 267 static int sof_ipc3_bytes_get(struct snd_sof_control *scontrol,
 268                               struct snd_ctl_elem_value *ucontrol)
 269 {
 270         struct sof_ipc_ctrl_data *cdata = scontrol->ipc_control_data;
 271         struct snd_soc_component *scomp = scontrol->scomp;
 272         struct sof_abi_hdr *data = cdata->data;
 273         size_t size;
 274
 275         snd_sof_refresh_control(scontrol);
 276
 277         if (scontrol->max_size > sizeof(ucontrol->value.bytes.data)) {
 278                 dev_err_ratelimited(scomp->dev, "data max %zu exceeds ucontrol data array size\n",
 279                                     scontrol->max_size);
 280                 return -EINVAL;
 281         }
 282
 283         /* be->max has been verified to be >= sizeof(struct sof_abi_hdr) */
 284         if (data->size > scontrol->max_size - sizeof(*data)) {
 285                 dev_err_ratelimited(scomp->dev,
 286                                     "%u bytes of control data is invalid, max is %zu\n",
 287                                     data->size, scontrol->max_size - sizeof(*data));
 288                 return -EINVAL;
 289         }
 290
 291         size = data->size + sizeof(*data);
 292
 293         /* copy back to kcontrol */
 294         memcpy(ucontrol->value.bytes.data, data, size);
 295
 296         return 0;
 297 }
 298
 299 static int sof_ipc3_bytes_put(struct snd_sof_control *scontrol,
 300                               struct snd_ctl_elem_value *ucontrol)
 301 {
 302         struct sof_ipc_ctrl_data *cdata = scontrol->ipc_control_data;
 303         struct snd_soc_component *scomp = scontrol->scomp;
 304         struct sof_abi_hdr *data = cdata->data;
 305         size_t size;
 306
 307         if (scontrol->max_size > sizeof(ucontrol->value.bytes.data)) {
 308                 dev_err_ratelimited(scomp->dev, "data max %zu exceeds ucontrol data array size\n",
 309                                     scontrol->max_size);
 310                 return -EINVAL;
 311         }
 312
 313         /* scontrol->max_size has been verified to be >= sizeof(struct sof_abi_hdr) */
 314         if (data->size > scontrol->max_size - sizeof(*data)) {
 315                 dev_err_ratelimited(scomp->dev, "data size too big %u bytes max is %zu\n",
 316                                     data->size, scontrol->max_size - sizeof(*data));
 317                 return -EINVAL;
 318         }
 319
 320         size = data->size + sizeof(*data);
 321
 322         /* copy from kcontrol */
 323         memcpy(data, ucontrol->value.bytes.data, size);
 324
 325         /* notify DSP of byte control updates */
 326         if (pm_runtime_active(scomp->dev))
 327                 return sof_ipc3_set_get_kcontrol_data(scontrol, true);
 328
 329         return 0;
 330 }
 331
 332 static int sof_ipc3_bytes_ext_get(struct snd_sof_control *scontrol,
 333                                   const unsigned int __user *binary_data, unsigned int size)
 334 {
 335         struct snd_ctl_tlv __user *tlvd = (struct snd_ctl_tlv __user *)binary_data;
 336         struct sof_ipc_ctrl_data *cdata = scontrol->ipc_control_data;
 337         struct snd_soc_component *scomp = scontrol->scomp;
 338         struct snd_ctl_tlv header;
 339         size_t data_size;
 340
 341         snd_sof_refresh_control(scontrol);
 342
 343         /*
 344          * Decrement the limit by ext bytes header size to
 345          * ensure the user space buffer is not exceeded.
 346          */
 347         if (size < sizeof(struct snd_ctl_tlv))
 348                 return -ENOSPC;
 349
 350         size -= sizeof(struct snd_ctl_tlv);
 351
 352         /* set the ABI header values */
 353         cdata->data->magic = SOF_ABI_MAGIC;
 354         cdata->data->abi = SOF_ABI_VERSION;
 355
 356         /* check data size doesn't exceed max coming from topology */
 357         if (cdata->data->size > scontrol->max_size - sizeof(struct sof_abi_hdr)) {
 358                 dev_err_ratelimited(scomp->dev, "User data size %d exceeds max size %zu\n",
 359                                     cdata->data->size,
 360                                     scontrol->max_size - sizeof(struct sof_abi_hdr));
 361                 return -EINVAL;
 362         }
 363
 364         data_size = cdata->data->size + sizeof(struct sof_abi_hdr);
 365
 366         /* make sure we don't exceed size provided by user space for data */
 367         if (data_size > size)
 368                 return -ENOSPC;
 369
 370         header.numid = cdata->cmd;
 371         header.length = data_size;
 372         if (copy_to_user(tlvd, &header, sizeof(struct snd_ctl_tlv)))
 373                 return -EFAULT;
 374
 375         if (copy_to_user(tlvd->tlv, cdata->data, data_size))
 376                 return -EFAULT;
 377
 378         return 0;
 379 }
 380
 381 static int sof_ipc3_bytes_ext_put(struct snd_sof_control *scontrol,
 382                                   const unsigned int __user *binary_data,
 383                                   unsigned int size)
 384 {
 385         const struct snd_ctl_tlv __user *tlvd = (const struct snd_ctl_tlv __user *)binary_data;
 386         struct sof_ipc_ctrl_data *cdata = scontrol->ipc_control_data;
 387         struct snd_soc_component *scomp = scontrol->scomp;
 388         struct snd_ctl_tlv header;
 389
 390         /*
 391          * The beginning of bytes data contains a header from where
 392          * the length (as bytes) is needed to know the correct copy
 393          * length of data from tlvd->tlv.
 394          */
 395         if (copy_from_user(&header, tlvd, sizeof(struct snd_ctl_tlv)))
 396                 return -EFAULT;
 397
 398         /* make sure TLV info is consistent */
 399         if (header.length + sizeof(struct snd_ctl_tlv) > size) {
 400                 dev_err_ratelimited(scomp->dev, "Inconsistent TLV, data %d + header %zu > %d\n",
 401                                     header.length, sizeof(struct snd_ctl_tlv), size);
 402                 return -EINVAL;
 403         }
 404
 405         /* be->max is coming from topology */
 406         if (header.length > scontrol->max_size) {
 407                 dev_err_ratelimited(scomp->dev, "Bytes data size %d exceeds max %zu\n",
 408                                     header.length, scontrol->max_size);
 409                 return -EINVAL;
 410         }
 411
 412         /* Check that header id matches the command */
 413         if (header.numid != cdata->cmd) {
 414                 dev_err_ratelimited(scomp->dev, "Incorrect command for bytes put %d\n",
 415                                     header.numid);
 416                 return -EINVAL;
 417         }
 418
 419         if (copy_from_user(cdata->data, tlvd->tlv, header.length))
 420                 return -EFAULT;
 421
 422         if (cdata->data->magic != SOF_ABI_MAGIC) {
 423                 dev_err_ratelimited(scomp->dev, "Wrong ABI magic 0x%08x\n", cdata->data->magic);
 424                 return -EINVAL;
 425         }
 426
 427         if (SOF_ABI_VERSION_INCOMPATIBLE(SOF_ABI_VERSION, cdata->data->abi)) {
 428                 dev_err_ratelimited(scomp->dev, "Incompatible ABI version 0x%08x\n",
 429                                     cdata->data->abi);
 430                 return -EINVAL;
 431         }
 432
 433         /* be->max has been verified to be >= sizeof(struct sof_abi_hdr) */
 434         if (cdata->data->size > scontrol->max_size - sizeof(struct sof_abi_hdr)) {
 435                 dev_err_ratelimited(scomp->dev, "Mismatch in ABI data size (truncated?)\n");
 436                 return -EINVAL;
 437         }
 438
 439         /* notify DSP of byte control updates */
 440         if (pm_runtime_active(scomp->dev))
 441                 return sof_ipc3_set_get_kcontrol_data(scontrol, true);
 442
 443         return 0;
 444 }
 445
 446 static int sof_ipc3_bytes_ext_volatile_get(struct snd_sof_control *scontrol,
 447                                            const unsigned int __user *binary_data,
 448                                            unsigned int size)
 449 {
 450         struct snd_ctl_tlv __user *tlvd = (struct snd_ctl_tlv __user *)binary_data;
 451         struct sof_ipc_ctrl_data *cdata = scontrol->ipc_control_data;
 452         struct snd_soc_component *scomp = scontrol->scomp;
 453         struct snd_ctl_tlv header;
 454         size_t data_size;
 455         int ret;
 456
 457         /*
 458          * Decrement the limit by ext bytes header size to
 459          * ensure the user space buffer is not exceeded.
 460          */
 461         if (size < sizeof(struct snd_ctl_tlv))
 462                 return -ENOSPC;
 463
 464         size -= sizeof(struct snd_ctl_tlv);
 465
 466         /* set the ABI header values */
 467         cdata->data->magic = SOF_ABI_MAGIC;
 468         cdata->data->abi = SOF_ABI_VERSION;
 469
 470         /* get all the component data from DSP */
 471         ret = sof_ipc3_set_get_kcontrol_data(scontrol, false);
 472         if (ret < 0)
 473                 return ret;
 474
 475         /* check data size doesn't exceed max coming from topology */
 476         if (cdata->data->size > scontrol->max_size - sizeof(struct sof_abi_hdr)) {
 477                 dev_err_ratelimited(scomp->dev, "User data size %d exceeds max size %zu\n",
 478                                     cdata->data->size,
 479                                     scontrol->max_size - sizeof(struct sof_abi_hdr));
 480                 return -EINVAL;
 481         }
 482
 483         data_size = cdata->data->size + sizeof(struct sof_abi_hdr);
 484
 485         /* make sure we don't exceed size provided by user space for data */
 486         if (data_size > size)
 487                 return -ENOSPC;
 488
 489         header.numid = cdata->cmd;
 490         header.length = data_size;
 491         if (copy_to_user(tlvd, &header, sizeof(struct snd_ctl_tlv)))
 492                 return -EFAULT;
 493
 494         if (copy_to_user(tlvd->tlv, cdata->data, data_size))
 495                 return -EFAULT;
 496
 497         return ret;
 498 }
 499
 500 static void snd_sof_update_control(struct snd_sof_control *scontrol,
 501                                    struct sof_ipc_ctrl_data *cdata)
 502 {
 503         struct snd_soc_component *scomp = scontrol->scomp;
 504         struct sof_ipc_ctrl_data *local_cdata;
 505         int i;
 506
 507         local_cdata = scontrol->ipc_control_data;
 508
 509         if (cdata->cmd == SOF_CTRL_CMD_BINARY) {
 510                 if (cdata->num_elems != local_cdata->data->size) {
 511                         dev_err(scomp->dev, "cdata binary size mismatch %u - %u\n",
 512                                 cdata->num_elems, local_cdata->data->size);
 513                         return;
 514                 }
 515
 516                 /* copy the new binary data */
 517                 memcpy(local_cdata->data, cdata->data, cdata->num_elems);
 518         } else if (cdata->num_elems != scontrol->num_channels) {
 519                 dev_err(scomp->dev, "cdata channel count mismatch %u - %d\n",
 520                         cdata->num_elems, scontrol->num_channels);
 521         } else {
 522                 /* copy the new values */
 523                 for (i = 0; i < cdata->num_elems; i++)
 524                         local_cdata->chanv[i].value = cdata->chanv[i].value;
 525         }
 526 }
 527
 528 static void sof_ipc3_control_update(struct snd_sof_dev *sdev, void *ipc_control_message)
 529 {
 530         struct sof_ipc_ctrl_data *cdata = ipc_control_message;
 531         struct snd_soc_dapm_widget *widget;
 532         struct snd_sof_control *scontrol;
 533         struct snd_sof_widget *swidget;
 534         struct snd_kcontrol *kc = NULL;
 535         struct soc_mixer_control *sm;
 536         struct soc_bytes_ext *be;
 537         size_t expected_size;
 538         struct soc_enum *se;
 539         bool found = false;
 540         int i, type;
 541
 542         if (cdata->type == SOF_CTRL_TYPE_VALUE_COMP_GET ||
 543             cdata->type == SOF_CTRL_TYPE_VALUE_COMP_SET) {
 544                 dev_err(sdev->dev, "Component data is not supported in control notification\n");
 545                 return;
 546         }
 547
 548         /* Find the swidget first */
 549         list_for_each_entry(swidget, &sdev->widget_list, list) {
 550                 if (swidget->comp_id == cdata->comp_id) {
 551                         found = true;
 552                         break;
 553                 }
 554         }
 555
 556         if (!found)
 557                 return;
 558
 559         /* Translate SOF cmd to TPLG type */
 560         switch (cdata->cmd) {
 561         case SOF_CTRL_CMD_VOLUME:
 562         case SOF_CTRL_CMD_SWITCH:
 563                 type = SND_SOC_TPLG_TYPE_MIXER;
 564                 break;
 565         case SOF_CTRL_CMD_BINARY:
 566                 type = SND_SOC_TPLG_TYPE_BYTES;
 567                 break;
 568         case SOF_CTRL_CMD_ENUM:
 569                 type = SND_SOC_TPLG_TYPE_ENUM;
 570                 break;
 571         default:
 572                 dev_err(sdev->dev, "Unknown cmd %u in %s\n", cdata->cmd, __func__);
 573                 return;
 574         }
 575
 576         widget = swidget->widget;
 577         for (i = 0; i < widget->num_kcontrols; i++) {
 578                 /* skip non matching types or non matching indexes within type */
 579                 if (widget->dobj.widget.kcontrol_type[i] == type &&
 580                     widget->kcontrol_news[i].index == cdata->index) {
 581                         kc = widget->kcontrols[i];
 582                         break;
 583                 }
 584         }
 585
 586         if (!kc)
 587                 return;
 588
 589         switch (cdata->cmd) {
 590         case SOF_CTRL_CMD_VOLUME:
 591         case SOF_CTRL_CMD_SWITCH:
 592                 sm = (struct soc_mixer_control *)kc->private_value;
 593                 scontrol = sm->dobj.private;
 594                 break;
 595         case SOF_CTRL_CMD_BINARY:
 596                 be = (struct soc_bytes_ext *)kc->private_value;
 597                 scontrol = be->dobj.private;
 598                 break;
 599         case SOF_CTRL_CMD_ENUM:
 600                 se = (struct soc_enum *)kc->private_value;
 601                 scontrol = se->dobj.private;
 602                 break;
 603         default:
 604                 return;
 605         }
 606
 607         expected_size = sizeof(struct sof_ipc_ctrl_data);
 608         switch (cdata->type) {
 609         case SOF_CTRL_TYPE_VALUE_CHAN_GET:
 610         case SOF_CTRL_TYPE_VALUE_CHAN_SET:
 611                 expected_size += cdata->num_elems *
 612                                  sizeof(struct sof_ipc_ctrl_value_chan);
 613                 break;
 614         case SOF_CTRL_TYPE_DATA_GET:
 615         case SOF_CTRL_TYPE_DATA_SET:
 616                 expected_size += cdata->num_elems + sizeof(struct sof_abi_hdr);
 617                 break;
 618         default:
 619                 return;
 620         }
 621
 622         if (cdata->rhdr.hdr.size != expected_size) {
 623                 dev_err(sdev->dev, "Component notification size mismatch\n");
 624                 return;
 625         }
 626
 627         if (cdata->num_elems)
 628                 /*
 629                  * The message includes the updated value/data, update the
 630                  * control's local cache using the received notification
 631                  */
 632                 snd_sof_update_control(scontrol, cdata);
 633         else
 634                 /* Mark the scontrol that the value/data is changed in SOF */
 635                 scontrol->comp_data_dirty = true;
 636
 637         snd_ctl_notify_one(swidget->scomp->card->snd_card, SNDRV_CTL_EVENT_MASK_VALUE, kc, 0);
 638 }
 639
 640 static int sof_ipc3_widget_kcontrol_setup(struct snd_sof_dev *sdev,
 641                                           struct snd_sof_widget *swidget)
 642 {
 643         struct snd_sof_control *scontrol;
 644         int ret;
 645
 646         /* set up all controls for the widget */
 647         list_for_each_entry(scontrol, &sdev->kcontrol_list, list)
 648                 if (scontrol->comp_id == swidget->comp_id) {
 649                         /* set kcontrol data in DSP */
 650                         ret = sof_ipc3_set_get_kcontrol_data(scontrol, true);
 651                         if (ret < 0) {
 652                                 dev_err(sdev->dev,
 653                                         "kcontrol %d set up failed for widget %s\n",
 654                                         scontrol->comp_id, swidget->widget->name);
 655                                 return ret;
 656                         }
 657
 658                         /*
 659                          * Read back the data from the DSP for static widgets.
 660                          * This is particularly useful for binary kcontrols
 661                          * associated with static pipeline widgets to initialize
 662                          * the data size to match that in the DSP.
 663                          */
 664                         if (swidget->dynamic_pipeline_widget)
 665                                 continue;
 666
 667                         ret = sof_ipc3_set_get_kcontrol_data(scontrol, false);
 668                         if (ret < 0)
 669                                 dev_warn(sdev->dev,
 670                                          "kcontrol %d read failed for widget %s\n",
 671                                          scontrol->comp_id, swidget->widget->name);
 672                 }
 673
 674         return 0;
 675 }
 676
 677 static int
 678 sof_ipc3_set_up_volume_table(struct snd_sof_control *scontrol, int tlv[SOF_TLV_ITEMS], int size)
 679 {
 680         int i;
 681
 682         /* init the volume table */
 683         scontrol->volume_table = kcalloc(size, sizeof(u32), GFP_KERNEL);
 684         if (!scontrol->volume_table)
 685                 return -ENOMEM;
 686
 687         /* populate the volume table */
 688         for (i = 0; i < size ; i++)
 689                 scontrol->volume_table[i] = vol_compute_gain(i, tlv);
 690
 691         return 0;
 692 }
 693
 694 const struct sof_ipc_tplg_control_ops tplg_ipc3_control_ops = {
 695         .volume_put = sof_ipc3_volume_put,
 696         .volume_get = sof_ipc3_volume_get,
 697         .switch_put = sof_ipc3_switch_put,
 698         .switch_get = sof_ipc3_switch_get,
 699         .enum_put = sof_ipc3_enum_put,
 700         .enum_get = sof_ipc3_enum_get,
 701         .bytes_put = sof_ipc3_bytes_put,
 702         .bytes_get = sof_ipc3_bytes_get,
 703         .bytes_ext_put = sof_ipc3_bytes_ext_put,
 704         .bytes_ext_get = sof_ipc3_bytes_ext_get,
 705         .bytes_ext_volatile_get = sof_ipc3_bytes_ext_volatile_get,
 706         .update = sof_ipc3_control_update,
 707         .widget_kcontrol_setup = sof_ipc3_widget_kcontrol_setup,
 708         .set_up_volume_table = sof_ipc3_set_up_volume_table,
 709 };