]> git.alsa-project.org Git - alsa-lib.git/commitdiff
ucm: ucm_main.c - cosmetic tab cleanups
authorJaroslav Kysela <perex@perex.cz>
Fri, 5 Mar 2021 18:35:03 +0000 (19:35 +0100)
committerJaroslav Kysela <perex@perex.cz>
Thu, 11 Mar 2021 08:26:07 +0000 (09:26 +0100)
This file is problematic for the git's tab checker.
The unexpand tool is used to convert initial spaces
to tabs.

Signed-off-by: Jaroslav Kysela <perex@perex.cz>
src/ucm/main.c

index 8ac99de08f9544e861974f5956c32fa9daf45de4..f9f78e024b243cf5b073e81be33d282394c4bc75 100644 (file)
@@ -48,9 +48,9 @@ static int get_value(snd_use_case_mgr_t *uc_mgr,
                        const char *verb_name,
                        int exact);
 static int get_value1(snd_use_case_mgr_t *uc_mgr, char **value,
-                      struct list_head *value_list, const char *identifier);
+                     struct list_head *value_list, const char *identifier);
 static int get_value3(snd_use_case_mgr_t *uc_mgr,
-                      char **value,
+                     char **value,
                      const char *identifier,
                      struct list_head *value_list1,
                      struct list_head *value_list2,
@@ -79,30 +79,30 @@ static int check_identifier(const char *identifier, const char *prefix)
 
 static int list_count(struct list_head *list)
 {
-        struct list_head *pos;
-        int count = 0;
-        
-        list_for_each(pos, list) {
-                count += 1;
-        }
-        return count;
+       struct list_head *pos;
+       int count = 0;
+
+       list_for_each(pos, list) {
+               count += 1;
+       }
+       return count;
 }
 
 static int alloc_str_list(struct list_head *list, int mult, char **result[])
 {
-        char **res;
-        int cnt;
-        
-        cnt = list_count(list) * mult;
-        if (cnt == 0) {
+       char **res;
+       int cnt;
+
+       cnt = list_count(list) * mult;
+       if (cnt == 0) {
                *result = NULL;
-                return cnt;
+               return cnt;
        }
-        res = calloc(mult, cnt * sizeof(char *));
-        if (res == NULL)
-                return -ENOMEM;
-        *result = res;
-        return cnt;
+       res = calloc(mult, cnt * sizeof(char *));
+       if (res == NULL)
+               return -ENOMEM;
+       *result = res;
+       return cnt;
 }
 
 /**
@@ -138,12 +138,12 @@ char *snd_use_case_identifier(const char *fmt, ...)
  */
 int snd_use_case_free_list(const char *list[], int items)
 {
-        int i;
+       int i;
        if (list == NULL)
                return 0;
-        for (i = 0; i < items; i++)
+       for (i = 0; i < items; i++)
                free((void *)list[i]);
-        free(list);
+       free(list);
        return 0;
 }
 
@@ -639,42 +639,42 @@ static void *find0(struct list_head *list,
  * \return count of items on success, otherwise a negative error code
  */
 static int get_list0(struct list_head *list,
-                     const char **result[],
-                     unsigned long offset,
-                     unsigned long s1offset)
+                    const char **result[],
+                    unsigned long offset,
+                    unsigned long s1offset)
 {
-        char **res;
-        int cnt;
+       char **res;
+       int cnt;
        struct list_head *pos;
        char *ptr, *str1;
 
        cnt = alloc_str_list(list, 1, &res);
        if (cnt <= 0) {
                *result = NULL;
-               return cnt;
+               return cnt;
        }
        *result = (const char **)res;
        list_for_each(pos, list) {
                ptr = list_entry_offset(pos, char, offset);
                str1 = *((char **)(ptr + s1offset));
                if (str1 != NULL) {
-                       *res = strdup(str1);
-                       if (*res == NULL)
-                               goto __fail;
-                } else {
-                        *res = NULL;
-                }
-                res++;
+                       *res = strdup(str1);
+                       if (*res == NULL)
+                               goto __fail;
+               } else {
+                       *res = NULL;
+               }
+               res++;
        }
        return cnt;
       __fail:
-        snd_use_case_free_list(*result, cnt);
-        return -ENOMEM;
+       snd_use_case_free_list(*result, cnt);
+       return -ENOMEM;
 }
 
 #define get_list(list, result, type, member, s1) \
        get_list0(list, result, \
-                   (unsigned long)(&((type *)0)->member), \
+                   (unsigned long)(&((type *)0)->member), \
                    (unsigned long)(&((type *)0)->s1))
 
 /**
@@ -687,52 +687,52 @@ static int get_list0(struct list_head *list,
  * \return count of items on success, otherwise a negative error code
  */
 static int get_list20(struct list_head *list,
-                      const char **result[],
-                      unsigned long offset,
-                      unsigned long s1offset,
-                      unsigned long s2offset)
+                     const char **result[],
+                     unsigned long offset,
+                     unsigned long s1offset,
+                     unsigned long s2offset)
 {
-        char **res;
-        int cnt;
+       char **res;
+       int cnt;
        struct list_head *pos;
        char *ptr, *str1, *str2;
 
        cnt = alloc_str_list(list, 2, &res);
        if (cnt <= 0) {
                *result = NULL;
-               return cnt;
+               return cnt;
        }
-        *result = (const char **)res;
+       *result = (const char **)res;
        list_for_each(pos, list) {
                ptr = list_entry_offset(pos, char, offset);
                str1 = *((char **)(ptr + s1offset));
                if (str1 != NULL) {
-                       *res = strdup(str1);
-                       if (*res == NULL)
-                               goto __fail;
-                } else {
-                        *res = NULL;
-                }
-                res++;
+                       *res = strdup(str1);
+                       if (*res == NULL)
+                               goto __fail;
+               } else {
+                       *res = NULL;
+               }
+               res++;
                str2 = *((char **)(ptr + s2offset));
                if (str2 != NULL) {
-                       *res = strdup(str2);
-                       if (*res == NULL)
-                               goto __fail;
-                } else {
-                        *res = NULL;
-                }
-                res++;
+                       *res = strdup(str2);
+                       if (*res == NULL)
+                               goto __fail;
+               } else {
+                       *res = NULL;
+               }
+               res++;
        }
        return cnt;
       __fail:
-        snd_use_case_free_list(*result, cnt);
-        return -ENOMEM;
+       snd_use_case_free_list(*result, cnt);
+       return -ENOMEM;
 }
 
 #define get_list2(list, result, type, member, s1, s2) \
        get_list20(list, result, \
-                   (unsigned long)(&((type *)0)->member), \
+                   (unsigned long)(&((type *)0)->member), \
                    (unsigned long)(&((type *)0)->s1), \
                    (unsigned long)(&((type *)0)->s2))
 
@@ -802,7 +802,7 @@ static inline int is_device_supported(snd_use_case_mgr_t *uc_mgr,
  * \return structure on success, otherwise a NULL (not found)
  */
 static inline struct use_case_device *
-        find_device(snd_use_case_mgr_t *uc_mgr, struct use_case_verb *verb,
+       find_device(snd_use_case_mgr_t *uc_mgr, struct use_case_verb *verb,
                    const char *device_name, int check_supported)
 {
        struct use_case_device *device;
@@ -830,7 +830,7 @@ static inline struct use_case_device *
  * \return structure on success, otherwise a NULL (not found)
  */
 static struct use_case_modifier *
-        find_modifier(snd_use_case_mgr_t *uc_mgr, struct use_case_verb *verb,
+       find_modifier(snd_use_case_mgr_t *uc_mgr, struct use_case_verb *verb,
                      const char *modifier_name, int check_supported)
 {
        struct use_case_modifier *modifier;
@@ -852,31 +852,31 @@ static struct use_case_modifier *
 }
 
 long device_status(snd_use_case_mgr_t *uc_mgr,
-                   const char *device_name)
+                  const char *device_name)
 {
-        struct use_case_device *dev;
-        struct list_head *pos;
+       struct use_case_device *dev;
+       struct list_head *pos;
 
-        list_for_each(pos, &uc_mgr->active_devices) {
-                dev = list_entry(pos, struct use_case_device, active_list);
-                if (strcmp(dev->name, device_name) == 0)
-                        return 1;
-        }
-        return 0;
+       list_for_each(pos, &uc_mgr->active_devices) {
+               dev = list_entry(pos, struct use_case_device, active_list);
+               if (strcmp(dev->name, device_name) == 0)
+                       return 1;
+       }
+       return 0;
 }
 
 long modifier_status(snd_use_case_mgr_t *uc_mgr,
-                     const char *modifier_name)
+                    const char *modifier_name)
 {
-        struct use_case_modifier *mod;
-        struct list_head *pos;
+       struct use_case_modifier *mod;
+       struct list_head *pos;
 
-        list_for_each(pos, &uc_mgr->active_modifiers) {
-                mod = list_entry(pos, struct use_case_modifier, active_list);
-                if (strcmp(mod->name, modifier_name) == 0)
-                        return 1;
-        }
-        return 0;
+       list_for_each(pos, &uc_mgr->active_modifiers) {
+               mod = list_entry(pos, struct use_case_modifier, active_list);
+               if (strcmp(mod->name, modifier_name) == 0)
+                       return 1;
+       }
+       return 0;
 }
 
 /**
@@ -958,7 +958,7 @@ static int set_device(snd_use_case_mgr_t *uc_mgr,
        struct list_head *seq;
        int err;
 
-        if (device_status(uc_mgr, device->name) == enable)
+       if (device_status(uc_mgr, device->name) == enable)
                return 0;
 
        if (enable) {
@@ -1120,7 +1120,7 @@ static int dismantle_use_case(snd_use_case_mgr_t *uc_mgr)
  */
 int snd_use_case_mgr_reset(snd_use_case_mgr_t *uc_mgr)
 {
-        int err;
+       int err;
 
        pthread_mutex_lock(&uc_mgr->mutex);
        err = execute_sequence(uc_mgr, &uc_mgr->default_list,
@@ -1139,9 +1139,9 @@ int snd_use_case_mgr_reset(snd_use_case_mgr_t *uc_mgr)
  */
 static int get_verb_list(snd_use_case_mgr_t *uc_mgr, const char **list[])
 {
-        return get_list2(&uc_mgr->verb_list, list,
-                         struct use_case_verb, list,
-                         name, comment);
+       return get_list2(&uc_mgr->verb_list, list,
+                        struct use_case_verb, list,
+                        name, comment);
 }
 
 /**
@@ -1151,20 +1151,20 @@ static int get_verb_list(snd_use_case_mgr_t *uc_mgr, const char **list[])
  * \return Number of list entries if success, otherwise a negative error code
  */
 static int get_device_list(snd_use_case_mgr_t *uc_mgr, const char **list[],
-                           char *verbname)
-{
-        struct use_case_verb *verb;
-        
-        if (verbname) {
-                verb = find_verb(uc_mgr, verbname);
-        } else {
-                verb = uc_mgr->active_verb;
-        }
-        if (verb == NULL)
-                return -ENOENT;
-        return get_list2(&verb->device_list, list,
-                         struct use_case_device, list,
-                         name, comment);
+                          char *verbname)
+{
+       struct use_case_verb *verb;
+
+       if (verbname) {
+               verb = find_verb(uc_mgr, verbname);
+       } else {
+               verb = uc_mgr->active_verb;
+       }
+       if (verb == NULL)
+               return -ENOENT;
+       return get_list2(&verb->device_list, list,
+                        struct use_case_device, list,
+                        name, comment);
 }
 
 /**
@@ -1174,20 +1174,19 @@ static int get_device_list(snd_use_case_mgr_t *uc_mgr, const char **list[],
  * \return Number of list entries if success, otherwise a negative error code
  */
 static int get_modifier_list(snd_use_case_mgr_t *uc_mgr, const char **list[],
-                             char *verbname)
-{
-        struct use_case_verb *verb;
-        
-        if (verbname) {
-                verb = find_verb(uc_mgr, verbname);
-        } else {
-                verb = uc_mgr->active_verb;
-        }
-        if (verb == NULL)
-                return -ENOENT;
-        return get_list2(&verb->modifier_list, list,
-                         struct use_case_modifier, list,
-                         name, comment);
+                            char *verbname)
+{
+       struct use_case_verb *verb;
+       if (verbname) {
+               verb = find_verb(uc_mgr, verbname);
+       } else {
+               verb = uc_mgr->active_verb;
+       }
+       if (verb == NULL)
+               return -ENOENT;
+       return get_list2(&verb->modifier_list, list,
+                        struct use_case_modifier, list,
+                        name, comment);
 }
 
 /**
@@ -1374,13 +1373,13 @@ static int add_identifiers(struct list_head *list,
  * \param source Source list with ucm_value structures
  */
 static int add_values(struct list_head *list,
-                      const char *identifier,
-                      struct list_head *source)
+                     const char *identifier,
+                     struct list_head *source)
 {
        struct ucm_value *v;
        struct list_head *pos;
        int err;
-        
+
        list_for_each(pos, source) {
                v = list_entry(pos, struct ucm_value, list);
                if (check_identifier(identifier, v->name)) {
@@ -1475,51 +1474,51 @@ __fail:
  * \return Number of list entries if success, otherwise a negative error code
  */
 static int get_value_list(snd_use_case_mgr_t *uc_mgr,
-                          const char *identifier,
-                          const char **list[],
-                          char *verbname)
+                         const char *identifier,
+                         const char **list[],
+                         char *verbname)
 {
        struct list_head mylist, *pos;
-        struct use_case_verb *verb;
-        struct use_case_device *dev;
-        struct use_case_modifier *mod;
-        char **res;
-        int err;
-        
-        if (verbname) {
-                verb = find_verb(uc_mgr, verbname);
-        } else {
-                verb = uc_mgr->active_verb;
-        }
-        if (verb == NULL)
-                return -ENOENT;
-        INIT_LIST_HEAD(&mylist);
+       struct use_case_verb *verb;
+       struct use_case_device *dev;
+       struct use_case_modifier *mod;
+       char **res;
+       int err;
+
+       if (verbname) {
+               verb = find_verb(uc_mgr, verbname);
+       } else {
+               verb = uc_mgr->active_verb;
+       }
+       if (verb == NULL)
+               return -ENOENT;
+       INIT_LIST_HEAD(&mylist);
        err = add_values(&mylist, identifier, &uc_mgr->value_list);
        if (err < 0)
                goto __fail;
-        err = add_values(&mylist, identifier, &verb->value_list);
-        if (err < 0)
-                goto __fail;
-        list_for_each(pos, &verb->device_list) {
-                dev = list_entry(pos, struct use_case_device, list);
-                err = add_values(&mylist, identifier, &dev->value_list);
-                if (err < 0)
-                        goto __fail;
-        }
-        list_for_each(pos, &verb->modifier_list) {
-                mod = list_entry(pos, struct use_case_modifier, list);
-                err = add_values(&mylist, identifier, &mod->value_list);
-                if (err < 0)
-                        goto __fail;
-        }
+       err = add_values(&mylist, identifier, &verb->value_list);
+       if (err < 0)
+               goto __fail;
+       list_for_each(pos, &verb->device_list) {
+               dev = list_entry(pos, struct use_case_device, list);
+               err = add_values(&mylist, identifier, &dev->value_list);
+               if (err < 0)
+                       goto __fail;
+       }
+       list_for_each(pos, &verb->modifier_list) {
+               mod = list_entry(pos, struct use_case_modifier, list);
+               err = add_values(&mylist, identifier, &mod->value_list);
+               if (err < 0)
+                       goto __fail;
+       }
        err = myvalue_to_str_list(&mylist, &res);
        if (err > 0)
-               *list = (const char **)res;
+               *list = (const char **)res;
        else if (err == 0)
                *list = NULL;
       __fail:
        myvalue_list_free(&mylist);
-        return err;
+       return err;
 }
 
 /**
@@ -1529,13 +1528,13 @@ static int get_value_list(snd_use_case_mgr_t *uc_mgr,
  * \return Number of list entries if success, otherwise a negative error code
  */
 static int get_enabled_device_list(snd_use_case_mgr_t *uc_mgr,
-                                   const char **list[])
+                                  const char **list[])
 {
-        if (uc_mgr->active_verb == NULL)
-                return -EINVAL;
-        return get_list(&uc_mgr->active_devices, list,
-                        struct use_case_device, active_list,
-                        name);
+       if (uc_mgr->active_verb == NULL)
+               return -EINVAL;
+       return get_list(&uc_mgr->active_devices, list,
+                       struct use_case_device, active_list,
+                       name);
 }
 
 /**
@@ -1545,13 +1544,13 @@ static int get_enabled_device_list(snd_use_case_mgr_t *uc_mgr,
  * \return Number of list entries if success, otherwise a negative error code
  */
 static int get_enabled_modifier_list(snd_use_case_mgr_t *uc_mgr,
-                                     const char **list[])
+                                    const char **list[])
 {
-        if (uc_mgr->active_verb == NULL)
-                return -EINVAL;
-        return get_list(&uc_mgr->active_modifiers, list,
-                        struct use_case_modifier, active_list,
-                        name);
+       if (uc_mgr->active_verb == NULL)
+               return -EINVAL;
+       return get_list(&uc_mgr->active_modifiers, list,
+                       struct use_case_modifier, active_list,
+                       name);
 }
 
 /**
@@ -1573,24 +1572,24 @@ int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr,
        pthread_mutex_lock(&uc_mgr->mutex);
        if (strcmp(identifier, "_verbs") == 0)
                err = get_verb_list(uc_mgr, list);
-        else if (strcmp(identifier, "_enadevs") == 0)
-               err = get_enabled_device_list(uc_mgr, list);
-        else if (strcmp(identifier, "_enamods") == 0)
-                err = get_enabled_modifier_list(uc_mgr, list);
-        else {
-                str1 = strchr(identifier, '/');
-                if (str1) {
-                        str = strdup(str1 + 1);
-                       if (str == NULL) {
-                               err = -ENOMEM;
-                               goto __end;
-                        }
-                } else {
-                        str = NULL;
-                }
+       else if (strcmp(identifier, "_enadevs") == 0)
+               err = get_enabled_device_list(uc_mgr, list);
+       else if (strcmp(identifier, "_enamods") == 0)
+               err = get_enabled_modifier_list(uc_mgr, list);
+       else {
+               str1 = strchr(identifier, '/');
+               if (str1) {
+                       str = strdup(str1 + 1);
+                       if (str == NULL) {
+                               err = -ENOMEM;
+                               goto __end;
+                       }
+               } else {
+                       str = NULL;
+               }
                if (check_identifier(identifier, "_devices"))
                        err = get_device_list(uc_mgr, list, str);
-                else if (check_identifier(identifier, "_modifiers"))
+               else if (check_identifier(identifier, "_modifiers"))
                        err = get_modifier_list(uc_mgr, list, str);
                else if (check_identifier(identifier, "_identifiers"))
                        err = get_identifiers_list(uc_mgr, list, str);
@@ -1613,13 +1612,13 @@ int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr,
 static int get_value1(snd_use_case_mgr_t *uc_mgr, char **value,
                      struct list_head *value_list, const char *identifier)
 {
-        struct ucm_value *val;
-        struct list_head *pos;
-        
+       struct ucm_value *val;
+       struct list_head *pos;
+
        if (!value_list)
                return -ENOENT;
 
-        list_for_each(pos, value_list) {
+       list_for_each(pos, value_list) {
                val = list_entry(pos, struct ucm_value, list);
                if (check_identifier(identifier, val->name)) {
                        if (uc_mgr->conf_format < 2) {
@@ -1630,8 +1629,8 @@ static int get_value1(snd_use_case_mgr_t *uc_mgr, char **value,
                        }
                        return uc_mgr_get_substituted_value(uc_mgr, value, val->data);
                }
-        }
-        return -ENOENT;
+       }
+       return -ENOENT;
 }
 
 static int get_value3(snd_use_case_mgr_t *uc_mgr,
@@ -1740,27 +1739,27 @@ int snd_use_case_get(snd_use_case_mgr_t *uc_mgr,
        const char *slash1, *slash2, *mod_dev_after;
        const char *ident, *mod_dev, *verb;
        int exact = 0;
-        int err;
+       int err;
 
        pthread_mutex_lock(&uc_mgr->mutex);
        if (identifier == NULL) {
-               *value = strdup(uc_mgr->card_name);
-               if (*value == NULL) {
-                       err = -ENOMEM;
-                       goto __end;
-                }
-                err = 0;
-        } else if (strcmp(identifier, "_verb") == 0) {
-                if (uc_mgr->active_verb == NULL) {
-                        err = -ENOENT;
+               *value = strdup(uc_mgr->card_name);
+               if (*value == NULL) {
+                       err = -ENOMEM;
                        goto __end;
                }
-                *value = strdup(uc_mgr->active_verb->name);
-                if (*value == NULL) {
-                        err = -ENOMEM;
-                        goto __end;
-                }
-               err = 0;
+               err = 0;
+       } else if (strcmp(identifier, "_verb") == 0) {
+               if (uc_mgr->active_verb == NULL) {
+                       err = -ENOENT;
+                       goto __end;
+               }
+               *value = strdup(uc_mgr->active_verb->name);
+               if (*value == NULL) {
+                       err = -ENOMEM;
+                       goto __end;
+               }
+               err = 0;
        } else if (strcmp(identifier, "_file") == 0) {
                /* get the conf file name of the opened card */
                if ((uc_mgr->card_name == NULL) ||
@@ -1779,7 +1778,7 @@ int snd_use_case_get(snd_use_case_mgr_t *uc_mgr,
        } else if (identifier[0] == '_') {
                err = -ENOENT;
                goto __end;
-        } else {
+       } else {
                if (identifier[0] == '=') {
                        exact = 1;
                        identifier++;
@@ -1812,15 +1811,15 @@ int snd_use_case_get(snd_use_case_mgr_t *uc_mgr,
                }
 
                err = get_value(uc_mgr, ident, (char **)value, mod_dev, verb,
-                               exact);
+                               exact);
                if (ident != identifier)
                        free((void *)ident);
                if (mod_dev)
                        free((void *)mod_dev);
-        }
+       }
       __end:
        pthread_mutex_unlock(&uc_mgr->mutex);
-        return err;
+       return err;
 }
 
 
@@ -1834,29 +1833,29 @@ int snd_use_case_geti(snd_use_case_mgr_t *uc_mgr,
                      const char *identifier,
                      long *value)
 {
-        char *str, *str1;
-        long err;
+       char *str, *str1;
+       long err;
 
        pthread_mutex_lock(&uc_mgr->mutex);
-        if (0) {
-                /* nothing here - prepared for fixed identifiers */
-        } else {
-                str1 = strchr(identifier, '/');
-                if (str1) {
-                        str = strdup(str1 + 1);
-                       if (str == NULL) {
-                               err = -ENOMEM;
-                               goto __end;
-                        }
-                } else {
-                        str = NULL;
-                }
-                if (check_identifier(identifier, "_devstatus")) {
+       if (0) {
+               /* nothing here - prepared for fixed identifiers */
+       } else {
+               str1 = strchr(identifier, '/');
+               if (str1) {
+                       str = strdup(str1 + 1);
+                       if (str == NULL) {
+                               err = -ENOMEM;
+                               goto __end;
+                       }
+               } else {
+                       str = NULL;
+               }
+               if (check_identifier(identifier, "_devstatus")) {
                        if (!str) {
                                err = -EINVAL;
                                goto __end;
                        }
-                        err = device_status(uc_mgr, str);
+                       err = device_status(uc_mgr, str);
                        if (err >= 0) {
                                *value = err;
                                err = 0;
@@ -1866,7 +1865,7 @@ int snd_use_case_geti(snd_use_case_mgr_t *uc_mgr,
                                err = -EINVAL;
                                goto __end;
                        }
-                        err = modifier_status(uc_mgr, str);
+                       err = modifier_status(uc_mgr, str);
                        if (err >= 0) {
                                *value = err;
                                err = 0;
@@ -1880,13 +1879,13 @@ int snd_use_case_geti(snd_use_case_mgr_t *uc_mgr,
                        err = -ENOENT;
 #endif
                } else
-                        err = -ENOENT;
-                if (str)
-                        free(str);
-        }
+                       err = -ENOENT;
+               if (str)
+                       free(str);
+       }
       __end:
        pthread_mutex_unlock(&uc_mgr->mutex);
-        return err;
+       return err;
 }
 
 static int set_fixedboot_user(snd_use_case_mgr_t *uc_mgr,
@@ -1936,199 +1935,199 @@ static int set_defaults_user(snd_use_case_mgr_t *uc_mgr,
 }
 
 static int handle_transition_verb(snd_use_case_mgr_t *uc_mgr,
-                                  struct use_case_verb *new_verb)
+                                 struct use_case_verb *new_verb)
 {
-        struct list_head *pos;
-        struct transition_sequence *trans;
-        int err;
+       struct list_head *pos;
+       struct transition_sequence *trans;
+       int err;
 
-        list_for_each(pos, &uc_mgr->active_verb->transition_list) {
-                trans = list_entry(pos, struct transition_sequence, list);
-                if (strcmp(trans->name, new_verb->name) == 0) {
-                        err = execute_sequence(uc_mgr, &trans->transition_list,
+       list_for_each(pos, &uc_mgr->active_verb->transition_list) {
+               trans = list_entry(pos, struct transition_sequence, list);
+               if (strcmp(trans->name, new_verb->name) == 0) {
+                       err = execute_sequence(uc_mgr, &trans->transition_list,
                                               &uc_mgr->active_verb->value_list,
                                               &uc_mgr->value_list,
                                               NULL);
-                        if (err >= 0)
-                                return 1;
-                        return err;
-                }
-        }
-        return 0;
+                       if (err >= 0)
+                               return 1;
+                       return err;
+               }
+       }
+       return 0;
 }
 
 static int set_verb_user(snd_use_case_mgr_t *uc_mgr,
-                         const char *verb_name)
-{
-        struct use_case_verb *verb;
-        int err = 0;
-
-        if (uc_mgr->active_verb &&
-            strcmp(uc_mgr->active_verb->name, verb_name) == 0)
-                return 0;
-        if (strcmp(verb_name, SND_USE_CASE_VERB_INACTIVE) != 0) {
-                verb = find_verb(uc_mgr, verb_name);
-                if (verb == NULL)
-                        return -ENOENT;
-        } else {
-                verb = NULL;
-        }
-        if (uc_mgr->active_verb) {
-                err = handle_transition_verb(uc_mgr, verb);
-                if (err == 0) {
-                        err = dismantle_use_case(uc_mgr);
-                        if (err < 0)
-                                return err;
-                } else if (err == 1) {
-                        uc_mgr->active_verb = verb;
-                        verb = NULL;
-                } else {
-                        verb = NULL; /* show error */
-                }
-        }
-        if (verb) {
-                err = set_verb(uc_mgr, verb, 1);
-                if (err < 0)
-                        uc_error("error: failed to initialize new use case: %s",
-                                 verb_name);
-        }
-        return err;
+                        const char *verb_name)
+{
+       struct use_case_verb *verb;
+       int err = 0;
+
+       if (uc_mgr->active_verb &&
+           strcmp(uc_mgr->active_verb->name, verb_name) == 0)
+               return 0;
+       if (strcmp(verb_name, SND_USE_CASE_VERB_INACTIVE) != 0) {
+               verb = find_verb(uc_mgr, verb_name);
+               if (verb == NULL)
+                       return -ENOENT;
+       } else {
+               verb = NULL;
+       }
+       if (uc_mgr->active_verb) {
+               err = handle_transition_verb(uc_mgr, verb);
+               if (err == 0) {
+                       err = dismantle_use_case(uc_mgr);
+                       if (err < 0)
+                               return err;
+               } else if (err == 1) {
+                       uc_mgr->active_verb = verb;
+                       verb = NULL;
+               } else {
+                       verb = NULL; /* show error */
+               }
+       }
+       if (verb) {
+               err = set_verb(uc_mgr, verb, 1);
+               if (err < 0)
+                       uc_error("error: failed to initialize new use case: %s",
+                                verb_name);
+       }
+       return err;
 }
 
 
 static int set_device_user(snd_use_case_mgr_t *uc_mgr,
-                           const char *device_name,
-                           int enable)
+                          const char *device_name,
+                          int enable)
 {
-        struct use_case_device *device;
+       struct use_case_device *device;
 
-        if (uc_mgr->active_verb == NULL)
-                return -ENOENT;
-        device = find_device(uc_mgr, uc_mgr->active_verb, device_name, 1);
-        if (device == NULL)
-                return -ENOENT;
-        return set_device(uc_mgr, device, enable);
+       if (uc_mgr->active_verb == NULL)
+               return -ENOENT;
+       device = find_device(uc_mgr, uc_mgr->active_verb, device_name, 1);
+       if (device == NULL)
+               return -ENOENT;
+       return set_device(uc_mgr, device, enable);
 }
 
 static int set_modifier_user(snd_use_case_mgr_t *uc_mgr,
-                             const char *modifier_name,
-                             int enable)
+                            const char *modifier_name,
+                            int enable)
 {
-        struct use_case_modifier *modifier;
+       struct use_case_modifier *modifier;
 
-        if (uc_mgr->active_verb == NULL)
-                return -ENOENT;
+       if (uc_mgr->active_verb == NULL)
+               return -ENOENT;
 
-        modifier = find_modifier(uc_mgr, uc_mgr->active_verb, modifier_name, 1);
-        if (modifier == NULL)
-                return -ENOENT;
-        return set_modifier(uc_mgr, modifier, enable);
+       modifier = find_modifier(uc_mgr, uc_mgr->active_verb, modifier_name, 1);
+       if (modifier == NULL)
+               return -ENOENT;
+       return set_modifier(uc_mgr, modifier, enable);
 }
 
 static int switch_device(snd_use_case_mgr_t *uc_mgr,
-                         const char *old_device,
-                         const char *new_device)
-{
-        struct use_case_device *xold, *xnew;
-        struct transition_sequence *trans;
-        struct list_head *pos;
-        int err, seq_found = 0;
-        
-        if (uc_mgr->active_verb == NULL)
-                return -ENOENT;
-        if (device_status(uc_mgr, old_device) == 0) {
-                uc_error("error: device %s not enabled", old_device);
-                return -EINVAL;
-        }
-        if (device_status(uc_mgr, new_device) != 0) {
-                uc_error("error: device %s already enabled", new_device);
-                return -EINVAL;
-        }
-        xold = find_device(uc_mgr, uc_mgr->active_verb, old_device, 1);
-        if (xold == NULL)
-                return -ENOENT;
-        list_del(&xold->active_list);
-        xnew = find_device(uc_mgr, uc_mgr->active_verb, new_device, 1);
-        list_add_tail(&xold->active_list, &uc_mgr->active_devices);
-        if (xnew == NULL)
-                return -ENOENT;
-        err = 0;
-        list_for_each(pos, &xold->transition_list) {
-                trans = list_entry(pos, struct transition_sequence, list);
-                if (strcmp(trans->name, new_device) == 0) {
-                        err = execute_sequence(uc_mgr, &trans->transition_list,
+                        const char *old_device,
+                        const char *new_device)
+{
+       struct use_case_device *xold, *xnew;
+       struct transition_sequence *trans;
+       struct list_head *pos;
+       int err, seq_found = 0;
+
+       if (uc_mgr->active_verb == NULL)
+               return -ENOENT;
+       if (device_status(uc_mgr, old_device) == 0) {
+               uc_error("error: device %s not enabled", old_device);
+               return -EINVAL;
+       }
+       if (device_status(uc_mgr, new_device) != 0) {
+               uc_error("error: device %s already enabled", new_device);
+               return -EINVAL;
+       }
+       xold = find_device(uc_mgr, uc_mgr->active_verb, old_device, 1);
+       if (xold == NULL)
+               return -ENOENT;
+       list_del(&xold->active_list);
+       xnew = find_device(uc_mgr, uc_mgr->active_verb, new_device, 1);
+       list_add_tail(&xold->active_list, &uc_mgr->active_devices);
+       if (xnew == NULL)
+               return -ENOENT;
+       err = 0;
+       list_for_each(pos, &xold->transition_list) {
+               trans = list_entry(pos, struct transition_sequence, list);
+               if (strcmp(trans->name, new_device) == 0) {
+                       err = execute_sequence(uc_mgr, &trans->transition_list,
                                               &xold->value_list,
                                               &uc_mgr->active_verb->value_list,
                                               &uc_mgr->value_list);
-                        if (err >= 0) {
-                                list_del(&xold->active_list);
-                                list_add_tail(&xnew->active_list, &uc_mgr->active_devices);
-                        }
-                        seq_found = 1;
-                        break;
-                }
-        }
-        if (!seq_found) {
-                err = set_device(uc_mgr, xold, 0);
-                if (err < 0)
-                        return err;
-                err = set_device(uc_mgr, xnew, 1);
-                if (err < 0)
-                        return err;
-        }
-        return err;
+                       if (err >= 0) {
+                               list_del(&xold->active_list);
+                               list_add_tail(&xnew->active_list, &uc_mgr->active_devices);
+                       }
+                       seq_found = 1;
+                       break;
+               }
+       }
+       if (!seq_found) {
+               err = set_device(uc_mgr, xold, 0);
+               if (err < 0)
+                       return err;
+               err = set_device(uc_mgr, xnew, 1);
+               if (err < 0)
+                       return err;
+       }
+       return err;
 }
 
 static int switch_modifier(snd_use_case_mgr_t *uc_mgr,
-                           const char *old_modifier,
-                           const char *new_modifier)
-{
-        struct use_case_modifier *xold, *xnew;
-        struct transition_sequence *trans;
-        struct list_head *pos;
-        int err, seq_found = 0;
-        
-        if (uc_mgr->active_verb == NULL)
-                return -ENOENT;
-        if (modifier_status(uc_mgr, old_modifier) == 0) {
-                uc_error("error: modifier %s not enabled", old_modifier);
-                return -EINVAL;
-        }
-        if (modifier_status(uc_mgr, new_modifier) != 0) {
-                uc_error("error: modifier %s already enabled", new_modifier);
-                return -EINVAL;
-        }
-        xold = find_modifier(uc_mgr, uc_mgr->active_verb, old_modifier, 1);
-        if (xold == NULL)
-                return -ENOENT;
-        xnew = find_modifier(uc_mgr, uc_mgr->active_verb, new_modifier, 1);
-        if (xnew == NULL)
-                return -ENOENT;
-        err = 0;
-        list_for_each(pos, &xold->transition_list) {
-                trans = list_entry(pos, struct transition_sequence, list);
-                if (strcmp(trans->name, new_modifier) == 0) {
-                        err = execute_sequence(uc_mgr, &trans->transition_list,
+                          const char *old_modifier,
+                          const char *new_modifier)
+{
+       struct use_case_modifier *xold, *xnew;
+       struct transition_sequence *trans;
+       struct list_head *pos;
+       int err, seq_found = 0;
+
+       if (uc_mgr->active_verb == NULL)
+               return -ENOENT;
+       if (modifier_status(uc_mgr, old_modifier) == 0) {
+               uc_error("error: modifier %s not enabled", old_modifier);
+               return -EINVAL;
+       }
+       if (modifier_status(uc_mgr, new_modifier) != 0) {
+               uc_error("error: modifier %s already enabled", new_modifier);
+               return -EINVAL;
+       }
+       xold = find_modifier(uc_mgr, uc_mgr->active_verb, old_modifier, 1);
+       if (xold == NULL)
+               return -ENOENT;
+       xnew = find_modifier(uc_mgr, uc_mgr->active_verb, new_modifier, 1);
+       if (xnew == NULL)
+               return -ENOENT;
+       err = 0;
+       list_for_each(pos, &xold->transition_list) {
+               trans = list_entry(pos, struct transition_sequence, list);
+               if (strcmp(trans->name, new_modifier) == 0) {
+                       err = execute_sequence(uc_mgr, &trans->transition_list,
                                               &xold->value_list,
                                               &uc_mgr->active_verb->value_list,
                                               &uc_mgr->value_list);
-                        if (err >= 0) {
-                                list_del(&xold->active_list);
-                                list_add_tail(&xnew->active_list, &uc_mgr->active_modifiers);
-                        }
-                        seq_found = 1;
-                        break;
-                }
-        }
-        if (!seq_found) {
-                err = set_modifier(uc_mgr, xold, 0);
-                if (err < 0)
-                        return err;
-                err = set_modifier(uc_mgr, xnew, 1);
-                if (err < 0)
-                        return err;
-        }
-        return err;        
+                       if (err >= 0) {
+                               list_del(&xold->active_list);
+                               list_add_tail(&xnew->active_list, &uc_mgr->active_modifiers);
+                       }
+                       seq_found = 1;
+                       break;
+               }
+       }
+       if (!seq_found) {
+               err = set_modifier(uc_mgr, xold, 0);
+               if (err < 0)
+                       return err;
+               err = set_modifier(uc_mgr, xnew, 1);
+               if (err < 0)
+                       return err;
+       }
+       return err;
 }
 
 /**
@@ -2139,8 +2138,8 @@ static int switch_modifier(snd_use_case_mgr_t *uc_mgr,
  * \return Zero if success, otherwise a negative error code
  */
 int snd_use_case_set(snd_use_case_mgr_t *uc_mgr,
-                     const char *identifier,
-                     const char *value)
+                    const char *identifier,
+                    const char *value)
 {
        char *str, *str1;
        int err = 0;
@@ -2153,39 +2152,39 @@ int snd_use_case_set(snd_use_case_mgr_t *uc_mgr,
        else if (strcmp(identifier, "_defaults") == 0)
                err = set_defaults_user(uc_mgr, value);
        else if (strcmp(identifier, "_verb") == 0)
-               err = set_verb_user(uc_mgr, value);
-        else if (strcmp(identifier, "_enadev") == 0)
-                err = set_device_user(uc_mgr, value, 1);
-        else if (strcmp(identifier, "_disdev") == 0)
-                err = set_device_user(uc_mgr, value, 0);
-        else if (strcmp(identifier, "_enamod") == 0)
-                err = set_modifier_user(uc_mgr, value, 1);
-        else if (strcmp(identifier, "_dismod") == 0)
-                err = set_modifier_user(uc_mgr, value, 0);
-        else {
-                str1 = strchr(identifier, '/');
-                if (str1) {
-                        str = strdup(str1 + 1);
-                       if (str == NULL) {
-                               err = -ENOMEM;
-                               goto __end;
-                        }
-                } else {
-                        err = -EINVAL;
-                        goto __end;
-                }
-                if (check_identifier(identifier, "_swdev"))
-                        err = switch_device(uc_mgr, str, value);
-                else if (check_identifier(identifier, "_swmod"))
-                        err = switch_modifier(uc_mgr, str, value);
-                else
-                        err = -EINVAL;
-                if (str)
-                        free(str);
-        }
+               err = set_verb_user(uc_mgr, value);
+       else if (strcmp(identifier, "_enadev") == 0)
+               err = set_device_user(uc_mgr, value, 1);
+       else if (strcmp(identifier, "_disdev") == 0)
+               err = set_device_user(uc_mgr, value, 0);
+       else if (strcmp(identifier, "_enamod") == 0)
+               err = set_modifier_user(uc_mgr, value, 1);
+       else if (strcmp(identifier, "_dismod") == 0)
+               err = set_modifier_user(uc_mgr, value, 0);
+       else {
+               str1 = strchr(identifier, '/');
+               if (str1) {
+                       str = strdup(str1 + 1);
+                       if (str == NULL) {
+                               err = -ENOMEM;
+                               goto __end;
+                       }
+               } else {
+                       err = -EINVAL;
+                       goto __end;
+               }
+               if (check_identifier(identifier, "_swdev"))
+                       err = switch_device(uc_mgr, str, value);
+               else if (check_identifier(identifier, "_swmod"))
+                       err = switch_modifier(uc_mgr, str, value);
+               else
+                       err = -EINVAL;
+               if (str)
+                       free(str);
+       }
       __end:
        pthread_mutex_unlock(&uc_mgr->mutex);
-        return err;
+       return err;
 }
 
 /**