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 = 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 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_DESCRIPTION("Analog Devices SigmaStudio firmware helpers");
809 MODULE_LICENSE("GPL");
810
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.