mixer: Fix missing hctl handle free in snd_mixer_attach_hctl()
[alsa-lib.git] / src / ucm / parser.c
1 /*
2  *  This library is free software; you can redistribute it and/or
3  *  modify it under the terms of the GNU Lesser General Public
4  *  License as published by the Free Software Foundation; either
5  *  version 2 of the License, or (at your option) any later version.
6  *
7  *  This library is distributed in the hope that it will be useful,
8  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
9  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10  *  Lesser General Public License for more details.
11  *
12  *  You should have received a copy of the GNU Lesser General Public
13  *  License along with this library; if not, write to the Free Software  
14  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
15  *
16  *  Support for the verb/device/modifier core logic and API,
17  *  command line tool and file parser was kindly sponsored by
18  *  Texas Instruments Inc.
19  *  Support for multiple active modifiers and devices,
20  *  transition sequences, multiple client access and user defined use
21  *  cases was kindly sponsored by Wolfson Microelectronics PLC.
22  *
23  *  Copyright (C) 2008-2010 SlimLogic Ltd
24  *  Copyright (C) 2010 Wolfson Microelectronics PLC
25  *  Copyright (C) 2010 Texas Instruments Inc.
26  *  Copyright (C) 2010 Red Hat Inc.
27  *  Authors: Liam Girdwood <lrg@slimlogic.co.uk>
28  *               Stefan Schmidt <stefan@slimlogic.co.uk>
29  *               Justin Xu <justinx@slimlogic.co.uk>
30  *               Jaroslav Kysela <perex@perex.cz>
31  */
32
33 #include "ucm_local.h"
34 #include <dirent.h>
35
36 /** The name of the environment variable containing the UCM directory */
37 #define ALSA_CONFIG_UCM_VAR "ALSA_CONFIG_UCM"
38
39 static int parse_sequence(snd_use_case_mgr_t *uc_mgr,
40                           struct list_head *base,
41                           snd_config_t *cfg);
42
43 /*
44  * Parse string
45  */
46 int parse_string(snd_config_t *n, char **res)
47 {
48         int err;
49
50         err = snd_config_get_string(n, (const char **)res);
51         if (err < 0)
52                 return err;
53         *res = strdup(*res);
54         if (*res == NULL)
55                 return -ENOMEM;
56         return 0;
57 }
58
59 /*
60  * Parse safe ID
61  */
62 int parse_is_name_safe(const char *name)
63 {
64         if (strchr(name, '.')) {
65                 uc_error("char '.' not allowed in '%s'", name);
66                 return 0;
67         }
68         return 1;
69 }
70
71 int parse_get_safe_id(snd_config_t *n, const char **id)
72 {
73         int err;
74
75         err = snd_config_get_id(n, id);
76         if (err < 0)
77                 return err;
78         if (!parse_is_name_safe((char *)(*id)))
79                 return -EINVAL;
80         return 0;
81 }
82
83 /*
84  * Parse transition
85  */
86 static int parse_transition(snd_use_case_mgr_t *uc_mgr,
87                             struct list_head *tlist,
88                             snd_config_t *cfg)
89 {
90         struct transition_sequence *tseq;
91         const char *id;
92         snd_config_iterator_t i, next;
93         snd_config_t *n;
94         int err;
95
96         if (snd_config_get_id(cfg, &id) < 0)
97                 return -EINVAL;
98
99         if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
100                 uc_error("compound type expected for %s", id);
101                 return -EINVAL;
102         }
103
104         snd_config_for_each(i, next, cfg) {
105                 n = snd_config_iterator_entry(i);
106
107                 if (snd_config_get_id(n, &id) < 0)
108                         return -EINVAL;
109
110                 tseq = calloc(1, sizeof(*tseq));
111                 if (tseq == NULL)
112                         return -ENOMEM;
113                 INIT_LIST_HEAD(&tseq->transition_list);
114
115                 tseq->name = strdup(id);
116                 if (tseq->name == NULL) {
117                         free(tseq);
118                         return -ENOMEM;
119                 }
120         
121                 err = parse_sequence(uc_mgr, &tseq->transition_list, n);
122                 if (err < 0) {
123                         uc_mgr_free_transition_element(tseq);
124                         return err;
125                 }
126
127                 list_add(&tseq->list, tlist);
128         }
129         return 0;
130 }
131
132 /*
133  * Parse compound
134  */
135 static int parse_compound(snd_use_case_mgr_t *uc_mgr, snd_config_t *cfg,
136           int (*fcn)(snd_use_case_mgr_t *, snd_config_t *, void *, void *),
137           void *data1, void *data2)
138 {
139         const char *id;
140         snd_config_iterator_t i, next;
141         snd_config_t *n;
142         int err;
143
144         if (snd_config_get_id(cfg, &id) < 0)
145                 return -EINVAL;
146         
147         if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
148                 uc_error("compound type expected for %s", id);
149                 return -EINVAL;
150         }
151         /* parse compound */
152         snd_config_for_each(i, next, cfg) {
153                 n = snd_config_iterator_entry(i);
154
155                 if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
156                         uc_error("compound type expected for %s, is %d", id, snd_config_get_type(cfg));
157                         return -EINVAL;
158                 }
159                 
160                 err = fcn(uc_mgr, n, data1, data2);
161                 if (err < 0)
162                         return err;
163         }
164
165         return 0;
166 }
167
168 static int strip_legacy_dev_index(char *name)
169 {
170         char *dot = strchr(name, '.');
171         if (!dot)
172                 return 0;
173         if (dot[1] != '0' || dot[2] != '\0') {
174                 uc_error("device name %s contains a '.',"
175                          " and is not legacy foo.0 format", name);
176                 return -EINVAL;
177         }
178         *dot = '\0';
179         return 0;
180 }
181
182 /*
183  * Parse device list
184  */
185 static int parse_device_list(snd_use_case_mgr_t *uc_mgr ATTRIBUTE_UNUSED,
186                              struct dev_list *dev_list,
187                              enum dev_list_type type,
188                              snd_config_t *cfg)
189 {
190         struct dev_list_node *sdev;
191         const char *id;
192         snd_config_iterator_t i, next;
193         snd_config_t *n;
194         int err;
195
196         if (dev_list->type != DEVLIST_NONE) {
197                 uc_error("error: multiple supported or"
198                         " conflicting device lists");
199                 return -EEXIST;
200         }
201
202         if (snd_config_get_id(cfg, &id) < 0)
203                 return -EINVAL;
204
205         if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
206                 uc_error("compound type expected for %s", id);
207                 return -EINVAL;
208         }
209
210         snd_config_for_each(i, next, cfg) {
211                 n = snd_config_iterator_entry(i);
212
213                 if (snd_config_get_id(n, &id) < 0)
214                         return -EINVAL;
215
216                 sdev = calloc(1, sizeof(struct dev_list_node));
217                 if (sdev == NULL)
218                         return -ENOMEM;
219                 err = parse_string(n, &sdev->name);
220                 if (err < 0) {
221                         free(sdev);
222                         return err;
223                 }
224                 err = strip_legacy_dev_index(sdev->name);
225                 if (err < 0) {
226                         free(sdev->name);
227                         free(sdev);
228                         return err;
229                 }
230                 list_add(&sdev->list, &dev_list->list);
231         }
232
233         dev_list->type = type;
234
235         return 0;
236 }
237
238 /*
239  * Parse sequences.
240  *
241  * Sequence controls elements  are in the following form:-
242  *
243  * cdev "hw:0"
244  * cset "element_id_syntax value_syntax"
245  * usleep time
246  * exec "any unix command with arguments"
247  *
248  * e.g.
249  *      cset "name='Master Playback Switch' 0,0"
250  *      cset "iface=PCM,name='Disable HDMI',index=1 0"
251  */
252 static int parse_sequence(snd_use_case_mgr_t *uc_mgr ATTRIBUTE_UNUSED,
253                           struct list_head *base,
254                           snd_config_t *cfg)
255 {
256         struct sequence_element *curr;
257         snd_config_iterator_t i, next;
258         snd_config_t *n;
259         int err, idx = 0;
260         const char *cmd = NULL;
261
262         if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
263                 uc_error("error: compound is expected for sequence definition");
264                 return -EINVAL;
265         }
266
267         snd_config_for_each(i, next, cfg) {
268                 const char *id;
269                 idx ^= 1;
270                 n = snd_config_iterator_entry(i);
271                 err = snd_config_get_id(n, &id);
272                 if (err < 0)
273                         continue;
274                 if (idx == 1) {
275                         if (snd_config_get_type(n) != SND_CONFIG_TYPE_STRING) {
276                                 uc_error("error: string type is expected for sequence command");
277                                 return -EINVAL;
278                         }
279                         snd_config_get_string(n, &cmd);
280                         continue;
281                 }
282
283                 /* alloc new sequence element */
284                 curr = calloc(1, sizeof(struct sequence_element));
285                 if (curr == NULL)
286                         return -ENOMEM;
287                 list_add_tail(&curr->list, base);
288
289                 if (strcmp(cmd, "cdev") == 0) {
290                         curr->type = SEQUENCE_ELEMENT_TYPE_CDEV;
291                         err = parse_string(n, &curr->data.cdev);
292                         if (err < 0) {
293                                 uc_error("error: cdev requires a string!");
294                                 return err;
295                         }
296                         continue;
297                 }
298
299                 if (strcmp(cmd, "cset") == 0) {
300                         curr->type = SEQUENCE_ELEMENT_TYPE_CSET;
301                         err = parse_string(n, &curr->data.cset);
302                         if (err < 0) {
303                                 uc_error("error: cset requires a string!");
304                                 return err;
305                         }
306                         continue;
307                 }
308
309                 if (strcmp(cmd, "usleep") == 0) {
310                         curr->type = SEQUENCE_ELEMENT_TYPE_SLEEP;
311                         err = snd_config_get_integer(n, &curr->data.sleep);
312                         if (err < 0) {
313                                 uc_error("error: usleep requires integer!");
314                                 return err;
315                         }
316                         continue;
317                 }
318
319                 if (strcmp(cmd, "msleep") == 0) {
320                         curr->type = SEQUENCE_ELEMENT_TYPE_SLEEP;
321                         err = snd_config_get_integer(n, &curr->data.sleep);
322                         if (err < 0) {
323                                 uc_error("error: msleep requires integer!");
324                                 return err;
325                         }
326                         curr->data.sleep *= 1000L;
327                         continue;
328                 }
329
330                 if (strcmp(cmd, "exec") == 0) {
331                         curr->type = SEQUENCE_ELEMENT_TYPE_EXEC;
332                         err = parse_string(n, &curr->data.exec);
333                         if (err < 0) {
334                                 uc_error("error: exec requires a string!");
335                                 return err;
336                         }
337                         continue;
338                 }
339                 
340                 list_del(&curr->list);
341                 uc_mgr_free_sequence_element(curr);
342         }
343
344         return 0;
345 }
346
347 /*
348  * Parse values.
349  *
350  * Parse values describing PCM, control/mixer settings and stream parameters.
351  *
352  * Value {
353  *   TQ Voice
354  *   CapturePCM "hw:1"
355  *   PlaybackVolume "name='Master Playback Volume',index=2"
356  *   PlaybackSwitch "name='Master Playback Switch',index=2"
357  * }
358  */
359 static int parse_value(snd_use_case_mgr_t *uc_mgr ATTRIBUTE_UNUSED,
360                           struct list_head *base,
361                           snd_config_t *cfg)
362 {
363         struct ucm_value *curr;
364         snd_config_iterator_t i, next;
365         snd_config_t *n;
366         long l;
367         long long ll;
368         double d;
369         snd_config_type_t type;
370         int err;
371
372         if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
373                 uc_error("error: compound is expected for value definition");
374                 return -EINVAL;
375         }
376         snd_config_for_each(i, next, cfg) {
377                 const char *id;
378                 n = snd_config_iterator_entry(i);
379                 err = snd_config_get_id(n, &id);
380                 if (err < 0)
381                         continue;
382
383                 /* alloc new value */
384                 curr = calloc(1, sizeof(struct ucm_value));
385                 if (curr == NULL)
386                         return -ENOMEM;
387                 list_add_tail(&curr->list, base);
388                 curr->name = strdup(id);
389                 if (curr->name == NULL)
390                         return -ENOMEM;
391                 type = snd_config_get_type(n);
392                 switch (type) {
393                 case SND_CONFIG_TYPE_INTEGER:
394                         curr->data = malloc(16);
395                         if (curr->data == NULL)
396                                 return -ENOMEM;
397                         snd_config_get_integer(n, &l);
398                         sprintf(curr->data, "%li", l);
399                         break;
400                 case SND_CONFIG_TYPE_INTEGER64:
401                         curr->data = malloc(32);
402                         if (curr->data == NULL)
403                                 return -ENOMEM;
404                         snd_config_get_integer64(n, &ll);
405                         sprintf(curr->data, "%lli", ll);
406                         break;
407                 case SND_CONFIG_TYPE_REAL:
408                         curr->data = malloc(64);
409                         if (curr->data == NULL)
410                                 return -ENOMEM;
411                         snd_config_get_real(n, &d);
412                         sprintf(curr->data, "%-16g", d);
413                         break;
414                 case SND_CONFIG_TYPE_STRING:
415                         err = parse_string(n, &curr->data);
416                         if (err < 0) {
417                                 uc_error("error: unable to parse a string for id '%s'!", id);
418                                 return err;
419                         }
420                         break;
421                 default:
422                         uc_error("error: invalid type %i in Value compound", type);
423                         return -EINVAL;
424                 }
425         }
426
427         return 0;
428 }
429
430 /*
431  * Parse Modifier Use cases
432  *
433  *      # Each modifier is described in new section. N modifiers are allowed
434  *      SectionModifier."Capture Voice" {
435  *
436  *              Comment "Record voice call"
437  *
438  *              SupportedDevice [
439  *                      "x"
440  *                      "y"
441  *              ]
442  *
443  *              ConflictingDevice [
444  *                      "x"
445  *                      "y"
446  *              ]
447  *
448  *              EnableSequence [
449  *                      ....
450  *              ]
451  *
452  *              DisableSequence [
453  *                      ...
454  *              ]
455  *
456  *              TransitionSequence."ToModifierName" [
457  *                      ...
458  *              ]
459  *
460  *              # Optional TQ and ALSA PCMs
461  *              Value {
462  *                      TQ Voice
463  *                      CapturePCM "hw:1"
464  *                      PlaybackVolume "name='Master Playback Volume',index=2"
465  *                      PlaybackSwitch "name='Master Playback Switch',index=2"
466  *              }
467  *
468  *       }
469  *
470  * SupportedDevice and ConflictingDevice cannot be specified together.
471  * Both are optional.
472  */
473 static int parse_modifier(snd_use_case_mgr_t *uc_mgr,
474                 snd_config_t *cfg,
475                 void *data1,
476                 void *data2)
477 {
478         struct use_case_verb *verb = data1;
479         struct use_case_modifier *modifier;
480         const char *name;
481         snd_config_iterator_t i, next;
482         snd_config_t *n;
483         int err;
484
485         if (data2) {
486                 name = data2;
487                 if (!parse_is_name_safe(name))
488                         return -EINVAL;
489         }
490         else {
491                 if (parse_get_safe_id(cfg, &name) < 0)
492                         return -EINVAL;
493         }
494
495         /* allocate modifier */
496         modifier = calloc(1, sizeof(*modifier));
497         if (modifier == NULL)
498                 return -ENOMEM;
499         INIT_LIST_HEAD(&modifier->enable_list);
500         INIT_LIST_HEAD(&modifier->disable_list);
501         INIT_LIST_HEAD(&modifier->transition_list);
502         INIT_LIST_HEAD(&modifier->dev_list.list);
503         INIT_LIST_HEAD(&modifier->value_list);
504         list_add_tail(&modifier->list, &verb->modifier_list);
505         modifier->name = strdup(name);
506
507         snd_config_for_each(i, next, cfg) {
508                 const char *id;
509                 n = snd_config_iterator_entry(i);
510                 if (snd_config_get_id(n, &id) < 0)
511                         continue;
512
513                 if (strcmp(id, "Comment") == 0) {
514                         err = parse_string(n, &modifier->comment);
515                         if (err < 0) {
516                                 uc_error("error: failed to get modifier comment");
517                                 return err;
518                         }
519                         continue;
520                 }
521
522                 if (strcmp(id, "SupportedDevice") == 0) {
523                         err = parse_device_list(uc_mgr, &modifier->dev_list,
524                                                 DEVLIST_SUPPORTED, n);
525                         if (err < 0) {
526                                 uc_error("error: failed to parse supported"
527                                         " device list");
528                                 return err;
529                         }
530                 }
531
532                 if (strcmp(id, "ConflictingDevice") == 0) {
533                         err = parse_device_list(uc_mgr, &modifier->dev_list,
534                                                 DEVLIST_CONFLICTING, n);
535                         if (err < 0) {
536                                 uc_error("error: failed to parse conflicting"
537                                         " device list");
538                                 return err;
539                         }
540                 }
541
542                 if (strcmp(id, "EnableSequence") == 0) {
543                         err = parse_sequence(uc_mgr, &modifier->enable_list, n);
544                         if (err < 0) {
545                                 uc_error("error: failed to parse modifier"
546                                         " enable sequence");
547                                 return err;
548                         }
549                         continue;
550                 }
551
552                 if (strcmp(id, "DisableSequence") == 0) {
553                         err = parse_sequence(uc_mgr, &modifier->disable_list, n);
554                         if (err < 0) {
555                                 uc_error("error: failed to parse modifier"
556                                         " disable sequence");
557                                 return err;
558                         }
559                         continue;
560                 }
561
562                 if (strcmp(id, "TransitionSequence") == 0) {
563                         err = parse_transition(uc_mgr, &modifier->transition_list, n);
564                         if (err < 0) {
565                                 uc_error("error: failed to parse transition"
566                                         " modifier");
567                                 return err;
568                         }
569                         continue;
570                 }
571
572                 if (strcmp(id, "Value") == 0) {
573                         err = parse_value(uc_mgr, &modifier->value_list, n);
574                         if (err < 0) {
575                                 uc_error("error: failed to parse Value");
576                                 return err;
577                         }
578                         continue;
579                 }
580         }
581
582         return 0;
583 }
584
585 /*
586  * Parse Device Use Cases
587  *
588  *# Each device is described in new section. N devices are allowed
589  *SectionDevice."Headphones" {
590  *      Comment "Headphones connected to 3.5mm jack"
591  *
592  *      upportedDevice [
593  *              "x"
594  *              "y"
595  *      ]
596  *
597  *      ConflictingDevice [
598  *              "x"
599  *              "y"
600  *      ]
601  *
602  *      EnableSequence [
603  *              ....
604  *      ]
605  *
606  *      DisableSequence [
607  *              ...
608  *      ]
609  *
610  *      TransitionSequence."ToDevice" [
611  *              ...
612  *      ]
613  *
614  *      Value {
615  *              PlaybackVolume "name='Master Playback Volume',index=2"
616  *              PlaybackSwitch "name='Master Playback Switch',index=2"
617  *      }
618  * }
619  */
620 static int parse_device(snd_use_case_mgr_t *uc_mgr,
621                         snd_config_t *cfg,
622                         void *data1,
623                         void *data2)
624 {
625         struct use_case_verb *verb = data1;
626         const char *name;
627         struct use_case_device *device;
628         snd_config_iterator_t i, next;
629         snd_config_t *n;
630         int err;
631
632         if (data2) {
633                 name = data2;
634                 if (!parse_is_name_safe(name))
635                         return -EINVAL;
636         }
637         else {
638                 if (parse_get_safe_id(cfg, &name) < 0)
639                         return -EINVAL;
640         }
641
642         device = calloc(1, sizeof(*device));
643         if (device == NULL)
644                 return -ENOMEM;
645         INIT_LIST_HEAD(&device->enable_list);
646         INIT_LIST_HEAD(&device->disable_list);
647         INIT_LIST_HEAD(&device->transition_list);
648         INIT_LIST_HEAD(&device->dev_list.list);
649         INIT_LIST_HEAD(&device->value_list);
650         list_add_tail(&device->list, &verb->device_list);
651         device->name = strdup(name);
652
653         snd_config_for_each(i, next, cfg) {
654                 const char *id;
655                 n = snd_config_iterator_entry(i);
656                 if (snd_config_get_id(n, &id) < 0)
657                         continue;
658
659                 if (strcmp(id, "Comment") == 0) {
660                         err = parse_string(n, &device->comment);
661                         if (err < 0) {
662                                 uc_error("error: failed to get device comment");
663                                 return err;
664                         }
665                         continue;
666                 }
667
668                 if (strcmp(id, "SupportedDevice") == 0) {
669                         err = parse_device_list(uc_mgr, &device->dev_list,
670                                                 DEVLIST_SUPPORTED, n);
671                         if (err < 0) {
672                                 uc_error("error: failed to parse supported"
673                                         " device list");
674                                 return err;
675                         }
676                 }
677
678                 if (strcmp(id, "ConflictingDevice") == 0) {
679                         err = parse_device_list(uc_mgr, &device->dev_list,
680                                                 DEVLIST_CONFLICTING, n);
681                         if (err < 0) {
682                                 uc_error("error: failed to parse conflicting"
683                                         " device list");
684                                 return err;
685                         }
686                 }
687
688                 if (strcmp(id, "EnableSequence") == 0) {
689                         uc_dbg("EnableSequence");
690                         err = parse_sequence(uc_mgr, &device->enable_list, n);
691                         if (err < 0) {
692                                 uc_error("error: failed to parse device enable"
693                                          " sequence");
694                                 return err;
695                         }
696                         continue;
697                 }
698
699                 if (strcmp(id, "DisableSequence") == 0) {
700                         uc_dbg("DisableSequence");
701                         err = parse_sequence(uc_mgr, &device->disable_list, n);
702                         if (err < 0) {
703                                 uc_error("error: failed to parse device disable"
704                                          " sequence");
705                                 return err;
706                         }
707                         continue;
708                 }
709
710                 if (strcmp(id, "TransitionSequence") == 0) {
711                         uc_dbg("TransitionSequence");
712                         err = parse_transition(uc_mgr, &device->transition_list, n);
713                         if (err < 0) {
714                                 uc_error("error: failed to parse transition"
715                                         " device");
716                                 return err;
717                         }
718                         continue;
719                 }
720
721                 if (strcmp(id, "Value") == 0) {
722                         err = parse_value(uc_mgr, &device->value_list, n);
723                         if (err < 0) {
724                                 uc_error("error: failed to parse Value");
725                                 return err;
726                         }
727                         continue;
728                 }
729         }
730         return 0;
731 }
732
733 static int parse_compound_check_legacy(snd_use_case_mgr_t *uc_mgr,
734           snd_config_t *cfg,
735           int (*fcn)(snd_use_case_mgr_t *, snd_config_t *, void *, void *),
736           void *data1)
737 {
738         const char *id, *idchild;
739         int child_ctr = 0, legacy_format = 1;
740         snd_config_iterator_t i, next;
741         snd_config_t *child;
742         int err;
743
744         err = snd_config_get_id(cfg, &id);
745         if (err < 0)
746                 return err;
747
748         snd_config_for_each(i, next, cfg) {
749                 child_ctr++;
750                 if (child_ctr > 1) {
751                         break;
752                 }
753
754                 child = snd_config_iterator_entry(i);
755
756                 if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
757                         legacy_format = 0;
758                         break;
759                 }
760
761                 if (snd_config_get_id(child, &idchild) < 0)
762                         return -EINVAL;
763
764                 if (strcmp(idchild, "0")) {
765                         legacy_format = 0;
766                         break;
767                 }
768         }
769         if (child_ctr != 1) {
770                 legacy_format = 0;
771         }
772
773         if (legacy_format)
774                 return parse_compound(uc_mgr, cfg, fcn, data1, (void *)id);
775         else
776                 return fcn(uc_mgr, cfg, data1, NULL);
777 }
778
779 static int parse_device_name(snd_use_case_mgr_t *uc_mgr,
780                              snd_config_t *cfg,
781                              void *data1,
782                              void *data2 ATTRIBUTE_UNUSED)
783 {
784         return parse_compound_check_legacy(uc_mgr, cfg, parse_device, data1);
785 }
786
787 static int parse_modifier_name(snd_use_case_mgr_t *uc_mgr,
788                              snd_config_t *cfg,
789                              void *data1,
790                              void *data2 ATTRIBUTE_UNUSED)
791 {
792         return parse_compound_check_legacy(uc_mgr, cfg, parse_modifier, data1);
793 }
794
795 /*
796  * Parse Verb Section
797  *
798  * # Example Use case verb section for Voice call blah
799  * # By Joe Blogs <joe@blogs.com>
800  *
801  * SectionVerb {
802  *      # enable and disable sequences are compulsory
803  *      EnableSequence [
804  *              cset "name='Master Playback Switch',index=2 0,0"
805  *              cset "name='Master Playback Volume',index=2 25,25"
806  *              msleep 50
807  *              cset "name='Master Playback Switch',index=2 1,1"
808  *              cset "name='Master Playback Volume',index=2 50,50"
809  *      ]
810  *
811  *      DisableSequence [
812  *              cset "name='Master Playback Switch',index=2 0,0"
813  *              cset "name='Master Playback Volume',index=2 25,25"
814  *              msleep 50
815  *              cset "name='Master Playback Switch',index=2 1,1"
816  *              cset "name='Master Playback Volume',index=2 50,50"
817  *      ]
818  *
819  *      # Optional transition verb
820  *      TransitionSequence."ToCaseName" [
821  *              msleep 1
822  *      ]
823  *
824  *      # Optional TQ and ALSA PCMs
825  *      Value {
826  *              TQ HiFi
827  *              CapturePCM "hw:0"
828  *              PlaybackPCM "hw:0"
829  *      }
830  * }
831  */
832 static int parse_verb(snd_use_case_mgr_t *uc_mgr,
833                       struct use_case_verb *verb,
834                       snd_config_t *cfg)
835 {
836         snd_config_iterator_t i, next;
837         snd_config_t *n;
838         int err;
839         
840         /* parse verb section */
841         snd_config_for_each(i, next, cfg) {
842                 const char *id;
843                 n = snd_config_iterator_entry(i);
844                 if (snd_config_get_id(n, &id) < 0)
845                         continue;
846
847                 if (strcmp(id, "EnableSequence") == 0) {
848                         uc_dbg("Parse EnableSequence");
849                         err = parse_sequence(uc_mgr, &verb->enable_list, n);
850                         if (err < 0) {
851                                 uc_error("error: failed to parse verb enable sequence");
852                                 return err;
853                         }
854                         continue;
855                 }
856
857                 if (strcmp(id, "DisableSequence") == 0) {
858                         uc_dbg("Parse DisableSequence");
859                         err = parse_sequence(uc_mgr, &verb->disable_list, n);
860                         if (err < 0) {
861                                 uc_error("error: failed to parse verb disable sequence");
862                                 return err;
863                         }
864                         continue;
865                 }
866
867                 if (strcmp(id, "TransitionSequence") == 0) {
868                         uc_dbg("Parse TransitionSequence");
869                         err = parse_transition(uc_mgr, &verb->transition_list, n);
870                         if (err < 0) {
871                                 uc_error("error: failed to parse transition sequence");
872                                 return err;
873                         }
874                         continue;
875                 }
876
877                 if (strcmp(id, "Value") == 0) {
878                         uc_dbg("Parse Value");
879                         err = parse_value(uc_mgr, &verb->value_list, n);
880                         if (err < 0)
881                                 return err;
882                         continue;
883                 }
884         }
885
886         return 0;
887 }
888
889 /*
890  * Parse a Use case verb file.
891  *
892  * This file contains the following :-
893  *  o Verb enable and disable sequences.
894  *  o Supported Device enable and disable sequences for verb.
895  *  o Supported Modifier enable and disable sequences for verb
896  *  o Optional QoS for the verb and modifiers.
897  *  o Optional PCM device ID for verb and modifiers
898  *  o Alias kcontrols IDs for master and volumes and mutes.
899  */
900 static int parse_verb_file(snd_use_case_mgr_t *uc_mgr,
901                            const char *use_case_name,
902                            const char *comment,
903                            const char *file)
904 {
905         snd_config_iterator_t i, next;
906         snd_config_t *n;
907         struct use_case_verb *verb;
908         snd_config_t *cfg;
909         char filename[MAX_FILE];
910         char *env = getenv(ALSA_CONFIG_UCM_VAR);
911         int err;
912
913         /* allocate verb */
914         verb = calloc(1, sizeof(struct use_case_verb));
915         if (verb == NULL)
916                 return -ENOMEM;
917         INIT_LIST_HEAD(&verb->enable_list);
918         INIT_LIST_HEAD(&verb->disable_list);
919         INIT_LIST_HEAD(&verb->transition_list);
920         INIT_LIST_HEAD(&verb->device_list);
921         INIT_LIST_HEAD(&verb->modifier_list);
922         INIT_LIST_HEAD(&verb->value_list);
923         list_add_tail(&verb->list, &uc_mgr->verb_list);
924         if (use_case_name == NULL)
925                 return -EINVAL;
926         verb->name = strdup(use_case_name);
927         if (verb->name == NULL)
928                 return -ENOMEM;
929
930         if (comment != NULL) {
931                 verb->comment = strdup(comment);
932                 if (verb->comment == NULL)
933                         return -ENOMEM;
934         }
935
936         /* open Verb file for reading */
937         snprintf(filename, sizeof(filename), "%s/%s/%s",
938                 env ? env : ALSA_USE_CASE_DIR,
939                 uc_mgr->card_name, file);
940         filename[sizeof(filename)-1] = '\0';
941         
942         err = uc_mgr_config_load(filename, &cfg);
943         if (err < 0) {
944                 uc_error("error: failed to open verb file %s : %d",
945                         filename, -errno);
946                 return err;
947         }
948
949         /* parse master config sections */
950         snd_config_for_each(i, next, cfg) {
951                 const char *id;
952                 n = snd_config_iterator_entry(i);
953                 if (snd_config_get_id(n, &id) < 0)
954                         continue;
955
956                 /* find verb section and parse it */
957                 if (strcmp(id, "SectionVerb") == 0) {
958                         err = parse_verb(uc_mgr, verb, n);
959                         if (err < 0) {
960                                 uc_error("error: %s failed to parse verb",
961                                                 file);
962                                 return err;
963                         }
964                         continue;
965                 }
966
967                 /* find device sections and parse them */
968                 if (strcmp(id, "SectionDevice") == 0) {
969                         err = parse_compound(uc_mgr, n,
970                                                 parse_device_name, verb, NULL);
971                         if (err < 0) {
972                                 uc_error("error: %s failed to parse device",
973                                                 file);
974                                 return err;
975                         }
976                         continue;
977                 }
978
979                 /* find modifier sections and parse them */
980                 if (strcmp(id, "SectionModifier") == 0) {
981                         err = parse_compound(uc_mgr, n,
982                                              parse_modifier_name, verb, NULL);
983                         if (err < 0) {
984                                 uc_error("error: %s failed to parse modifier",
985                                                 file);
986                                 return err;
987                         }
988                         continue;
989                 }
990         }
991
992         /* use case verb must have at least 1 device */
993         if (list_empty(&verb->device_list)) {
994                 uc_error("error: no use case device defined", file);
995                 return -EINVAL;
996         }
997         return 0;
998 }
999
1000 /*
1001  * Parse master section for "Use Case" and "File" tags.
1002  */
1003 static int parse_master_section(snd_use_case_mgr_t *uc_mgr, snd_config_t *cfg,
1004                                 void *data1 ATTRIBUTE_UNUSED,
1005                                 void *data2 ATTRIBUTE_UNUSED)
1006 {
1007         snd_config_iterator_t i, next;
1008         snd_config_t *n;
1009         const char *use_case_name, *file = NULL, *comment = NULL;
1010         int err;
1011
1012         if (snd_config_get_id(cfg, &use_case_name) < 0) {
1013                 uc_error("unable to get name for use case section");
1014                 return -EINVAL;
1015         }
1016
1017         if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
1018                 uc_error("compound type expected for use case section");
1019                 return -EINVAL;
1020         }
1021         /* parse master config sections */
1022         snd_config_for_each(i, next, cfg) {
1023                 const char *id;
1024                 n = snd_config_iterator_entry(i);
1025                 if (snd_config_get_id(n, &id) < 0)
1026                         continue;
1027
1028                 /* get use case verb file name */
1029                 if (strcmp(id, "File") == 0) {
1030                         err = snd_config_get_string(n, &file);
1031                         if (err < 0) {
1032                                 uc_error("failed to get File");
1033                                 return err;
1034                         }
1035                         continue;
1036                 }
1037
1038                 /* get optional use case comment */
1039                 if (strncmp(id, "Comment", 7) == 0) {
1040                         err = snd_config_get_string(n, &comment);
1041                         if (err < 0) {
1042                                 uc_error("error: failed to get Comment");
1043                                 return err;
1044                         }
1045                         continue;
1046                 }
1047
1048                 uc_error("unknown field %s in master section");
1049         }
1050
1051         uc_dbg("use_case_name %s file '%s'", use_case_name, file);
1052
1053         /* do we have both use case name and file ? */
1054         if (!file) {
1055                 uc_error("error: use case missing file");
1056                 return -EINVAL;
1057         }
1058
1059         /* parse verb file */
1060         return parse_verb_file(uc_mgr, use_case_name, comment, file);
1061 }
1062
1063 /*
1064  * parse controls
1065  */
1066 static int parse_controls(snd_use_case_mgr_t *uc_mgr, snd_config_t *cfg)
1067 {
1068         int err;
1069         
1070         if (!list_empty(&uc_mgr->default_list)) {
1071                 uc_error("Default list is not empty");
1072                 return -EINVAL;
1073         }
1074         err = parse_sequence(uc_mgr, &uc_mgr->default_list, cfg);
1075         if (err < 0) {
1076                 uc_error("Unable to parse SectionDefaults");
1077                 return err;
1078         }
1079         
1080         return 0;
1081 }
1082
1083 /*
1084  * Each sound card has a master sound card file that lists all the supported
1085  * use case verbs for that sound card. i.e.
1086  *
1087  * #Example master file for blah sound card
1088  * #By Joe Blogs <joe@bloggs.org>
1089  *
1090  * Comment "Nice Abstracted Soundcard"
1091  *
1092  * # The file is divided into Use case sections. One section per use case verb.
1093  *
1094  * SectionUseCase."Voice Call" {
1095  *      File "voice_call_blah"
1096  *      Comment "Make a voice phone call."
1097  * }
1098  *
1099  * SectionUseCase."HiFi" {
1100  *      File "hifi_blah"
1101  *      Comment "Play and record HiFi quality Music."
1102  * }
1103  *
1104  * # Define Value defaults
1105  *
1106  * ValueDefaults {
1107  *      PlaybackCTL "hw:CARD=0"
1108  *      CaptureCTL "hw:CARD=0"
1109  * }
1110  *
1111  * # This file also stores the default sound card state.
1112  *
1113  * SectionDefaults [
1114  *      cset "name='Master Playback Switch',index=2 1,1"
1115  *      cset "name='Master Playback Volume',index=2 25,25"
1116  *      cset "name='Master Mono Playback',index=1 0"
1117  *      cset "name='Master Mono Playback Volume',index=1 0"
1118  *      cset "name='PCM Switch',index=2 1,1"
1119  *      exec "some binary here"
1120  *      msleep 50
1121  *      ........
1122  * ]
1123  *
1124  * # End of example file.
1125  */
1126 static int parse_master_file(snd_use_case_mgr_t *uc_mgr, snd_config_t *cfg)
1127 {
1128         snd_config_iterator_t i, next;
1129         snd_config_t *n;
1130         const char *id;
1131         int err;
1132
1133         if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
1134                 uc_error("compound type expected for master file");
1135                 return -EINVAL;
1136         }
1137
1138         /* parse master config sections */
1139         snd_config_for_each(i, next, cfg) {
1140
1141                 n = snd_config_iterator_entry(i);
1142                 if (snd_config_get_id(n, &id) < 0)
1143                         continue;
1144
1145                 if (strcmp(id, "Comment") == 0) {
1146                         err = parse_string(n, &uc_mgr->comment);
1147                         if (err < 0) {
1148                                 uc_error("error: failed to get master comment");
1149                                 return err;
1150                         }
1151                         continue;
1152                 }
1153
1154                 /* find use case section and parse it */
1155                 if (strcmp(id, "SectionUseCase") == 0) {
1156                         err = parse_compound(uc_mgr, n,
1157                                              parse_master_section,
1158                                              NULL, NULL);
1159                         if (err < 0)
1160                                 return err;
1161                         continue;
1162                 }
1163
1164                 /* find default control values section and parse it */
1165                 if (strcmp(id, "SectionDefaults") == 0) {
1166                         err = parse_controls(uc_mgr, n);
1167                         if (err < 0)
1168                                 return err;
1169                         continue;
1170                 }
1171
1172                 /* get the default values */
1173                 if (strcmp(id, "ValueDefaults") == 0) {
1174                         err = parse_value(uc_mgr, &uc_mgr->value_list, n);
1175                         if (err < 0) {
1176                                 uc_error("error: failed to parse ValueDefaults");
1177                                 return err;
1178                         }
1179                         continue;
1180                 }
1181
1182                 uc_error("uknown master file field %s", id);
1183         }
1184         return 0;
1185 }
1186
1187 static int load_master_config(const char *card_name, snd_config_t **cfg)
1188 {
1189         char filename[MAX_FILE];
1190         char *env = getenv(ALSA_CONFIG_UCM_VAR);
1191         int err;
1192
1193         snprintf(filename, sizeof(filename)-1,
1194                 "%s/%s/%s.conf", env ? env : ALSA_USE_CASE_DIR,
1195                 card_name, card_name);
1196         filename[MAX_FILE-1] = '\0';
1197
1198         err = uc_mgr_config_load(filename, cfg);
1199         if (err < 0) {
1200                 uc_error("error: could not parse configuration for card %s",
1201                                 card_name);
1202                 return err;
1203         }
1204
1205         return 0;
1206 }
1207
1208 /* load master use case file for sound card */
1209 int uc_mgr_import_master_config(snd_use_case_mgr_t *uc_mgr)
1210 {
1211         snd_config_t *cfg;
1212         int err;
1213
1214         err = load_master_config(uc_mgr->card_name, &cfg);
1215         if (err < 0)
1216                 return err;
1217         err = parse_master_file(uc_mgr, cfg);
1218         snd_config_delete(cfg);
1219         if (err < 0)
1220                 uc_mgr_free_verb(uc_mgr);
1221
1222         return err;
1223 }
1224
1225 static int filename_filter(const struct dirent *dirent)
1226 {
1227         if (dirent == NULL)
1228                 return 0;
1229         if (dirent->d_type == DT_DIR) {
1230                 if (dirent->d_name[0] == '.') {
1231                         if (dirent->d_name[1] == '\0')
1232                                 return 0;
1233                         if (dirent->d_name[1] == '.' &&
1234                             dirent->d_name[2] == '\0')
1235                                 return 0;
1236                 }
1237                 return 1;
1238         }
1239         return 0;
1240 }
1241
1242 /* scan all cards and comments */
1243 int uc_mgr_scan_master_configs(const char **_list[])
1244 {
1245         char filename[MAX_FILE], dfl[MAX_FILE];
1246         char *env = getenv(ALSA_CONFIG_UCM_VAR);
1247         const char **list;
1248         snd_config_t *cfg, *c;
1249         int i, cnt, err;
1250         ssize_t ss;
1251         struct dirent **namelist;
1252
1253         snprintf(filename, sizeof(filename)-1,
1254                 "%s", env ? env : ALSA_USE_CASE_DIR);
1255         filename[MAX_FILE-1] = '\0';
1256
1257 #ifdef _GNU_SOURCE
1258 #define SORTFUNC        versionsort
1259 #else
1260 #define SORTFUNC        alphasort
1261 #endif
1262         err = scandir(filename, &namelist, filename_filter, SORTFUNC);
1263         if (err < 0) {
1264                 err = -errno;
1265                 uc_error("error: could not scan directory %s: %s",
1266                                 filename, strerror(-err));
1267                 return err;
1268         }
1269         cnt = err;
1270
1271         dfl[0] = '\0';
1272         if (strlen(filename) + 8 < sizeof(filename)) {
1273                 strcat(filename, "/default");
1274                 ss = readlink(filename, dfl, sizeof(dfl)-1);
1275                 if (ss >= 0) {
1276                         dfl[ss] = '\0';
1277                         dfl[sizeof(dfl)-1] = '\0';
1278                         if (dfl[0] && dfl[strlen(dfl)-1] == '/')
1279                                 dfl[strlen(dfl)-1] = '\0';
1280                 } else {
1281                         dfl[0] = '\0';
1282                 }
1283         }
1284
1285         list = calloc(1, cnt * 2 * sizeof(char *));
1286         if (list == NULL) {
1287                 err = -ENOMEM;
1288                 goto __err;
1289         }
1290
1291         for (i = 0; i < cnt; i++) {
1292                 err = load_master_config(namelist[i]->d_name, &cfg);
1293                 if (err < 0)
1294                         goto __err;
1295                 err = snd_config_search(cfg, "Comment", &c);
1296                 if (err >= 0) {
1297                         err = parse_string(c, (char **)&list[i*2+1]);
1298                         if (err < 0) {
1299                                 snd_config_delete(cfg);
1300                                 goto __err;
1301                         }
1302                 }
1303                 snd_config_delete(cfg);
1304                 list[i * 2] = strdup(namelist[i]->d_name);
1305                 if (list[i * 2] == NULL) {
1306                         err = -ENOMEM;
1307                         goto __err;
1308                 }
1309                 if (strcmp(dfl, list[i * 2]) == 0) {
1310                         /* default to top */
1311                         const char *save1 = list[i * 2];
1312                         const char *save2 = list[i * 2 + 1];
1313                         memmove(list + 2, list, i * 2 * sizeof(char *));
1314                         list[0] = save1;
1315                         list[1] = save2;
1316                 }
1317         }
1318         err = cnt * 2;
1319
1320       __err:
1321         for (i = 0; i < cnt; i++) {
1322                 free(namelist[i]);
1323                 if (err < 0) {
1324                         free((void *)list[i * 2]);
1325                         free((void *)list[i * 2 + 1]);
1326                 }
1327         }
1328         free(namelist);
1329
1330         if (err >= 0)
1331                 *_list = list;
1332
1333         return err;
1334 }