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[]; 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 = kzalloc(name_len + 1, GFP_KERNEL); 231 if (!name) { 232 ret = -ENOMEM; 233 goto err_free_ctrl; 234 } 235 memcpy(name, ctrl_chunk->name, name_len); 236 name[name_len] = '\0'; 237 ctrl->name = name; 238 239 /* 240 * Readbacks doesn't work with non-volatile controls, since the 241 * firmware updates the control value without driver interaction. Mark 242 * the readbacks to ensure that the values are not cached. 243 */ 244 if (ctrl->name && strncmp(ctrl->name, READBACK_CTRL_NAME, 245 (sizeof(READBACK_CTRL_NAME) - 1)) == 0) 246 ctrl->is_readback = true; 247 248 ctrl->addr = le16_to_cpu(ctrl_chunk->addr); 249 ctrl->num_bytes = num_bytes; 250 ctrl->samplerates = le32_to_cpu(chunk->samplerates); 251 252 list_add_tail(&ctrl->head, &sigmadsp->ctrl_list); 253 254 return 0; 255 256 err_free_ctrl: 257 kfree(ctrl); 258 259 return ret; 260 } 261 262 static int sigma_fw_load_data(struct sigmadsp *sigmadsp, 263 const struct sigma_fw_chunk *chunk, unsigned int length) 264 { 265 const struct sigma_fw_chunk_data *data_chunk; 266 struct sigmadsp_data *data; 267 268 if (length <= sizeof(*data_chunk)) 269 return -EINVAL; 270 271 data_chunk = (struct sigma_fw_chunk_data *)chunk; 272 273 length -= sizeof(*data_chunk); 274 275 data = kzalloc(sizeof(*data) + length, GFP_KERNEL); 276 if (!data) 277 return -ENOMEM; 278 279 data->addr = le16_to_cpu(data_chunk->addr); 280 data->length = length; 281 data->samplerates = le32_to_cpu(chunk->samplerates); 282 memcpy(data->data, data_chunk->data, length); 283 list_add_tail(&data->head, &sigmadsp->data_list); 284 285 return 0; 286 } 287 288 static int sigma_fw_load_samplerates(struct sigmadsp *sigmadsp, 289 const struct sigma_fw_chunk *chunk, unsigned int length) 290 { 291 const struct sigma_fw_chunk_samplerate *rate_chunk; 292 unsigned int num_rates; 293 unsigned int *rates; 294 unsigned int i; 295 296 rate_chunk = (const struct sigma_fw_chunk_samplerate *)chunk; 297 298 num_rates = (length - sizeof(*rate_chunk)) / sizeof(__le32); 299 300 if (num_rates > 32 || num_rates == 0) 301 return -EINVAL; 302 303 /* We only allow one samplerates block per file */ 304 if (sigmadsp->rate_constraints.count) 305 return -EINVAL; 306 307 rates = kcalloc(num_rates, sizeof(*rates), GFP_KERNEL); 308 if (!rates) 309 return -ENOMEM; 310 311 for (i = 0; i < num_rates; i++) 312 rates[i] = le32_to_cpu(rate_chunk->samplerates[i]); 313 314 sigmadsp->rate_constraints.count = num_rates; 315 sigmadsp->rate_constraints.list = rates; 316 317 return 0; 318 } 319 320 static int sigmadsp_fw_load_v2(struct sigmadsp *sigmadsp, 321 const struct firmware *fw) 322 { 323 struct sigma_fw_chunk *chunk; 324 unsigned int length, pos; 325 int ret; 326 327 /* 328 * Make sure that there is at least one chunk to avoid integer 329 * underflows later on. Empty firmware is still valid though. 330 */ 331 if (fw->size < sizeof(*chunk) + sizeof(struct sigma_firmware_header)) 332 return 0; 333 334 pos = sizeof(struct sigma_firmware_header); 335 336 while (pos < fw->size - sizeof(*chunk)) { 337 chunk = (struct sigma_fw_chunk *)(fw->data + pos); 338 339 length = le32_to_cpu(chunk->length); 340 341 if (length > fw->size - pos || length < sizeof(*chunk)) 342 return -EINVAL; 343 344 switch (le32_to_cpu(chunk->tag)) { 345 case SIGMA_FW_CHUNK_TYPE_DATA: 346 ret = sigma_fw_load_data(sigmadsp, chunk, length); 347 break; 348 case SIGMA_FW_CHUNK_TYPE_CONTROL: 349 ret = sigma_fw_load_control(sigmadsp, chunk, length); 350 break; 351 case SIGMA_FW_CHUNK_TYPE_SAMPLERATES: 352 ret = sigma_fw_load_samplerates(sigmadsp, chunk, length); 353 break; 354 default: 355 dev_warn(sigmadsp->dev, "Unknown chunk type: %d\n", 356 chunk->tag); 357 ret = 0; 358 break; 359 } 360 361 if (ret) 362 return ret; 363 364 /* 365 * This can not overflow since if length is larger than the 366 * maximum firmware size (0x4000000) we'll error out earilier. 367 */ 368 pos += ALIGN(length, sizeof(__le32)); 369 } 370 371 return 0; 372 } 373 374 static inline u32 sigma_action_len(struct sigma_action *sa) 375 { 376 return (sa->len_hi << 16) | le16_to_cpu(sa->len); 377 } 378 379 static size_t sigma_action_size(struct sigma_action *sa) 380 { 381 size_t payload = 0; 382 383 switch (sa->instr) { 384 case SIGMA_ACTION_WRITEXBYTES: 385 case SIGMA_ACTION_WRITESINGLE: 386 case SIGMA_ACTION_WRITESAFELOAD: 387 payload = sigma_action_len(sa); 388 break; 389 default: 390 break; 391 } 392 393 payload = ALIGN(payload, 2); 394 395 return payload + sizeof(struct sigma_action); 396 } 397 398 /* 399 * Returns a negative error value in case of an error, 0 if processing of 400 * the firmware should be stopped after this action, 1 otherwise. 401 */ 402 static int process_sigma_action(struct sigmadsp *sigmadsp, 403 struct sigma_action *sa) 404 { 405 size_t len = sigma_action_len(sa); 406 struct sigmadsp_data *data; 407 408 pr_debug("%s: instr:%i addr:%#x len:%zu\n", __func__, 409 sa->instr, sa->addr, len); 410 411 switch (sa->instr) { 412 case SIGMA_ACTION_WRITEXBYTES: 413 case SIGMA_ACTION_WRITESINGLE: 414 case SIGMA_ACTION_WRITESAFELOAD: 415 if (len < 3) 416 return -EINVAL; 417 418 data = kzalloc(sizeof(*data) + len - 2, GFP_KERNEL); 419 if (!data) 420 return -ENOMEM; 421 422 data->addr = be16_to_cpu(sa->addr); 423 data->length = len - 2; 424 memcpy(data->data, sa->payload, data->length); 425 list_add_tail(&data->head, &sigmadsp->data_list); 426 break; 427 case SIGMA_ACTION_END: 428 return 0; 429 default: 430 return -EINVAL; 431 } 432 433 return 1; 434 } 435 436 static int sigmadsp_fw_load_v1(struct sigmadsp *sigmadsp, 437 const struct firmware *fw) 438 { 439 struct sigma_action *sa; 440 size_t size, pos; 441 int ret; 442 443 pos = sizeof(struct sigma_firmware_header); 444 445 while (pos + sizeof(*sa) <= fw->size) { 446 sa = (struct sigma_action *)(fw->data + pos); 447 448 size = sigma_action_size(sa); 449 pos += size; 450 if (pos > fw->size || size == 0) 451 break; 452 453 ret = process_sigma_action(sigmadsp, sa); 454 455 pr_debug("%s: action returned %i\n", __func__, ret); 456 457 if (ret <= 0) 458 return ret; 459 } 460 461 if (pos != fw->size) 462 return -EINVAL; 463 464 return 0; 465 } 466 467 static void sigmadsp_firmware_release(struct sigmadsp *sigmadsp) 468 { 469 struct sigmadsp_control *ctrl, *_ctrl; 470 struct sigmadsp_data *data, *_data; 471 472 list_for_each_entry_safe(ctrl, _ctrl, &sigmadsp->ctrl_list, head) { 473 kfree(ctrl->name); 474 kfree(ctrl); 475 } 476 477 list_for_each_entry_safe(data, _data, &sigmadsp->data_list, head) 478 kfree(data); 479 480 INIT_LIST_HEAD(&sigmadsp->ctrl_list); 481 INIT_LIST_HEAD(&sigmadsp->data_list); 482 } 483 484 static void devm_sigmadsp_release(struct device *dev, void *res) 485 { 486 sigmadsp_firmware_release((struct sigmadsp *)res); 487 } 488 489 static int sigmadsp_firmware_load(struct sigmadsp *sigmadsp, const char *name) 490 { 491 const struct sigma_firmware_header *ssfw_head; 492 const struct firmware *fw; 493 int ret; 494 u32 crc; 495 496 /* first load the blob */ 497 ret = request_firmware(&fw, name, sigmadsp->dev); 498 if (ret) { 499 pr_debug("%s: request_firmware() failed with %i\n", __func__, ret); 500 goto done; 501 } 502 503 /* then verify the header */ 504 ret = -EINVAL; 505 506 /* 507 * Reject too small or unreasonable large files. The upper limit has been 508 * chosen a bit arbitrarily, but it should be enough for all practical 509 * purposes and having the limit makes it easier to avoid integer 510 * overflows later in the loading process. 511 */ 512 if (fw->size < sizeof(*ssfw_head) || fw->size >= 0x4000000) { 513 dev_err(sigmadsp->dev, "Failed to load firmware: Invalid size\n"); 514 goto done; 515 } 516 517 ssfw_head = (void *)fw->data; 518 if (memcmp(ssfw_head->magic, SIGMA_MAGIC, ARRAY_SIZE(ssfw_head->magic))) { 519 dev_err(sigmadsp->dev, "Failed to load firmware: Invalid magic\n"); 520 goto done; 521 } 522 523 crc = crc32(0, fw->data + sizeof(*ssfw_head), 524 fw->size - sizeof(*ssfw_head)); 525 pr_debug("%s: crc=%x\n", __func__, crc); 526 if (crc != le32_to_cpu(ssfw_head->crc)) { 527 dev_err(sigmadsp->dev, "Failed to load firmware: Wrong crc checksum: expected %x got %x\n", 528 le32_to_cpu(ssfw_head->crc), crc); 529 goto done; 530 } 531 532 switch (ssfw_head->version) { 533 case 1: 534 ret = sigmadsp_fw_load_v1(sigmadsp, fw); 535 break; 536 case 2: 537 ret = sigmadsp_fw_load_v2(sigmadsp, fw); 538 break; 539 default: 540 dev_err(sigmadsp->dev, 541 "Failed to load firmware: Invalid version %d. Supported firmware versions: 1, 2\n", 542 ssfw_head->version); 543 ret = -EINVAL; 544 break; 545 } 546 547 if (ret) 548 sigmadsp_firmware_release(sigmadsp); 549 550 done: 551 release_firmware(fw); 552 553 return ret; 554 } 555 556 static int sigmadsp_init(struct sigmadsp *sigmadsp, struct device *dev, 557 const struct sigmadsp_ops *ops, const char *firmware_name) 558 { 559 sigmadsp->ops = ops; 560 sigmadsp->dev = dev; 561 562 INIT_LIST_HEAD(&sigmadsp->ctrl_list); 563 INIT_LIST_HEAD(&sigmadsp->data_list); 564 mutex_init(&sigmadsp->lock); 565 566 return sigmadsp_firmware_load(sigmadsp, firmware_name); 567 } 568 569 /** 570 * devm_sigmadsp_init() - Initialize SigmaDSP instance 571 * @dev: The parent device 572 * @ops: The sigmadsp_ops to use for this instance 573 * @firmware_name: Name of the firmware file to load 574 * 575 * Allocates a SigmaDSP instance and loads the specified firmware file. 576 * 577 * Returns a pointer to a struct sigmadsp on success, or a PTR_ERR() on error. 578 */ 579 struct sigmadsp *devm_sigmadsp_init(struct device *dev, 580 const struct sigmadsp_ops *ops, const char *firmware_name) 581 { 582 struct sigmadsp *sigmadsp; 583 int ret; 584 585 sigmadsp = devres_alloc(devm_sigmadsp_release, sizeof(*sigmadsp), 586 GFP_KERNEL); 587 if (!sigmadsp) 588 return ERR_PTR(-ENOMEM); 589 590 ret = sigmadsp_init(sigmadsp, dev, ops, firmware_name); 591 if (ret) { 592 devres_free(sigmadsp); 593 return ERR_PTR(ret); 594 } 595 596 devres_add(dev, sigmadsp); 597 598 return sigmadsp; 599 } 600 EXPORT_SYMBOL_GPL(devm_sigmadsp_init); 601 602 static int sigmadsp_rate_to_index(struct sigmadsp *sigmadsp, unsigned int rate) 603 { 604 unsigned int i; 605 606 for (i = 0; i < sigmadsp->rate_constraints.count; i++) { 607 if (sigmadsp->rate_constraints.list[i] == rate) 608 return i; 609 } 610 611 return -EINVAL; 612 } 613 614 static unsigned int sigmadsp_get_samplerate_mask(struct sigmadsp *sigmadsp, 615 unsigned int samplerate) 616 { 617 int samplerate_index; 618 619 if (samplerate == 0) 620 return 0; 621 622 if (sigmadsp->rate_constraints.count) { 623 samplerate_index = sigmadsp_rate_to_index(sigmadsp, samplerate); 624 if (samplerate_index < 0) 625 return 0; 626 627 return BIT(samplerate_index); 628 } else { 629 return ~0; 630 } 631 } 632 633 static bool sigmadsp_samplerate_valid(unsigned int supported, 634 unsigned int requested) 635 { 636 /* All samplerates are supported */ 637 if (!supported) 638 return true; 639 640 return supported & requested; 641 } 642 643 static int sigmadsp_alloc_control(struct sigmadsp *sigmadsp, 644 struct sigmadsp_control *ctrl, unsigned int samplerate_mask) 645 { 646 struct snd_kcontrol_new template; 647 struct snd_kcontrol *kcontrol; 648 649 memset(&template, 0, sizeof(template)); 650 template.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 651 template.name = ctrl->name; 652 template.info = sigmadsp_ctrl_info; 653 template.get = sigmadsp_ctrl_get; 654 template.put = sigmadsp_ctrl_put; 655 template.private_value = (unsigned long)ctrl; 656 template.access = SNDRV_CTL_ELEM_ACCESS_READWRITE; 657 if (!sigmadsp_samplerate_valid(ctrl->samplerates, samplerate_mask)) 658 template.access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE; 659 660 kcontrol = snd_ctl_new1(&template, sigmadsp); 661 if (!kcontrol) 662 return -ENOMEM; 663 664 kcontrol->private_free = sigmadsp_control_free; 665 ctrl->kcontrol = kcontrol; 666 667 return snd_ctl_add(sigmadsp->component->card->snd_card, kcontrol); 668 } 669 670 static void sigmadsp_activate_ctrl(struct sigmadsp *sigmadsp, 671 struct sigmadsp_control *ctrl, unsigned int samplerate_mask) 672 { 673 struct snd_card *card = sigmadsp->component->card->snd_card; 674 struct snd_kcontrol_volatile *vd; 675 struct snd_ctl_elem_id id; 676 bool active; 677 bool changed = false; 678 679 active = sigmadsp_samplerate_valid(ctrl->samplerates, samplerate_mask); 680 681 down_write(&card->controls_rwsem); 682 if (!ctrl->kcontrol) { 683 up_write(&card->controls_rwsem); 684 return; 685 } 686 687 id = ctrl->kcontrol->id; 688 vd = &ctrl->kcontrol->vd[0]; 689 if (active == (bool)(vd->access & SNDRV_CTL_ELEM_ACCESS_INACTIVE)) { 690 vd->access ^= SNDRV_CTL_ELEM_ACCESS_INACTIVE; 691 changed = true; 692 } 693 up_write(&card->controls_rwsem); 694 695 if (active && changed) { 696 mutex_lock(&sigmadsp->lock); 697 if (ctrl->cached) 698 sigmadsp_ctrl_write(sigmadsp, ctrl, ctrl->cache); 699 mutex_unlock(&sigmadsp->lock); 700 } 701 702 if (changed) 703 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, &id); 704 } 705 706 /** 707 * sigmadsp_attach() - Attach a sigmadsp instance to a ASoC component 708 * @sigmadsp: The sigmadsp instance to attach 709 * @component: The component to attach to 710 * 711 * Typically called in the components probe callback. 712 * 713 * Note, once this function has been called the firmware must not be released 714 * until after the ALSA snd_card that the component belongs to has been 715 * disconnected, even if sigmadsp_attach() returns an error. 716 */ 717 int sigmadsp_attach(struct sigmadsp *sigmadsp, 718 struct snd_soc_component *component) 719 { 720 struct sigmadsp_control *ctrl; 721 unsigned int samplerate_mask; 722 int ret; 723 724 sigmadsp->component = component; 725 726 samplerate_mask = sigmadsp_get_samplerate_mask(sigmadsp, 727 sigmadsp->current_samplerate); 728 729 list_for_each_entry(ctrl, &sigmadsp->ctrl_list, head) { 730 ret = sigmadsp_alloc_control(sigmadsp, ctrl, samplerate_mask); 731 if (ret) 732 return ret; 733 } 734 735 return 0; 736 } 737 EXPORT_SYMBOL_GPL(sigmadsp_attach); 738 739 /** 740 * sigmadsp_setup() - Setup the DSP for the specified samplerate 741 * @sigmadsp: The sigmadsp instance to configure 742 * @samplerate: The samplerate the DSP should be configured for 743 * 744 * Loads the appropriate firmware program and parameter memory (if not already 745 * loaded) and enables the controls for the specified samplerate. Any control 746 * parameter changes that have been made previously will be restored. 747 * 748 * Returns 0 on success, a negative error code otherwise. 749 */ 750 int sigmadsp_setup(struct sigmadsp *sigmadsp, unsigned int samplerate) 751 { 752 struct sigmadsp_control *ctrl; 753 unsigned int samplerate_mask; 754 struct sigmadsp_data *data; 755 int ret; 756 757 if (sigmadsp->current_samplerate == samplerate) 758 return 0; 759 760 samplerate_mask = sigmadsp_get_samplerate_mask(sigmadsp, samplerate); 761 if (samplerate_mask == 0) 762 return -EINVAL; 763 764 list_for_each_entry(data, &sigmadsp->data_list, head) { 765 if (!sigmadsp_samplerate_valid(data->samplerates, 766 samplerate_mask)) 767 continue; 768 ret = sigmadsp_write(sigmadsp, data->addr, data->data, 769 data->length); 770 if (ret) 771 goto err; 772 } 773 774 list_for_each_entry(ctrl, &sigmadsp->ctrl_list, head) 775 sigmadsp_activate_ctrl(sigmadsp, ctrl, samplerate_mask); 776 777 sigmadsp->current_samplerate = samplerate; 778 779 return 0; 780 err: 781 sigmadsp_reset(sigmadsp); 782 783 return ret; 784 } 785 EXPORT_SYMBOL_GPL(sigmadsp_setup); 786 787 /** 788 * sigmadsp_reset() - Notify the sigmadsp instance that the DSP has been reset 789 * @sigmadsp: The sigmadsp instance to reset 790 * 791 * Should be called whenever the DSP has been reset and parameter and program 792 * memory need to be re-loaded. 793 */ 794 void sigmadsp_reset(struct sigmadsp *sigmadsp) 795 { 796 struct sigmadsp_control *ctrl; 797 798 list_for_each_entry(ctrl, &sigmadsp->ctrl_list, head) 799 sigmadsp_activate_ctrl(sigmadsp, ctrl, false); 800 801 sigmadsp->current_samplerate = 0; 802 } 803 EXPORT_SYMBOL_GPL(sigmadsp_reset); 804 805 /** 806 * sigmadsp_restrict_params() - Applies DSP firmware specific constraints 807 * @sigmadsp: The sigmadsp instance 808 * @substream: The substream to restrict 809 * 810 * Applies samplerate constraints that may be required by the firmware Should 811 * typically be called from the CODEC/component drivers startup callback. 812 * 813 * Returns 0 on success, a negative error code otherwise. 814 */ 815 int sigmadsp_restrict_params(struct sigmadsp *sigmadsp, 816 struct snd_pcm_substream *substream) 817 { 818 if (sigmadsp->rate_constraints.count == 0) 819 return 0; 820 821 return snd_pcm_hw_constraint_list(substream->runtime, 0, 822 SNDRV_PCM_HW_PARAM_RATE, &sigmadsp->rate_constraints); 823 } 824 EXPORT_SYMBOL_GPL(sigmadsp_restrict_params); 825 826 MODULE_LICENSE("GPL"); 827