sound/soc/codecs/sigmadsp.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Load Analog Devices SigmaStudio firmware files
   4  *
   5  * Copyright 2009-2014 Analog Devices Inc.
   6  */
   7
   8 #include <linux/crc32.h>
   9 #include <linux/firmware.h>
  10 #include <linux/kernel.h>
  11 #include <linux/i2c.h>
  12 #include <linux/regmap.h>
  13 #include <linux/module.h>
  14 #include <linux/slab.h>
  15
  16 #include <sound/control.h>
  17 #include <sound/soc.h>
  18
  19 #include "sigmadsp.h"
  20
  21 #define SIGMA_MAGIC "ADISIGM"
  22
  23 #define SIGMA_FW_CHUNK_TYPE_DATA 0
  24 #define SIGMA_FW_CHUNK_TYPE_CONTROL 1
  25 #define SIGMA_FW_CHUNK_TYPE_SAMPLERATES 2
  26
  27 #define READBACK_CTRL_NAME "ReadBack"
  28
  29 struct sigmadsp_control {
  30         struct list_head head;
  31         uint32_t samplerates;
  32         unsigned int addr;
  33         unsigned int num_bytes;
  34         const char *name;
  35         struct snd_kcontrol *kcontrol;
  36         bool is_readback;
  37         bool cached;
  38         uint8_t cache[];
  39 };
  40
  41 struct sigmadsp_data {
  42         struct list_head head;
  43         uint32_t samplerates;
  44         unsigned int addr;
  45         unsigned int length;
  46         uint8_t data[] __counted_by(length);
  47 };
  48
  49 struct sigma_fw_chunk {
  50         __le32 length;
  51         __le32 tag;
  52         __le32 samplerates;
  53 } __packed;
  54
  55 struct sigma_fw_chunk_data {
  56         struct sigma_fw_chunk chunk;
  57         __le16 addr;
  58         uint8_t data[];
  59 } __packed;
  60
  61 struct sigma_fw_chunk_control {
  62         struct sigma_fw_chunk chunk;
  63         __le16 type;
  64         __le16 addr;
  65         __le16 num_bytes;
  66         const char name[];
  67 } __packed;
  68
  69 struct sigma_fw_chunk_samplerate {
  70         struct sigma_fw_chunk chunk;
  71         __le32 samplerates[];
  72 } __packed;
  73
  74 struct sigma_firmware_header {
  75         unsigned char magic[7];
  76         u8 version;
  77         __le32 crc;
  78 } __packed;
  79
  80 enum {
  81         SIGMA_ACTION_WRITEXBYTES = 0,
  82         SIGMA_ACTION_WRITESINGLE,
  83         SIGMA_ACTION_WRITESAFELOAD,
  84         SIGMA_ACTION_END,
  85 };
  86
  87 struct sigma_action {
  88         u8 instr;
  89         u8 len_hi;
  90         __le16 len;
  91         __be16 addr;
  92         unsigned char payload[];
  93 } __packed;
  94
  95 static int sigmadsp_write(struct sigmadsp *sigmadsp, unsigned int addr,
  96         const uint8_t data[], size_t len)
  97 {
  98         return sigmadsp->write(sigmadsp->control_data, addr, data, len);
  99 }
 100
 101 static int sigmadsp_read(struct sigmadsp *sigmadsp, unsigned int addr,
 102         uint8_t data[], size_t len)
 103 {
 104         return sigmadsp->read(sigmadsp->control_data, addr, data, len);
 105 }
 106
 107 static int sigmadsp_ctrl_info(struct snd_kcontrol *kcontrol,
 108         struct snd_ctl_elem_info *info)
 109 {
 110         struct sigmadsp_control *ctrl = (void *)kcontrol->private_value;
 111
 112         info->type = SNDRV_CTL_ELEM_TYPE_BYTES;
 113         info->count = ctrl->num_bytes;
 114
 115         return 0;
 116 }
 117
 118 static int sigmadsp_ctrl_write(struct sigmadsp *sigmadsp,
 119         struct sigmadsp_control *ctrl, void *data)
 120 {
 121         /* safeload loads up to 20 bytes in a atomic operation */
 122         if (ctrl->num_bytes <= 20 && sigmadsp->ops && sigmadsp->ops->safeload)
 123                 return sigmadsp->ops->safeload(sigmadsp, ctrl->addr, data,
 124                         ctrl->num_bytes);
 125         else
 126                 return sigmadsp_write(sigmadsp, ctrl->addr, data,
 127                         ctrl->num_bytes);
 128 }
 129
 130 static int sigmadsp_ctrl_put(struct snd_kcontrol *kcontrol,
 131         struct snd_ctl_elem_value *ucontrol)
 132 {
 133         struct sigmadsp_control *ctrl = (void *)kcontrol->private_value;
 134         struct sigmadsp *sigmadsp = snd_kcontrol_chip(kcontrol);
 135         uint8_t *data;
 136         int ret = 0;
 137
 138         mutex_lock(&sigmadsp->lock);
 139
 140         data = ucontrol->value.bytes.data;
 141
 142         if (!(kcontrol->vd[0].access & SNDRV_CTL_ELEM_ACCESS_INACTIVE))
 143                 ret = sigmadsp_ctrl_write(sigmadsp, ctrl, data);
 144
 145         if (ret == 0) {
 146                 memcpy(ctrl->cache, data, ctrl->num_bytes);
 147                 if (!ctrl->is_readback)
 148                         ctrl->cached = true;
 149         }
 150
 151         mutex_unlock(&sigmadsp->lock);
 152
 153         return ret;
 154 }
 155
 156 static int sigmadsp_ctrl_get(struct snd_kcontrol *kcontrol,
 157         struct snd_ctl_elem_value *ucontrol)
 158 {
 159         struct sigmadsp_control *ctrl = (void *)kcontrol->private_value;
 160         struct sigmadsp *sigmadsp = snd_kcontrol_chip(kcontrol);
 161         int ret = 0;
 162
 163         mutex_lock(&sigmadsp->lock);
 164
 165         if (!ctrl->cached) {
 166                 ret = sigmadsp_read(sigmadsp, ctrl->addr, ctrl->cache,
 167                         ctrl->num_bytes);
 168         }
 169
 170         if (ret == 0) {
 171                 if (!ctrl->is_readback)
 172                         ctrl->cached = true;
 173                 memcpy(ucontrol->value.bytes.data, ctrl->cache,
 174                         ctrl->num_bytes);
 175         }
 176
 177         mutex_unlock(&sigmadsp->lock);
 178
 179         return ret;
 180 }
 181
 182 static void sigmadsp_control_free(struct snd_kcontrol *kcontrol)
 183 {
 184         struct sigmadsp_control *ctrl = (void *)kcontrol->private_value;
 185
 186         ctrl->kcontrol = NULL;
 187 }
 188
 189 static bool sigma_fw_validate_control_name(const char *name, unsigned int len)
 190 {
 191         unsigned int i;
 192
 193         for (i = 0; i < len; i++) {
 194                 /* Normal ASCII characters are valid */
 195                 if (name[i] < ' ' || name[i] > '~')
 196                         return false;
 197         }
 198
 199         return true;
 200 }
 201
 202 static int sigma_fw_load_control(struct sigmadsp *sigmadsp,
 203         const struct sigma_fw_chunk *chunk, unsigned int length)
 204 {
 205         const struct sigma_fw_chunk_control *ctrl_chunk;
 206         struct sigmadsp_control *ctrl;
 207         unsigned int num_bytes;
 208         size_t name_len;
 209         char *name;
 210         int ret;
 211
 212         if (length <= sizeof(*ctrl_chunk))
 213                 return -EINVAL;
 214
 215         ctrl_chunk = (const struct sigma_fw_chunk_control *)chunk;
 216
 217         name_len = length - sizeof(*ctrl_chunk);
 218         if (name_len >= SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
 219                 name_len = SNDRV_CTL_ELEM_ID_NAME_MAXLEN - 1;
 220
 221         /* Make sure there are no non-displayable characaters in the string */
 222         if (!sigma_fw_validate_control_name(ctrl_chunk->name, name_len))
 223                 return -EINVAL;
 224
 225         num_bytes = le16_to_cpu(ctrl_chunk->num_bytes);
 226         ctrl = kzalloc(sizeof(*ctrl) + num_bytes, GFP_KERNEL);
 227         if (!ctrl)
 228                 return -ENOMEM;
 229
 230         name = kmemdup_nul(ctrl_chunk->name, name_len, GFP_KERNEL);
 231         if (!name) {
 232                 ret = -ENOMEM;
 233                 goto err_free_ctrl;
 234         }
 235         ctrl->name = name;
 236
 237         /*
 238          * Readbacks doesn't work with non-volatile controls, since the
 239          * firmware updates the control value without driver interaction. Mark
 240          * the readbacks to ensure that the values are not cached.
 241          */
 242         if (ctrl->name && strncmp(ctrl->name, READBACK_CTRL_NAME,
 243                                   (sizeof(READBACK_CTRL_NAME) - 1)) == 0)
 244                 ctrl->is_readback = true;
 245
 246         ctrl->addr = le16_to_cpu(ctrl_chunk->addr);
 247         ctrl->num_bytes = num_bytes;
 248         ctrl->samplerates = le32_to_cpu(chunk->samplerates);
 249
 250         list_add_tail(&ctrl->head, &sigmadsp->ctrl_list);
 251
 252         return 0;
 253
 254 err_free_ctrl:
 255         kfree(ctrl);
 256
 257         return ret;
 258 }
 259
 260 static int sigma_fw_load_data(struct sigmadsp *sigmadsp,
 261         const struct sigma_fw_chunk *chunk, unsigned int length)
 262 {
 263         const struct sigma_fw_chunk_data *data_chunk;
 264         struct sigmadsp_data *data;
 265
 266         if (length <= sizeof(*data_chunk))
 267                 return -EINVAL;
 268
 269         data_chunk = (struct sigma_fw_chunk_data *)chunk;
 270
 271         length -= sizeof(*data_chunk);
 272
 273         data = kzalloc(struct_size(data, data, length), GFP_KERNEL);
 274         if (!data)
 275                 return -ENOMEM;
 276
 277         data->addr = le16_to_cpu(data_chunk->addr);
 278         data->length = length;
 279         data->samplerates = le32_to_cpu(chunk->samplerates);
 280         memcpy(data->data, data_chunk->data, length);
 281         list_add_tail(&data->head, &sigmadsp->data_list);
 282
 283         return 0;
 284 }
 285
 286 static int sigma_fw_load_samplerates(struct sigmadsp *sigmadsp,
 287         const struct sigma_fw_chunk *chunk, unsigned int length)
 288 {
 289         const struct sigma_fw_chunk_samplerate *rate_chunk;
 290         unsigned int num_rates;
 291         unsigned int *rates;
 292         unsigned int i;
 293
 294         rate_chunk = (const struct sigma_fw_chunk_samplerate *)chunk;
 295
 296         num_rates = (length - sizeof(*rate_chunk)) / sizeof(__le32);
 297
 298         if (num_rates > 32 || num_rates == 0)
 299                 return -EINVAL;
 300
 301         /* We only allow one samplerates block per file */
 302         if (sigmadsp->rate_constraints.count)
 303                 return -EINVAL;
 304
 305         rates = kcalloc(num_rates, sizeof(*rates), GFP_KERNEL);
 306         if (!rates)
 307                 return -ENOMEM;
 308
 309         for (i = 0; i < num_rates; i++)
 310                 rates[i] = le32_to_cpu(rate_chunk->samplerates[i]);
 311
 312         sigmadsp->rate_constraints.count = num_rates;
 313         sigmadsp->rate_constraints.list = rates;
 314
 315         return 0;
 316 }
 317
 318 static int sigmadsp_fw_load_v2(struct sigmadsp *sigmadsp,
 319         const struct firmware *fw)
 320 {
 321         struct sigma_fw_chunk *chunk;
 322         unsigned int length, pos;
 323         int ret;
 324
 325         /*
 326          * Make sure that there is at least one chunk to avoid integer
 327          * underflows later on. Empty firmware is still valid though.
 328          */
 329         if (fw->size < sizeof(*chunk) + sizeof(struct sigma_firmware_header))
 330                 return 0;
 331
 332         pos = sizeof(struct sigma_firmware_header);
 333
 334         while (pos < fw->size - sizeof(*chunk)) {
 335                 chunk = (struct sigma_fw_chunk *)(fw->data + pos);
 336
 337                 length = le32_to_cpu(chunk->length);
 338
 339                 if (length > fw->size - pos || length < sizeof(*chunk))
 340                         return -EINVAL;
 341
 342                 switch (le32_to_cpu(chunk->tag)) {
 343                 case SIGMA_FW_CHUNK_TYPE_DATA:
 344                         ret = sigma_fw_load_data(sigmadsp, chunk, length);
 345                         break;
 346                 case SIGMA_FW_CHUNK_TYPE_CONTROL:
 347                         ret = sigma_fw_load_control(sigmadsp, chunk, length);
 348                         break;
 349                 case SIGMA_FW_CHUNK_TYPE_SAMPLERATES:
 350                         ret = sigma_fw_load_samplerates(sigmadsp, chunk, length);
 351                         break;
 352                 default:
 353                         dev_warn(sigmadsp->dev, "Unknown chunk type: %d\n",
 354                                 chunk->tag);
 355                         ret = 0;
 356                         break;
 357                 }
 358
 359                 if (ret)
 360                         return ret;
 361
 362                 /*
 363                  * This can not overflow since if length is larger than the
 364                  * maximum firmware size (0x4000000) we'll error out earilier.
 365                  */
 366                 pos += ALIGN(length, sizeof(__le32));
 367         }
 368
 369         return 0;
 370 }
 371
 372 static inline u32 sigma_action_len(struct sigma_action *sa)
 373 {
 374         return (sa->len_hi << 16) | le16_to_cpu(sa->len);
 375 }
 376
 377 static size_t sigma_action_size(struct sigma_action *sa)
 378 {
 379         size_t payload = 0;
 380
 381         switch (sa->instr) {
 382         case SIGMA_ACTION_WRITEXBYTES:
 383         case SIGMA_ACTION_WRITESINGLE:
 384         case SIGMA_ACTION_WRITESAFELOAD:
 385                 payload = sigma_action_len(sa);
 386                 break;
 387         default:
 388                 break;
 389         }
 390
 391         payload = ALIGN(payload, 2);
 392
 393         return payload + sizeof(struct sigma_action);
 394 }
 395
 396 /*
 397  * Returns a negative error value in case of an error, 0 if processing of
 398  * the firmware should be stopped after this action, 1 otherwise.
 399  */
 400 static int process_sigma_action(struct sigmadsp *sigmadsp,
 401         struct sigma_action *sa)
 402 {
 403         size_t len = sigma_action_len(sa);
 404         struct sigmadsp_data *data;
 405
 406         pr_debug("%s: instr:%i addr:%#x len:%zu\n", __func__,
 407                 sa->instr, sa->addr, len);
 408
 409         switch (sa->instr) {
 410         case SIGMA_ACTION_WRITEXBYTES:
 411         case SIGMA_ACTION_WRITESINGLE:
 412         case SIGMA_ACTION_WRITESAFELOAD:
 413                 if (len < 3)
 414                         return -EINVAL;
 415
 416                 data = kzalloc(struct_size(data, data, size_sub(len, 2)),
 417                                GFP_KERNEL);
 418                 if (!data)
 419                         return -ENOMEM;
 420
 421                 data->addr = be16_to_cpu(sa->addr);
 422                 data->length = len - 2;
 423                 memcpy(data->data, sa->payload, data->length);
 424                 list_add_tail(&data->head, &sigmadsp->data_list);
 425                 break;
 426         case SIGMA_ACTION_END:
 427                 return 0;
 428         default:
 429                 return -EINVAL;
 430         }
 431
 432         return 1;
 433 }
 434
 435 static int sigmadsp_fw_load_v1(struct sigmadsp *sigmadsp,
 436         const struct firmware *fw)
 437 {
 438         struct sigma_action *sa;
 439         size_t size, pos;
 440         int ret;
 441
 442         pos = sizeof(struct sigma_firmware_header);
 443
 444         while (pos + sizeof(*sa) <= fw->size) {
 445                 sa = (struct sigma_action *)(fw->data + pos);
 446
 447                 size = sigma_action_size(sa);
 448                 pos += size;
 449                 if (pos > fw->size || size == 0)
 450                         break;
 451
 452                 ret = process_sigma_action(sigmadsp, sa);
 453
 454                 pr_debug("%s: action returned %i\n", __func__, ret);
 455
 456                 if (ret <= 0)
 457                         return ret;
 458         }
 459
 460         if (pos != fw->size)
 461                 return -EINVAL;
 462
 463         return 0;
 464 }
 465
 466 static void sigmadsp_firmware_release(struct sigmadsp *sigmadsp)
 467 {
 468         struct sigmadsp_control *ctrl, *_ctrl;
 469         struct sigmadsp_data *data, *_data;
 470
 471         list_for_each_entry_safe(ctrl, _ctrl, &sigmadsp->ctrl_list, head) {
 472                 kfree(ctrl->name);
 473                 kfree(ctrl);
 474         }
 475
 476         list_for_each_entry_safe(data, _data, &sigmadsp->data_list, head)
 477                 kfree(data);
 478
 479         INIT_LIST_HEAD(&sigmadsp->ctrl_list);
 480         INIT_LIST_HEAD(&sigmadsp->data_list);
 481 }
 482
 483 static void devm_sigmadsp_release(struct device *dev, void *res)
 484 {
 485         sigmadsp_firmware_release((struct sigmadsp *)res);
 486 }
 487
 488 static int sigmadsp_firmware_load(struct sigmadsp *sigmadsp, const char *name)
 489 {
 490         const struct sigma_firmware_header *ssfw_head;
 491         const struct firmware *fw;
 492         int ret;
 493         u32 crc;
 494
 495         /* first load the blob */
 496         ret = maybe_reject_firmware(&fw, name, sigmadsp->dev);
 497         if (ret) {
 498                 pr_debug("%s: maybe_reject_firmware() failed with %i\n", __func__, ret);
 499                 goto done;
 500         }
 501
 502         /* then verify the header */
 503         ret = -EINVAL;
 504
 505         /*
 506          * Reject too small or unreasonable large files. The upper limit has been
 507          * chosen a bit arbitrarily, but it should be enough for all practical
 508          * purposes and having the limit makes it easier to avoid integer
 509          * overflows later in the loading process.
 510          */
 511         if (fw->size < sizeof(*ssfw_head) || fw->size >= 0x4000000) {
 512                 dev_err(sigmadsp->dev, "Failed to load firmware: Invalid size\n");
 513                 goto done;
 514         }
 515
 516         ssfw_head = (void *)fw->data;
 517         if (memcmp(ssfw_head->magic, SIGMA_MAGIC, ARRAY_SIZE(ssfw_head->magic))) {
 518                 dev_err(sigmadsp->dev, "Failed to load firmware: Invalid magic\n");
 519                 goto done;
 520         }
 521
 522         crc = crc32(0, fw->data + sizeof(*ssfw_head),
 523                         fw->size - sizeof(*ssfw_head));
 524         pr_debug("%s: crc=%x\n", __func__, crc);
 525         if (crc != le32_to_cpu(ssfw_head->crc)) {
 526                 dev_err(sigmadsp->dev, "Failed to load firmware: Wrong crc checksum: expected %x got %x\n",
 527                         le32_to_cpu(ssfw_head->crc), crc);
 528                 goto done;
 529         }
 530
 531         switch (ssfw_head->version) {
 532         case 1:
 533                 ret = sigmadsp_fw_load_v1(sigmadsp, fw);
 534                 break;
 535         case 2:
 536                 ret = sigmadsp_fw_load_v2(sigmadsp, fw);
 537                 break;
 538         default:
 539                 dev_err(sigmadsp->dev,
 540                         "Failed to load firmware: Invalid version %d. Supported firmware versions: 1, 2\n",
 541                         ssfw_head->version);
 542                 ret = -EINVAL;
 543                 break;
 544         }
 545
 546         if (ret)
 547                 sigmadsp_firmware_release(sigmadsp);
 548
 549 done:
 550         release_firmware(fw);
 551
 552         return ret;
 553 }
 554
 555 static int sigmadsp_init(struct sigmadsp *sigmadsp, struct device *dev,
 556         const struct sigmadsp_ops *ops, const char *firmware_name)
 557 {
 558         sigmadsp->ops = ops;
 559         sigmadsp->dev = dev;
 560
 561         INIT_LIST_HEAD(&sigmadsp->ctrl_list);
 562         INIT_LIST_HEAD(&sigmadsp->data_list);
 563         mutex_init(&sigmadsp->lock);
 564
 565         return sigmadsp_firmware_load(sigmadsp, firmware_name);
 566 }
 567
 568 /**
 569  * devm_sigmadsp_init() - Initialize SigmaDSP instance
 570  * @dev: The parent device
 571  * @ops: The sigmadsp_ops to use for this instance
 572  * @firmware_name: Name of the firmware file to load
 573  *
 574  * Allocates a SigmaDSP instance and loads the specified firmware file.
 575  *
 576  * Returns a pointer to a struct sigmadsp on success, or a PTR_ERR() on error.
 577  */
 578 struct sigmadsp *devm_sigmadsp_init(struct device *dev,
 579         const struct sigmadsp_ops *ops, const char *firmware_name)
 580 {
 581         struct sigmadsp *sigmadsp;
 582         int ret;
 583
 584         sigmadsp = devres_alloc(devm_sigmadsp_release, sizeof(*sigmadsp),
 585                 GFP_KERNEL);
 586         if (!sigmadsp)
 587                 return ERR_PTR(-ENOMEM);
 588
 589         ret = sigmadsp_init(sigmadsp, dev, ops, firmware_name);
 590         if (ret) {
 591                 devres_free(sigmadsp);
 592                 return ERR_PTR(ret);
 593         }
 594
 595         devres_add(dev, sigmadsp);
 596
 597         return sigmadsp;
 598 }
 599 EXPORT_SYMBOL_GPL(devm_sigmadsp_init);
 600
 601 static int sigmadsp_rate_to_index(struct sigmadsp *sigmadsp, unsigned int rate)
 602 {
 603         unsigned int i;
 604
 605         for (i = 0; i < sigmadsp->rate_constraints.count; i++) {
 606                 if (sigmadsp->rate_constraints.list[i] == rate)
 607                         return i;
 608         }
 609
 610         return -EINVAL;
 611 }
 612
 613 static unsigned int sigmadsp_get_samplerate_mask(struct sigmadsp *sigmadsp,
 614         unsigned int samplerate)
 615 {
 616         int samplerate_index;
 617
 618         if (samplerate == 0)
 619                 return 0;
 620
 621         if (sigmadsp->rate_constraints.count) {
 622                 samplerate_index = sigmadsp_rate_to_index(sigmadsp, samplerate);
 623                 if (samplerate_index < 0)
 624                         return 0;
 625
 626                 return BIT(samplerate_index);
 627         } else {
 628                 return ~0;
 629         }
 630 }
 631
 632 static bool sigmadsp_samplerate_valid(unsigned int supported,
 633         unsigned int requested)
 634 {
 635         /* All samplerates are supported */
 636         if (!supported)
 637                 return true;
 638
 639         return supported & requested;
 640 }
 641
 642 static int sigmadsp_alloc_control(struct sigmadsp *sigmadsp,
 643         struct sigmadsp_control *ctrl, unsigned int samplerate_mask)
 644 {
 645         struct snd_kcontrol_new template;
 646         struct snd_kcontrol *kcontrol;
 647
 648         memset(&template, 0, sizeof(template));
 649         template.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 650         template.name = ctrl->name;
 651         template.info = sigmadsp_ctrl_info;
 652         template.get = sigmadsp_ctrl_get;
 653         template.put = sigmadsp_ctrl_put;
 654         template.private_value = (unsigned long)ctrl;
 655         template.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
 656         if (!sigmadsp_samplerate_valid(ctrl->samplerates, samplerate_mask))
 657                 template.access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
 658
 659         kcontrol = snd_ctl_new1(&template, sigmadsp);
 660         if (!kcontrol)
 661                 return -ENOMEM;
 662
 663         kcontrol->private_free = sigmadsp_control_free;
 664         ctrl->kcontrol = kcontrol;
 665
 666         return snd_ctl_add(sigmadsp->component->card->snd_card, kcontrol);
 667 }
 668
 669 static void sigmadsp_activate_ctrl(struct sigmadsp *sigmadsp,
 670         struct sigmadsp_control *ctrl, unsigned int samplerate_mask)
 671 {
 672         struct snd_card *card = sigmadsp->component->card->snd_card;
 673         bool active;
 674         int changed;
 675
 676         active = sigmadsp_samplerate_valid(ctrl->samplerates, samplerate_mask);
 677         if (!ctrl->kcontrol)
 678                 return;
 679         changed = snd_ctl_activate_id(card, &ctrl->kcontrol->id, active);
 680         if (active && changed > 0) {
 681                 mutex_lock(&sigmadsp->lock);
 682                 if (ctrl->cached)
 683                         sigmadsp_ctrl_write(sigmadsp, ctrl, ctrl->cache);
 684                 mutex_unlock(&sigmadsp->lock);
 685         }
 686 }
 687
 688 /**
 689  * sigmadsp_attach() - Attach a sigmadsp instance to a ASoC component
 690  * @sigmadsp: The sigmadsp instance to attach
 691  * @component: The component to attach to
 692  *
 693  * Typically called in the components probe callback.
 694  *
 695  * Note, once this function has been called the firmware must not be released
 696  * until after the ALSA snd_card that the component belongs to has been
 697  * disconnected, even if sigmadsp_attach() returns an error.
 698  */
 699 int sigmadsp_attach(struct sigmadsp *sigmadsp,
 700         struct snd_soc_component *component)
 701 {
 702         struct sigmadsp_control *ctrl;
 703         unsigned int samplerate_mask;
 704         int ret;
 705
 706         sigmadsp->component = component;
 707
 708         samplerate_mask = sigmadsp_get_samplerate_mask(sigmadsp,
 709                 sigmadsp->current_samplerate);
 710
 711         list_for_each_entry(ctrl, &sigmadsp->ctrl_list, head) {
 712                 ret = sigmadsp_alloc_control(sigmadsp, ctrl, samplerate_mask);
 713                 if (ret)
 714                         return ret;
 715         }
 716
 717         return 0;
 718 }
 719 EXPORT_SYMBOL_GPL(sigmadsp_attach);
 720
 721 /**
 722  * sigmadsp_setup() - Setup the DSP for the specified samplerate
 723  * @sigmadsp: The sigmadsp instance to configure
 724  * @samplerate: The samplerate the DSP should be configured for
 725  *
 726  * Loads the appropriate firmware program and parameter memory (if not already
 727  * loaded) and enables the controls for the specified samplerate. Any control
 728  * parameter changes that have been made previously will be restored.
 729  *
 730  * Returns 0 on success, a negative error code otherwise.
 731  */
 732 int sigmadsp_setup(struct sigmadsp *sigmadsp, unsigned int samplerate)
 733 {
 734         struct sigmadsp_control *ctrl;
 735         unsigned int samplerate_mask;
 736         struct sigmadsp_data *data;
 737         int ret;
 738
 739         if (sigmadsp->current_samplerate == samplerate)
 740                 return 0;
 741
 742         samplerate_mask = sigmadsp_get_samplerate_mask(sigmadsp, samplerate);
 743         if (samplerate_mask == 0)
 744                 return -EINVAL;
 745
 746         list_for_each_entry(data, &sigmadsp->data_list, head) {
 747                 if (!sigmadsp_samplerate_valid(data->samplerates,
 748                     samplerate_mask))
 749                         continue;
 750                 ret = sigmadsp_write(sigmadsp, data->addr, data->data,
 751                         data->length);
 752                 if (ret)
 753                         goto err;
 754         }
 755
 756         list_for_each_entry(ctrl, &sigmadsp->ctrl_list, head)
 757                 sigmadsp_activate_ctrl(sigmadsp, ctrl, samplerate_mask);
 758
 759         sigmadsp->current_samplerate = samplerate;
 760
 761         return 0;
 762 err:
 763         sigmadsp_reset(sigmadsp);
 764
 765         return ret;
 766 }
 767 EXPORT_SYMBOL_GPL(sigmadsp_setup);
 768
 769 /**
 770  * sigmadsp_reset() - Notify the sigmadsp instance that the DSP has been reset
 771  * @sigmadsp: The sigmadsp instance to reset
 772  *
 773  * Should be called whenever the DSP has been reset and parameter and program
 774  * memory need to be re-loaded.
 775  */
 776 void sigmadsp_reset(struct sigmadsp *sigmadsp)
 777 {
 778         struct sigmadsp_control *ctrl;
 779
 780         list_for_each_entry(ctrl, &sigmadsp->ctrl_list, head)
 781                 sigmadsp_activate_ctrl(sigmadsp, ctrl, false);
 782
 783         sigmadsp->current_samplerate = 0;
 784 }
 785 EXPORT_SYMBOL_GPL(sigmadsp_reset);
 786
 787 /**
 788  * sigmadsp_restrict_params() - Applies DSP firmware specific constraints
 789  * @sigmadsp: The sigmadsp instance
 790  * @substream: The substream to restrict
 791  *
 792  * Applies samplerate constraints that may be required by the firmware Should
 793  * typically be called from the CODEC/component drivers startup callback.
 794  *
 795  * Returns 0 on success, a negative error code otherwise.
 796  */
 797 int sigmadsp_restrict_params(struct sigmadsp *sigmadsp,
 798         struct snd_pcm_substream *substream)
 799 {
 800         if (sigmadsp->rate_constraints.count == 0)
 801                 return 0;
 802
 803         return snd_pcm_hw_constraint_list(substream->runtime, 0,
 804                 SNDRV_PCM_HW_PARAM_RATE, &sigmadsp->rate_constraints);
 805 }
 806 EXPORT_SYMBOL_GPL(sigmadsp_restrict_params);
 807
 808 MODULE_LICENSE("GPL");