810 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Load Analog Devices SigmaStudio firmware files4 *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 024#define SIGMA_FW_CHUNK_TYPE_CONTROL 125#define SIGMA_FW_CHUNK_TYPE_SAMPLERATES 226 27#define READBACK_CTRL_NAME "ReadBack"28 29struct 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 41struct 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 49struct sigma_fw_chunk {50 __le32 length;51 __le32 tag;52 __le32 samplerates;53} __packed;54 55struct sigma_fw_chunk_data {56 struct sigma_fw_chunk chunk;57 __le16 addr;58 uint8_t data[];59} __packed;60 61struct 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 69struct sigma_fw_chunk_samplerate {70 struct sigma_fw_chunk chunk;71 __le32 samplerates[];72} __packed;73 74struct sigma_firmware_header {75 unsigned char magic[7];76 u8 version;77 __le32 crc;78} __packed;79 80enum {81 SIGMA_ACTION_WRITEXBYTES = 0,82 SIGMA_ACTION_WRITESINGLE,83 SIGMA_ACTION_WRITESAFELOAD,84 SIGMA_ACTION_END,85};86 87struct sigma_action {88 u8 instr;89 u8 len_hi;90 __le16 len;91 __be16 addr;92 unsigned char payload[];93} __packed;94 95static 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 101static 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 107static 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 118static 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 else126 return sigmadsp_write(sigmadsp, ctrl->addr, data,127 ctrl->num_bytes);128}129 130static 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 156static 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 182static 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 189static 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 202static 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 the239 * firmware updates the control value without driver interaction. Mark240 * 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 254err_free_ctrl:255 kfree(ctrl);256 257 return ret;258}259 260static 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 286static 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 318static 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 integer327 * 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 the364 * maximum firmware size (0x4000000) we'll error out earilier.365 */366 pos += ALIGN(length, sizeof(__le32));367 }368 369 return 0;370}371 372static inline u32 sigma_action_len(struct sigma_action *sa)373{374 return (sa->len_hi << 16) | le16_to_cpu(sa->len);375}376 377static 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 of398 * the firmware should be stopped after this action, 1 otherwise.399 */400static 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 435static 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 466static 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 483static void devm_sigmadsp_release(struct device *dev, void *res)484{485 sigmadsp_firmware_release((struct sigmadsp *)res);486}487 488static 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 = request_firmware(&fw, name, sigmadsp->dev);497 if (ret) {498 pr_debug("%s: request_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 been507 * chosen a bit arbitrarily, but it should be enough for all practical508 * purposes and having the limit makes it easier to avoid integer509 * 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 549done:550 release_firmware(fw);551 552 return ret;553}554 555static 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 instance570 * @dev: The parent device571 * @ops: The sigmadsp_ops to use for this instance572 * @firmware_name: Name of the firmware file to load573 *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 */578struct 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}599EXPORT_SYMBOL_GPL(devm_sigmadsp_init);600 601static 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 613static 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 632static 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 642static 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 669static 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 component690 * @sigmadsp: The sigmadsp instance to attach691 * @component: The component to attach to692 *693 * Typically called in the components probe callback.694 *695 * Note, once this function has been called the firmware must not be released696 * until after the ALSA snd_card that the component belongs to has been697 * disconnected, even if sigmadsp_attach() returns an error.698 */699int 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}719EXPORT_SYMBOL_GPL(sigmadsp_attach);720 721/**722 * sigmadsp_setup() - Setup the DSP for the specified samplerate723 * @sigmadsp: The sigmadsp instance to configure724 * @samplerate: The samplerate the DSP should be configured for725 *726 * Loads the appropriate firmware program and parameter memory (if not already727 * loaded) and enables the controls for the specified samplerate. Any control728 * parameter changes that have been made previously will be restored.729 *730 * Returns 0 on success, a negative error code otherwise.731 */732int 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;762err:763 sigmadsp_reset(sigmadsp);764 765 return ret;766}767EXPORT_SYMBOL_GPL(sigmadsp_setup);768 769/**770 * sigmadsp_reset() - Notify the sigmadsp instance that the DSP has been reset771 * @sigmadsp: The sigmadsp instance to reset772 *773 * Should be called whenever the DSP has been reset and parameter and program774 * memory need to be re-loaded.775 */776void 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}785EXPORT_SYMBOL_GPL(sigmadsp_reset);786 787/**788 * sigmadsp_restrict_params() - Applies DSP firmware specific constraints789 * @sigmadsp: The sigmadsp instance790 * @substream: The substream to restrict791 *792 * Applies samplerate constraints that may be required by the firmware Should793 * typically be called from the CODEC/component drivers startup callback.794 *795 * Returns 0 on success, a negative error code otherwise.796 */797int 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}806EXPORT_SYMBOL_GPL(sigmadsp_restrict_params);807 808MODULE_DESCRIPTION("Analog Devices SigmaStudio firmware helpers");809MODULE_LICENSE("GPL");810