~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/codecs/sigmadsp.c

Version: ~ [ linux-5.1-rc5 ] ~ [ linux-5.0.7 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.34 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.111 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.168 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.178 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.138 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.65 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp